Particularly useful for memoization. See with_cache and with_cache_rec for more details.
Typical use case: one wants to memoize a function f : 'a -> 'b. Code sample:
let f x =
print_endline "call f";
x + 1;;
let f' = with_cache (lru 256) f;;
f' 0;; (* prints *)
f' 1;; (* prints *)
f' 0;; (* doesn't print, returns cached value *)val clear : (_, _) t -> unitClear the content of the cache
val with_cache : ('a, 'b) t -> ('a -> 'b) -> 'a -> 'bwith_cache c f behaves like f, but caches calls to f in the cache c. It always returns the same value as f x, if f x returns, or raise the same exception. However, f may not be called if x is in the cache.
val with_cache_rec : ('a, 'b) t -> (('a -> 'b) -> 'a -> 'b) -> 'a -> 'bwith_cache_rec c f is a function that first, applies f to some f' = fix f, such that recursive calls to f' are cached in c. It is similar to with_cache but with a function that takes as first argument its own recursive version. Examples (memoized Fibonacci function):
let fib = with_cache_rec (lru 256)
(fun fib' n -> match n with
| 1 | 2 -> 1
| _ -> fib' (n-1) + fib' (n-2)
);;
fib 70;;val size : (_, _) t -> intSize of the cache (number of entries). At most linear in the number of entries.
val iter : ('a, 'b) t -> ('a -> 'b -> unit) -> unitIterate on cached values. Should yield size cache pairs.
val dummy : ('a, 'b) tdummy cache, never stores any value
Linear cache with the given size. It stores key/value pairs in an array and does linear search at every call, so it should only be used with small size.
optional equality predicate for keys
Replacing cache of the given size. Equality and hash functions can be parametrized. It's a hash table that handles collisions by replacing the old value with the new (so a cache entry is evicted when another entry with the same hash (modulo size) is added). Never grows wider than the given size.
LRU cache of the given size ("Least Recently Used": keys that have not been used recently are deleted first). Never grows wider than the given size.