FunctorCombo.StrictMemo

Functor-based memo tries (strict for now)

Documentation

class Functor (Trie k) => HasTrie k where

Domain types with associated memo tries

Associated Types

type Trie k :: * -> *

Representation of trie with domain type a

Methods

trie :: (k -> v) -> k :->: v

Create the trie for the entire domain of a function

untrie :: (k :->: v) -> k -> v

Convert k trie to k function, i.e., access k field of the trie

Instances

HasTrie Bool

HasTrie Int

HasTrie Integer

HasTrie ()

(Functor (Trie [a]), HasTrie a) => HasTrie [a]

(Functor (Trie (Id a)), HasTrie a) => HasTrie (Id a)

(Functor (Trie (Tree a)), HasTrie a) => HasTrie (Tree a)

(Functor (Trie (Pair a)), HasTrie a) => HasTrie (Pair a)

(Functor (Trie (a -> b)), HasTrie a, HasTrie (:->: a b)) => HasTrie (a -> b)

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

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

(Functor (Trie (Const x a)), HasTrie x) => HasTrie (Const x a)

(Functor (Trie (TreeTrie a v)), HasTrie (:->: (PF (Tree a) (Tree a)) v)) => HasTrie (TreeTrie a v)

(Functor (Trie (ListTrie a v)), HasTrie (:->: (PF [a] [a]) v)) => HasTrie (ListTrie a v)

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

(Functor (Trie (:. g f a)), HasTrie (g (f a))) => HasTrie (:. g f a)

(Functor (Trie (:+: f g a)), HasTrie (f a), HasTrie (g a)) => HasTrie (:+: f g a)

(Functor (Trie (:*: f g a)), HasTrie (f a), HasTrie (g a)) => HasTrie (:*: f g a)

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

type :->: k v = Trie k v

Memo trie from k to v

memo :: HasTrie k => Unop (k -> v)

Trie-based function memoizer

memo2 :: (HasTrie s, HasTrie t) => Unop (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) => Unop (r -> s -> t -> a)

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

idTrie :: HasTrie k => k :->: k

onUntrie :: (HasTrie a, HasTrie b) => ((a -> a') -> b -> b') -> (a :->: a') -> b :->: b'

onUntrie2 :: (HasTrie a, HasTrie b, HasTrie c) => ((a -> a') -> (b -> b') -> c -> c') -> (a :->: a') -> (b :->: b') -> c :->: c'