An alternative to representable functors
The library provides a Memoizer
type class similar to Representable
(from adjunctions
)
that is suitable for containers with size known only at runtime. The only difference between
those type classes is that Memoizer
passes helper information to the tabulate
function.
{-# LANGUAGE TypeFamilies #-}
class Memoizer t where
-- Rep t
type Arg t
-- Helps memoizer to know all possible function inputs.
type DomainHint t
-- tabulate
remember :: (Arg t -> a) -> DomainHint t -> t a
-- index
recall :: t a -> Arg t -> a
recallMaybe :: t a -> Arg t -> Maybe a
{-# MINIMAL remember, (recall | recallMaybe) #-}
Instances
Data type | Arg |
DomainHint |
Does support unsafe indexing? |
---|---|---|---|
any Representable Functor |
Representable f => Rep f |
() (none) |
|
Array , UArray |
Ix i => i |
Ix i => (i, i) (range of the array) |
Yes |
boxed/unboxed/storable Vector |
Int |
Int (length of the array) |
Yes |
HashMap |
(Hashable k, Eq k) => k |
(Hashable k, Eq k) => [k] (all the function inputs) |
|
Map |
Ord k => k |
Ord k => [k] (all the function inputs) |
|
IntMap |
Int |
[Int] (all the function inputs) |
Store
comonad
The library also provides StoreT
comonad transformer that uses Memoizer
under the hood.
data StoreT memoizer w a
= StoreT (w (memoizer a)) (DomainHint memoizer) (Arg memoizer)
Is there a documentation?
The source code has a few Haddock documentation, so you can run stack haddock
to render it.