Generic caching library
val memoize : ?destruct:('b -> unit) ->
?expire:[ `Keep_all | `Keep_one | `Lru of int ] -> ('a -> 'b) -> 'a -> 'b
memoize ~destruct ~expire f memoizes the results of f.
expire : Strategy used to prune out values from the cache
  • `Keep_one: only keeps the last result around
  • `Keep_all: (the default value) never delete any values from the cache
  • `Lru n: keep n values in the cache and them removes the least recently used
destruct : function called on every value we remove from the cache
val unit : (unit -> 'a) -> unit -> 'a
Returns memoized version of any function with argument unit. In effect this builds a lazy value.

Exposed cache

These modules implement memoization and give you access to the cache. This, for instance, enables you to flush it.

module Lru : sig .. end
Least recently used caching
type ('k, 'v) t
type ('a, 'b) memo = ('a, ('b, exn) Core.Std.Result.t) t
val find : ('k, 'v) t -> 'k -> 'v option
val add : ('k, 'v) t -> key:'k -> data:'v -> unit
val remove : ('k, 'a) t -> 'k -> unit
val clear : ('a, 'b) t -> unit
val create : destruct:('v -> unit) option -> int -> ('k, 'v) t
val call_with_cache : cache:('a, 'b) memo -> ('a -> 'b) -> 'a -> 'b
val memoize : ?destruct:('b -> unit) -> ('a -> 'b) -> int -> ('a, 'b) memo * ('a -> 'b)
module Keep_all : sig .. end
Full caching (never flushes out values automatically )
type ('k, 'v) t
type ('a, 'b) memo = ('a, ('b, exn) Core.Std.Result.t) t
val find : ('k, 'v) t -> 'k -> 'v option
val add : ('k, 'v) t -> key:'k -> data:'v -> unit
val remove : ('k, 'a) t -> 'k -> unit
val clear : ('a, 'b) t -> unit
val create : destruct:('v -> unit) option -> ('k, 'v) t
val call_with_cache : cache:('a, 'b) memo -> ('a -> 'b) -> 'a -> 'b
val memoize : ?destruct:('b -> unit) -> ('a -> 'b) -> ('a, 'b) memo * ('a -> 'b)

Generic caching

This enables you to implement your own caching strategy and store.

Generic caching is based on separating the replacement policie and the store and tying them together with Make.

module type Strategy = sig .. end
Replacement policy

This dictates when elements will droped from the cache.

type 'a t
type 'a with_init_args
This type is used to specify the signature of cps_create. For instance if cps_create takes two arguments of types x and y:
  type 'a with_init_args : x -> y -> 'a
val cps_create : f:('a t -> 'b) -> 'b with_init_args
cps_create ~f is given in CPS form to enable chaining. (i.e. instead of directly returning a value it applies f to this value).
val touch : 'a t -> 'a -> 'a list
Marks an element as "fresh". Returns a list of elements to be dropped from the store.
val remove : 'a t -> 'a -> unit
Informs the strategy that an element was removed from the store.
val clear : 'a t -> unit
Inform the strategy that all the elements where dropped from the store.
module type Store = sig .. end
Caching store

A Store is the backend used to store the values in a cache. A store is a key/value associative table.

type ('k, 'v) t
A key value store.
type 'a with_init_args
val cps_create : f:(('a, 'c) t -> 'b) -> 'b with_init_args
cps_create is given in CPS form to enable chaining.

see Cache.Strategy.cps_create for more information.

val clear : ('k, 'v) t -> unit
Remove all the values from the store.
val replace : ('k, 'v) t -> key:'k -> data:'v -> unit
replace store ~key ~data associated the data to key; remove any previously existing binding.
val find : ('k, 'v) t -> 'k -> 'v option
find store key returns the value associated to key in store.
val data : ('a, 'v) t -> 'v list
data store returns all values in store.
val remove : ('k, 'v) t -> 'k -> unit
remove store key removes the binding for key in store.
module type S = sig .. end
The output signature of the functor Cache.Make
type ('k, 'v) t
A key value cache
type 'a with_init_args
Used to specify the type of the create and memoize function. This describes the arguments required to initialise the caching strategy and the store. For instance if the store doesn't take any argument (eg.: Store.Table) and the strategy takes an int (eg.: Strategy.Lru) this type will be:
   type 'a with_init_args = int -> 'a
type ('a, 'b) memo = ('a, ('b, exn) Core.Std.Result.t) t
val find : ('k, 'v) t -> 'k -> 'v option
val add : ('k, 'v) t -> key:'k -> data:'v -> unit
val remove : ('k, 'a) t -> 'k -> unit
val clear : ('a, 'b) t -> unit
val create : destruct:('v -> unit) option -> ('k, 'v) t with_init_args
val call_with_cache : cache:('a, 'b) memo -> ('a -> 'b) -> 'a -> 'b
val memoize : ?destruct:('b -> unit) ->
('a -> 'b) -> (('a, 'b) memo * ('a -> 'b)) with_init_args
module Strategy : sig .. end
Predefined strategies
module Lru : Strategy with type with_init_args = int -> 'a
Least recently used.
module Keep_all : Strategy with type with_init_args = 'a
Keep all the values
module Store : sig .. end
Predefined stores
module Table : Store with type with_init_args = 'a
module Make : 
functor (Strat : Strategy) ->
functor (Store : Store) -> S with type with_init_args = 'a Store.with_init_args Strat.with_init_args