module BatCache:sig..end
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.
type ('a, 'b) manual_cache = {
|
get : |
|
del : |
|
enum : |
}
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.
type('a, 'b)auto_cache ='a -> 'b
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