Batteries user guide : BatCache

# Module BatCache

    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 : `'a -> 'b`;`
`` | `del : `'a -> unit`;`
`` | `enum : `unit -> ('a * 'b) BatEnum.t`;`

}

    val make_ht : gen:('a -> 'b) -> init_size:int -> ('a, 'b) manual_cache

Make 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_cache

Make 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