Usage

If you had a function fibo defined like this:

let rec fibo x =
  if x < 0 then invalid_arg "fibo";
  if x < 2 then x
  else fibo (x - 1) + fibo (x - 2)

There's many different ways to memoïze it.

Simple memoïzation

The easiest one is to rewrite it like this:

let fibo = Memo.memo (fun fibo x ->
  if x < 0 then invalid_arg "fibo";
  if x < 2 then x
  else fibo (x - 1) + fibo (x - 2))

It'll use the Hashtbl module from Stdlib directly.

I'd like to thank Sylvain Conchon who taught me memoïzation and how to write this memo function when I was his student.

Using your own type, equal and hash functions

We provide a Memo.Make functor. It can be useful in case you don't want to use polymorphic equality or you are doing things like hash consing and you know how to compare or hash your type more efficiently.

let module Mem = Memo.Make(struct
  type t = int
  let equal = (=)
  let hash = Hashtbl.hash
end)

let fibo = Mem.memo (fun fibo x ->
  if x < 0 then invalid_arg "fibo";
  if x < 2 then x
  else fibo (x - 1) + fibo (x - 2))

Forgetful memoïzation

We provide a Memo.MakeWeak functor. It works like the previous one, but the bindings in the memoïzation cache will be weak, allowing the garbage collector to remove them if they are not used somewhere else.

let module Mem = Memo.MakeWeak(struct
  type t = int
  let equal = (=)
  let hash = Hashtbl.hash
end)

let fibo = Mem.memo (fun fibo x ->
  if x < 0 then invalid_arg "fibo";
  if x < 2 then x
  else fibo (x - 1) + fibo (x - 2))

I'd like to thank Jean-Christophe Filliâtre who taugh me forgetful memoïzation when I was doing research on binary decision diagram under his direction while I was a first year master student.

Fake memoïzation

We provide a Memo.Fake functor. It is useful if you want to quickly test a function you memoïzed with our Memo.Make or Memo.MakeWeak functor, but without memoïzing it. It'll basically do nothing and should be equivalent to your initial non-memoïzed function.

let module Mem = Memo.Fake(struct
  type t = int
  let equal = (=)
  let hash = Hashtbl.hash
end)

let fibo = Mem.memo (fun fibo x ->
  if x < 0 then invalid_arg "fibo";
  if x < 2 then x
  else fibo (x - 1) + fibo (x - 2))

Using your own defined cache

With the Memo.Mk functor, you can also directly provide a Cache module, which should have the signature Hashtbl.S. We will include your cache module and use it to define a memo function:

let module Mem = Memo.Mk(
  Hashtbl.Make(struct
    type t = int
    let equal = (=)
    let hash = Hashtbl.hash
  end)
end)

let fibo = Mem.memo (fun fibo x ->
  if x < 0 then invalid_arg "fibo";
  if x < 2 then x
  else fibo (x - 1) + fibo (x - 2))

This example is useless and equivalent to using the Memo.Make functor directly.

If you find a real use case for this which doesn't need new dependencies, contact me and I'll be happy to add a new functor to the library.

It should be useful only if you want to use another Hashtbl implementation or things like this.

Tuning

There's a default value for the initial cache size. You can set it to the value of your choice, reset it to the default and get the current value like this:

Memo.set_initial_cache_size 1024;
Memo.reset_initial_cache_size ();
let curr_size = Memo.get_initial_cache_size ()

Note that with the current implementation of hash tables in OCaml, it's better if you choose a power of two. You may saw some code using a prime number, it's because some years ago it was the best thing to do as the hash tables implementation was different. Jean-Christophe Filliâtre explained this to me, thanks again ! Also keep in mind that if you use your own defined cache thanks to the Memo.Mk functor, it may not be the right thing to do.