Module Memoize.ForType

ForType is a special case of Make where it suffices to pass an arbitrary type T as an argument. A hash table is used to hold the memoization table. OCaml's built-in generic equality and hash functions are used.

Parameters

module T : sig ... end

Signature

type key = T.t

The type of keys.

val memoize : (key -> 'a) -> key -> 'a

memoize is a memoization combinator for the type key. The function call memoize f produces a function f' that behaves extensionally like f, but is memoized.

type 'a t

The type of memoization tables.

val visibly_memoize : (key -> 'a) -> (key -> 'a) * 'a t

visibly_memoize is a memoization combinator that exposes the memoization table. The function call visibly_memoize f returns a pair of a memoized function f' and a memoization table.

val fix : ((key -> 'a) -> key -> 'a) -> key -> 'a

fix is a recursive memoization combinator.

exception Cycle of key list * key

Cycle is raised by defensive_fix when a dependency cycle is detected.

val defensive_fix : ((key -> 'a) -> key -> 'a) -> key -> 'a

defensive_fix works like fix, except it detects circular dependencies, which can arise if the second-order function supplied by the user does not follow a well-founded recursion pattern. When the user invokes f x, where f is the function returned by defensive_fix, if a cyclic dependency is detected, then Cycle (zs, z) is raised, where the list zs begins with z and continues with a series of intermediate keys, leading back to z. Note that undetected divergence remains possible; this corresponds to an infinite dependency chain, without a cycle.

val curried : (((('a * 'b) -> 'c) -> ('a * 'b) -> 'c) -> ('a * 'b) -> 'c) -> (('a -> 'b -> 'c) -> 'a -> 'b -> 'c) -> 'a -> 'b -> 'c

curried can be used to obtain a curried version of fix or defensive_fix in a concrete instance where the type key is a product type.