Sub modules

Acquired value

If the value is not yet acquired, it will be acquired within Value and cached.

Functor map

Create a clone of the memo (without any cached results). This allows for reacquiring the value.

Reset the memo. This clears the cached value.

Acquired value

If the value is not yet acquired, it will be acquired within Value and cached.

Create a clone of the memo (without any cached results). This allows for reacquiring the value.

Reset the memo. This clears the cached value.

Natural transformation for memoised higher-kinded structures

Natural transformation for memoised higher-kinded structures

Returns a Memo〈A〉 that wraps a function. The first call to the resulting Memo〈A〉 will cache the result. Subsequent calls return the cached item.

Create a preloaded memo structure with a pure value.

Returns a Memo〈F, A〉 that wraps a function that yields a higher-kind K〈F, A〉. The first call to the resulting Memo〈F, A〉 will cache the resulting K〈F, A〉. Subsequent calls return the cached item.

NOTE: This does not invoke the K〈F, A〉 computation, it merely caches the construction of the K〈F, A〉. If K〈F, A〉 itself is lazy, then it can be invoked multiple times; this memoisation won't affect that.

Create a preloaded memo structure with a pure value

Create a preloaded memo structure.

Returns a Func〈A, B〉 that wraps func. Each time the resulting Func〈A, B〉 is called with a new value, its result is memoized (cached). Subsequent calls use the memoized value.

Remarks: Thread-safe and memory-leak safe.

Returns a Func〈T, R〉 that wraps func. Each time the resulting Func〈T, R〉 is called with a new value, its result is memoized (cached). Subsequent calls use the memoized value.

Remarks: No mechanism for freeing cached values and therefore can cause a memory leak when holding onto the Func〈T, R〉 reference. Uses a ConcurrentDictionary for the cache and is thread-safe

Enumerable memoization. As an enumerable is enumerated each item is retained in an internal list, so that future evalation of the enumerable isn't done. Only items not seen before are evaluated.

This minimises one of the major problems with the IEnumerable / yield return pattern by causing at-most-once evaluation of each item.

Use the IEnumerable extension method Memo for convenience.

Although this allows efficient lazy evaluation, it does come at a memory cost. Each item is cached internally, so this method doesn't allow for evaluation of infinite sequences.