Data.Functor.Representable.Trie

Representations of polynomial functors

class (Adjustable (BaseTrie a), TraversableWithKey1 (BaseTrie a), Representable (BaseTrie a)) => HasTrie a where

Associated Types

type BaseTrie a :: * -> *

Methods

embedKey :: a -> Key (BaseTrie a)

projectKey :: Key (BaseTrie a) -> a

Instances

HasTrie Bool

HasTrie Char

HasTrie Int

HasTrie ()

HasTrie Any

HasTrie a => HasTrie [a]

HasTrie a => HasTrie (Dual a)

HasTrie a => HasTrie (Sum a)

HasTrie a => HasTrie (Product a)

HasTrie a => HasTrie (Maybe a)

HasTrie a => HasTrie (Seq a)

HasTrie v => HasTrie (IntMap v)

(HasTrie a, HasTrie b) => HasTrie (Either a b)

(HasTrie a, HasTrie b) => HasTrie (a, b)

(HasTrie k, HasTrie v) => HasTrie (Map k v)

(HasTrie a, HasTrie b) => HasTrie (Entry a b)

(HasTrie a, HasTrie b, HasTrie c) => HasTrie (a, b, c)

(HasTrie a, HasTrie b, HasTrie c, HasTrie d) => HasTrie (a, b, c, d)

Memoizing functions

mup :: HasTrie t => (b -> c) -> (t -> b) -> t -> c

Lift a memoizer to work with one more argument.

memo :: HasTrie t => (t -> a) -> t -> a

memo2 :: (HasTrie s, HasTrie t) => (s -> t -> a) -> s -> t -> a

Memoize a binary function, on its first argument and then on its second. Take care to exploit any partial evaluation.

memo3 :: (HasTrie r, HasTrie s, HasTrie t) => (r -> s -> t -> a) -> r -> s -> t -> a

Memoize a ternary function on successive arguments. Take care to exploit any partial evaluation.

inTrie :: (HasTrie a, HasTrie c) => ((a -> b) -> c -> d) -> (a :->: b) -> c :->: d

Apply a unary function inside of a tabulate

inTrie2 :: (HasTrie a, HasTrie c, HasTrie e) => ((a -> b) -> (c -> d) -> e -> f) -> (a :->: b) -> (c :->: d) -> e :->: f

Apply a binary function inside of a tabulate

inTrie3 :: (HasTrie a, HasTrie c, HasTrie e, HasTrie g) => ((a -> b) -> (c -> d) -> (e -> f) -> g -> h) -> (a :->: b) -> (c :->: d) -> (e :->: f) -> g :->: h

Apply a ternary function inside of a tabulate

Workarounds for current GHC limitations

trie :: HasTrie t => (t -> a) -> t :->: a

untrie :: (t :->: a) -> t -> a

data a :->: b where

Constructors

Trie :: HasTrie a => BaseTrie a b -> a :->: b

Instances

Semigroupoid :->:

HasTrie a => MonadReader a (:->: a)

HasTrie a => Monad (:->: a)

Functor (:->: a)

HasTrie a => Applicative (:->: a)

Foldable (:->: a)

Traversable (:->: a)

(HasTrie m, Semigroup m, Monoid m) => Comonad (:->: m)

(HasTrie m, Semigroup m) => Extend (:->: m)

HasTrie e => Distributive (:->: e)

Foldable1 (:->: a)

Traversable1 (:->: a)

Keyed (:->: a)

Indexable (:->: e)

HasTrie e => Adjustable (:->: e)

FoldableWithKey (:->: a)

FoldableWithKey1 (:->: a)

TraversableWithKey (:->: a)

TraversableWithKey1 (:->: a)

HasTrie e => Representable (:->: e)

Apply (:->: a)

Bind (:->: a)

HasTrie e => Adjunction (Entry e) (:->: e)

Eq b => Eq (:->: a b)

Ord b => Ord (:->: a b)

(Show a, Show b) => Show (:->: a b)

data Entry a b

Constructors

Entry a b

Instances

Functor (Entry a)

HasTrie e => Adjunction (Entry e) (:->: e)

(HasTrie a, HasTrie b) => HasTrie (Entry a b)

runTrie :: (a :->: b) -> BaseTrie a b