A memoization class. An instance Memoizable T for some type T means that that memoize method can memoize for parameters of type T.

Memoize a two argument function

Memoize a three argument function

Memoize a four argument function

Memoize a five argument function

Memoize a six argument function

Memoize a seven argument function

Memoizes the least fixed point of a function. This is like fix, but it passes the fixed function a memoized version of itself, so this memoizes using all recursive calls as well.

Two argument version of memoFix.

Three argument version of memoFix.

Four argument version of memoFix.

Five argument version of memoFix.

Six argument version of memoFix.

Seven argument version of memoFix.

Give a one-argument function whose argument satisfies Show, this memoizes the function such that the argument is shown (using trace) only when the function has to be applied, as opposed to when the answer is available in the memo cache.

Can be used to memoize over any "finite" type satisfying Enum and Bounded. This builds a binary search tree, treating the memoized type as isomorphic to a range of Int, so it will be only as efficient as toEnum, fromEnum, succ, and pred.

This can be used to make instances for finite types. For example, the instances for Int and Char are declared as:

  instance Memoizable Int where memoize = memoizeFinite
  instance Memoizable Char where memoize = memoizeFinite

To derive Memoizable instances for the given data types. In the simplest usage, to derive Memoizable for an algebraic datatype named T, write:

  deriveMemoizable ''T

This assumes that all the type parameters of T that are not annotated with a kind other than * should be listed as requiring Memoizable instances in the instance context. For example, given a data type declared as

  data T a (b :: * -> *) c = ...

the generated instance will look like

  instance (Memoizable a, Memoizable c) =>
           Memoizable (T a b c) where ...

For more precise control over the context, use deriveMemoizableParams.

N.B.: The TemplateHaskell language extension must be enabled to use this function.

Like deriveMemoizable but takes a second argument, which is a list of Ints to specify which type parameters of the type should be mentioned in the context. For example, given the same definition for T as above, we can write

   deriveMemoizableParams ''T [3]

to leave the first parameter of T out of the context and show only the third, yielding the instance

  instance Memoizable c => Memoizable (T a b c) where ...

N.B.: The TemplateHaskell language extension must be enabled to use this function.

In cases where neither deriveMemoizable nor deriveMemoizableParams can figure out the right context for an instance declaration, one can declare the instance manually and use this function to derive the method body for memoize. For example, suppose that a data type T is defined as:

  data T a b = T (a -> Bool) b

For T a b to be memoizable, a -> Bool must be, and based on the instance for (->), this means that a must satisfy Bounded and Enum, so deriveMemoizable cannot build the right context for the Memoizable instance. Instead, one can write:

  instance (Eq a, Enum a, Bounded a, Memoizable b) =>
           Memoizable (T a b) where
    memoize = $(deriveMemoize ''T)