-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Combinators for building memo tables.
--   
--   Combinators for building memo tables.
@package data-memocombinators
@version 0.5.1


-- | This module provides combinators for building memo tables over various
--   data types, so that the type of table can be customized depending on
--   the application.
--   
--   This module is designed to be imported <i>qualified</i>, eg.
--   
--   <pre>
--   import qualified Data.MemoCombinators as Memo
--   </pre>
--   
--   Usage is straightforward: apply an object of type <tt>Memo a</tt> to a
--   function of type <tt>a -&gt; b</tt>, and get a memoized function of
--   type <tt>a -&gt; b</tt>. For example:
--   
--   <pre>
--   fib = Memo.integral fib'
--      where
--      fib' 0 = 0
--      fib' 1 = 1
--      fib' x = fib (x-1) + fib (x-2)
--   </pre>
module Data.MemoCombinators

-- | The type of a memo table for functions of a.
type Memo a = forall r. (a -> r) -> (a -> r)

-- | Given a memoizer for a and an isomorphism between a and b, build a
--   memoizer for b.
wrap :: (a -> b) -> (b -> a) -> Memo a -> Memo b

-- | Memoize a two argument function (just apply the table directly for
--   single argument functions).
memo2 :: Memo a -> Memo b -> (a -> b -> r) -> (a -> b -> r)

-- | Memoize a three argument function.
memo3 :: Memo a -> Memo b -> Memo c -> (a -> b -> c -> r) -> (a -> b -> c -> r)

-- | Memoize the second argument of a function.
memoSecond :: Memo b -> (a -> b -> r) -> (a -> b -> r)

-- | Memoize the third argument of a function.
memoThird :: Memo c -> (a -> b -> c -> r) -> (a -> b -> c -> r)
bool :: Memo Bool
char :: Memo Char
list :: Memo a -> Memo [a]

-- | Build a table which memoizes all lists of less than the given length.
boundedList :: Int -> Memo a -> Memo [a]
either :: Memo a -> Memo b -> Memo (Either a b)
maybe :: Memo a -> Memo (Maybe a)
unit :: Memo ()
pair :: Memo a -> Memo b -> Memo (a, b)

-- | Memoize an enum type.
enum :: Enum a => Memo a

-- | Memoize an integral type.
integral :: Integral a => Memo a

-- | Memoize an ordered type with a bits instance.
bits :: (Num a, Ord a, Bits a) => Memo a

-- | <tt>switch p a b</tt> uses the memo table a whenever p gives true and
--   the memo table b whenever p gives false.
switch :: (a -> Bool) -> Memo a -> Memo a -> Memo a

-- | The type of builders for ranged tables; takes a lower bound and an
--   upper bound, and returns a memo table for that range.
type RangeMemo a = (a, a) -> Memo a

-- | Build a memo table for a range using a flat array. If items are given
--   outside the range, don't memoize.
arrayRange :: Ix a => RangeMemo a

-- | Build a memo table for a range using a flat array. If items are given
--   outside the range, behavior is undefined.
unsafeArrayRange :: Ix a => RangeMemo a

-- | Given a list of ranges, (lazily) build a memo table for each one and
--   combine them using linear search.
chunks :: Ix a => RangeMemo a -> [(a, a)] -> Memo a

module Data.MemoCombinators.Class

-- | The class of types which have complete memo tables.
class MemoTable a
table :: MemoTable a => Memo a

-- | The class of functions which can be completely memoized.
class Memoizable a
memoize :: Memoizable a => a -> a
instance MemoTable a => Memoizable (a -> b)
instance (Integral a, MemoTable a) => MemoTable (Ratio a)
instance (MemoTable a, MemoTable b) => MemoTable (Either a b)
instance MemoTable a => MemoTable (Maybe a)
instance MemoTable a => MemoTable [a]
instance (MemoTable a, MemoTable b, MemoTable c, MemoTable d, MemoTable e, MemoTable f, MemoTable g, MemoTable h, MemoTable i, MemoTable j, MemoTable k, MemoTable l, MemoTable m, MemoTable n, MemoTable o) => MemoTable (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
instance (MemoTable a, MemoTable b, MemoTable c, MemoTable d, MemoTable e, MemoTable f, MemoTable g, MemoTable h, MemoTable i, MemoTable j, MemoTable k, MemoTable l, MemoTable m, MemoTable n) => MemoTable (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
instance (MemoTable a, MemoTable b, MemoTable c, MemoTable d, MemoTable e, MemoTable f, MemoTable g, MemoTable h, MemoTable i, MemoTable j, MemoTable k, MemoTable l, MemoTable m) => MemoTable (a, b, c, d, e, f, g, h, i, j, k, l, m)
instance (MemoTable a, MemoTable b, MemoTable c, MemoTable d, MemoTable e, MemoTable f, MemoTable g, MemoTable h, MemoTable i, MemoTable j, MemoTable k, MemoTable l) => MemoTable (a, b, c, d, e, f, g, h, i, j, k, l)
instance (MemoTable a, MemoTable b, MemoTable c, MemoTable d, MemoTable e, MemoTable f, MemoTable g, MemoTable h, MemoTable i, MemoTable j, MemoTable k) => MemoTable (a, b, c, d, e, f, g, h, i, j, k)
instance (MemoTable a, MemoTable b, MemoTable c, MemoTable d, MemoTable e, MemoTable f, MemoTable g, MemoTable h, MemoTable i, MemoTable j) => MemoTable (a, b, c, d, e, f, g, h, i, j)
instance (MemoTable a, MemoTable b, MemoTable c, MemoTable d, MemoTable e, MemoTable f, MemoTable g, MemoTable h, MemoTable i) => MemoTable (a, b, c, d, e, f, g, h, i)
instance (MemoTable a, MemoTable b, MemoTable c, MemoTable d, MemoTable e, MemoTable f, MemoTable g, MemoTable h) => MemoTable (a, b, c, d, e, f, g, h)
instance (MemoTable a, MemoTable b, MemoTable c, MemoTable d, MemoTable e, MemoTable f, MemoTable g) => MemoTable (a, b, c, d, e, f, g)
instance (MemoTable a, MemoTable b, MemoTable c, MemoTable d, MemoTable e, MemoTable f) => MemoTable (a, b, c, d, e, f)
instance (MemoTable a, MemoTable b, MemoTable c, MemoTable d, MemoTable e) => MemoTable (a, b, c, d, e)
instance (MemoTable a, MemoTable b, MemoTable c, MemoTable d) => MemoTable (a, b, c, d)
instance (MemoTable a, MemoTable b, MemoTable c) => MemoTable (a, b, c)
instance (MemoTable a, MemoTable b) => MemoTable (a, b)
instance MemoTable ()
instance MemoTable Word64
instance MemoTable Word32
instance MemoTable Word16
instance MemoTable Word8
instance MemoTable Word
instance MemoTable Ordering
instance MemoTable Integer
instance MemoTable Int64
instance MemoTable Int32
instance MemoTable Int16
instance MemoTable Int8
instance MemoTable Int
instance MemoTable Char
instance MemoTable Bool
