Library
Module
Module type
Parameter
Class
Class type
A SET_MAKER
is a functor that instantiates CACHE_SET
s based on a given type and its associated hash function.
A Mutable structure akin to a set, but with a size bound. Note that, different caches have different policies towards the size bounds: some uphold the bound strictly, some treat the bound as a suggestion. In addition, some caches count their elements somewhat sloppily.
In general, the caches of ringo are intended to be used in settings that do not require strict, by-the-number, extremely-predictable behaviors.
See Ringo
(or Functors
) for more information.
module H : Hashtbl.HashedType
type elt = H.t
The type of values held by the cache.
val create : int -> t
create n
creates a unit-cache with a size-bound of n
. Remember that the size-bound is not upheld strictly by all caches.
add c v
adds the value v
to the cache c
. This may or may not cause another element to be removed from the cache, depending on the number of elements already present in the cache c
, the size-bound of the cache c
, and the policy of the cache c
towards its size-bound.
If v
is already present in c
, the element may count twice towards the size bound for some time. In other words: apart for size bound in some cases, the following sequences of operations are indistinguishable: add c v; add c u
and add c v; remove c v; add c u
fold f c init
folds the function f
and value init
over the elements of c
.
Note that for caches with a Weak
overflow policy, this function may fold over a subset of the elements of c
. See Ringo
(or Functors
) for more details.
mem c v
is true
if v
is present in c
. It is false
otherwise.
Note that the in caches with a non-FIFO
replacement policy, this may have a side effect on the v
element. Specifically, in those caches, it might make it less likely to be removed when supernumerary elements are inserted.
remove c v
removes the element v
from c
. If v
is not present in c
, it does nothing.
Note that in caches with a Sloppy
accounting policy, removed elements can still count towards the size bound for some time.
val length : t -> int
length c
is the number of elements present in c
.
val capacity : t -> int
capacity c
is the number of bindings c
can hold: capacity (create n) = n
val clear : t -> unit
clear c
removes all elements from c
.