Caches (bounded-size, key-value or simple-value stores) and other bounded-size
A map-cache (
Sigs.CACHE_MAP) (resp. a set-cache,
Sigs.CACHE_SET) is a module
that implements an imperative, key-value (resp. value) store.
A cache is bounded in size – meaning that inserting bindings (resp. elements)
beyond the cache capacity removes other bindings (resp. elements).
The specific behaviour of the cache is controlled by different options.
Specifically, the replacement policy (which bindings (resp. elements) are
removed when supernumerary bindings (resp. elements) are inserted), the overflow
policy (when are bindings (resp. elements) removed), the accounting policy (how
precisely are bindings (resp. elements) counted), and the capacity (how many
bindings (resp. elements) a cache can hold), are all controlled by parameters.
replacement is for defining the replacement policy of a cache and is provided
when instantiating the
LRUis for "Least Recently Used", meaning that when a supernumerary item is
inserted in the cache, the least recently used item is removed to make room.
FIFOis for "First-In, First-Out" meaning that when a supernumerary item is
inserted in the cache, the oldest inserted element is removed to make room.
overflow is for defining the overflow policy of a cache and is provided when
Strongmeans that the cache never holds more element than is specified when
Weakmeans that the cache may hold more elements than
specified when calling
createbut that supernumerary elements may be
collected by the Garbage Collector.
accounting is for defining the accounting policy of a cache and is provided
when instantiating the
Precisemeans that the cache counts its number of elements precisely.
Sloppymeans that the cache may count elements that have been
the cache as still being held by the cache.
Note that when requesting a
Sloppycache, the library might give you a
Precisecache if there is no additional runtime cost. In general,
caches are more efficient, but (1) they are not adapted to situations where
you remove many elements and (2) depending on the other parameters they might
be only as-efficient-as (not more) than
Preciseonly if you use
removea lot or if you need strong guarantee
on the number of elements.
capacity is for specifying the size-bound of the cache and is specified when
Cache.createto instantiate a cache.
Lwt, Option and Result wrappers
ringo-lwt includes wrappers for making Ringo map-caches friendly
to Lwt. Specifically, it includes a functor that, given a map-cache, will
produce a new cache with the following features:
replacenow takes a promise rather than a value,
find_or_replaceis a function that either returns the promise currently
bound to the given key or makes a new promise, and
promises that are rejected are automatically removed from the cache.
Two further functors provide integration for Lwt-and-Option (wherein promises
None are also removed) and Lwt-and-Result (wherein promises
Error are also removed).
These additional abstractions help avoiding race conditions.
Both rings and dlls are bounded-size imperative collections. Unlike caches,
their interface is much simpler: essentially providing
They are used internally to implement some components of the caches. They are
exposed because they can be useful.
>= "10.2" & < "13.0"