`Fix.MEMOIZER`

A memoizer is a higher-order function that constructs memoizing functions.

`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.

`Cycle`

is raised by `defensive_fix`

when a dependency cycle is detected.

`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.