Control.Monad.Memo.Class

Computation type:

Interface for monadic computations which can be memoized.

Documentation

class Monad m => MonadCache k v m | m -> k, m -> v where

Interface for memoization cache Is necessary since memoization mechanism from one transformer can use a cache from other (further down the stack)

Methods

lookup :: k -> m (Maybe v)

add :: k -> v -> m ()

Instances

(Monad m, MapLike c k v) => MonadCache k v (MemoStateT c k v m)

class Monad m => MonadMemo k v m | m -> k, m -> v where

Memoization interface

Methods

memo :: (k -> m v) -> k -> m v

Instances

MonadCache k [v] m => MonadMemo k v (ListT m)

MonadCache k (Maybe v) m => MonadMemo k v (MaybeT m)

MonadCache k v m => MonadMemo k v (IdentityT m)

MonadCache (s, k) v m => MonadMemo k v (StateT s m)

MonadCache (s, k) v m => MonadMemo k v (StateT s m)

(Monoid w, MonadCache k (v, w) m) => MonadMemo k v (WriterT w m)

(Monoid w, MonadCache k (v, w) m) => MonadMemo k v (WriterT w m)

MonadCache (r, k) v m => MonadMemo k v (ReaderT r m)

(Error e, MonadCache k (Either e v) m) => MonadMemo k v (ErrorT e m)

MonadCache k v m => MonadMemo k v (ContT r m)

(Monad m, MapLike c k v) => MonadMemo k v (MemoStateT c k v m)

for2 :: (((k1, k2) -> mv) -> (k1, k2) -> mv) -> (k1 -> k2 -> mv) -> k1 -> k2 -> mv

Adapter for memoization of two-argument function

for3 :: (((k1, k2, k3) -> mv) -> (k1, k2, k3) -> mv) -> (k1 -> k2 -> k3 -> mv) -> k1 -> k2 -> k3 -> mv

Adapter for memoization of three-argument function

for4 :: (((k1, k2, k3, k4) -> mv) -> (k1, k2, k3, k4) -> mv) -> (k1 -> k2 -> k3 -> k4 -> mv) -> k1 -> k2 -> k3 -> k4 -> mv

Adapter for memoization of four-argument function

memoln :: (MonadCache k2 v m1, Monad m1, Monad m2) => (forall a. m1 a -> m2 a) -> (k1 -> k2) -> (k1 -> m2 v) -> k1 -> m2 v

Memoization for the current transformer in stack using a cache from an arbitrary transformer down the stack

memol0 :: (MonadCache k v m, Monad m) => (k -> m v) -> k -> m v

Uses current monad's memoization cache

memol1 :: (MonadTrans t1, MonadCache k v m, Monad (t1 m)) => (k -> t1 m v) -> k -> t1 m v

Uses the 1st transformer in stack for memoization cache

memol2 :: (MonadTrans t1, MonadTrans t2, MonadCache k v m, Monad (t2 m), Monad (t1 (t2 m))) => (k -> t1 (t2 m) v) -> k -> t1 (t2 m) v

Uses the 2nd transformer in stack for memoization cache

memol3 :: (MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadCache k v m, Monad (t3 m), Monad (t2 (t3 m)), Monad (t1 (t2 (t3 m)))) => (k -> t1 (t2 (t3 m)) v) -> k -> t1 (t2 (t3 m)) v

Uses the 3rd transformer in stack for memoization cache

memol4 :: (MonadTrans t1, MonadTrans t2, MonadTrans t3, MonadTrans t4, MonadCache k v m, Monad (t4 m), Monad (t3 (t4 m)), Monad (t2 (t3 (t4 m))), Monad (t1 (t2 (t3 (t4 m))))) => (k -> t1 (t2 (t3 (t4 m))) v) -> k -> t1 (t2 (t3 (t4 m))) v

Uses the 4th transformer in stack for memoization cache