lru 0.3.0 · OCaml Package

MakeSeeded(K)(V) is a variant backed by Hashtbl.SeededS.

Parameters

module K : Stdlib.Hashtbl.SeededHashedType

module V : Weighted

Signature

Mutable LRU map

type t

A map.

type k = K.t

Keys in t.

type v = V.t

Values in t.

val create : ?random:bool -> int -> t

create ?random cap is a new map with capacity cap.

~random randomizes the underlying hash table. It defaults to false. See Hashtbl.create.

Note. The internal hash table is created with size cap.

raises Invalid_argument
when cap < 0.

val is_empty : t -> bool

is_empty t is true iff there are no bindings in t.

val size : t -> int

size t is the number of bindings in t.

Limiting the weight of bindings

val weight : t -> int

weight t is the combined weight of bindings in t.

val capacity : t -> int

capacity t is the maximum combined weight of bindings that trim will retain.

val resize : int -> t -> unit

resize cap t sets t's capacity to cap, while leaving the bindings unchanged.

raises Invalid_argument
when cap < 0.

val trim : t -> unit

trim t ensures that weight t <= capacity t by dropping bindings in LRU-to-MRU order.

Access by `k`

val mem : k -> t -> bool

mem k t is true iff k is bound in t.

val find : k -> t -> v option

find k t is Some v when k -> v is bound in t, or None otherwise.

Note This operation does not change the recently-used order.

val promote : k -> t -> unit

promote k t promotes the binding for k, if it exists, to most-recently-used.

val add : k -> v -> t -> unit

add k v t adds the binding k -> v to t as the most-recently-used binding.

Note add does not remove bindings. To ensure that the resulting map is not over capacity, combine with trim.

val remove : k -> t -> unit

remove k t is t without a binding for k.

Access to least-recently-used bindings

val lru : t -> (k * v) option

lru t is the least-recently-used binding in t, or None, when t is empty.

val drop_lru : t -> unit

drop_lru t removes the binding lru t.

Aggregate access

val fold : (k -> v -> 'a -> 'a) -> 'a -> t -> 'a

fold f z t is f k0 v0 (... (f kn vn z)), where k0 -> v0 is LRU and kn -> vn is MRU.

val iter : (k -> v -> unit) -> t -> unit

iter f t applies f to all the bindings in t in in LRU-to-MRU order.

Conversions

val of_list : (k * v) list -> t

of_list kvs is a map with bindings kvs, where the order of the list becomes LRU-to-MRU ordering, and its capacity is set to its weight.

The resulting t has the same shape as if the bindings were sequentially added in list order, except for capacity.

val to_list : t -> (k * v) list

to_list t are the bindings in t in LRU-to-MRU order.

Pretty-printing

val pp : 
  ?pp_size:(Stdlib.Format.formatter -> (int * int) -> unit) ->
  ?sep:(Stdlib.Format.formatter -> unit -> unit) ->
  (Stdlib.Format.formatter -> (k * v) -> unit) ->
  Stdlib.Format.formatter ->
  t ->
  unit

pp ~pp_size ~sep pp_kv ppf t pretty-prints t to ppf, using pp_kv to print the bindings, ~sep to separate them, and ~pp_size to print the weight and capacity. ~sep and ~pp_size default to unspecified printers.

package lru