The data structure for a manual cache with keys 'a and values 'b.
This cache gives access to some internals of a memoized function f, called the generating function. This function is usually pure; always returning the same output for a given input. This module allows the results of complex functions to be cached so that the function does not need to be called again to get that result.
When c.get k is called, an internal structure is first consulted to see if f k has been stored in that structure. If it has, then that previous result is returned, otherwise, f k is evaluated, the result stored in the caching structure and also returned to the user.
The user is allowed to remove a value from the caching structure with c.del k. This allows the user to prevent unbounded growth of the cache by removing unneeded entries. If the user prefers an automatically managed cache, this module provides !auto_cache.
Last, c.enum () will enumerate all the currently memorized bindings as pairs. This allows inspection of what is currently cached.
val make_ht : gen:('a -> 'b) -> init_size:int -> ('a, 'b) manual_cacheMake a manual cache backed by a hashtable. The generating function is passed with ~gen and the initial size of the hashtable is ~init_size. The hashtable uses the polymorphic hash and (=).
val make_map : gen:('a -> 'b) -> ('a, 'b) manual_cacheMake a manual cache for function ~gen backed by a Set.t. This set uses the polymorphic (<) for comparison, so 'a should be properly comparable by it.
Automatically managed caches
This type of cache is more transparent than the !manual_cache above. It does not provide inspection of the caching structure, but guarantees bounded memory usage through some policy of discarding some entries.
Each auto-cache can have a different policy to decide which entry to discard.
val lru_cache : gen:('a -> 'b) -> cap:int -> ('a, 'b) auto_cache