memo

This is the memoization implementation that uses Erlang Term Storage (ETS).
This is the faster (and newer) of the two implementations.

Functions

create

</>

pub fn create(apply fun: fn(Set(a, b)) -> c) -> c

Makes a reference to a new ETS table that stores the memoization cache and passes this reference to a callback function containing the function you want to memoize.
The table is private and has a randomly-generated name. The table is dropped after create returns.

Using create can be done easily with a use expression:

use cache <- create()
f(a, b, c, cache)

get

</>

pub fn get(from cache: Set(a, b), fetch key: a) -> Result(b, Nil)

Manually look up a value from the memoization cache for a given key.

memoize

</>

pub fn memoize(
  with cache: Set(a, b),
  this key: a,
  apply fun: fn() -> b,
) -> b

Look up the value associated with the given key in the memoization cache, and return it if it exists. If it doesn’t exist, evaluate the callback function and update the cache with the value it returns.

The key can be of any data type, as long as the value the function returns is unique to that particular key.

This works well with a use expression:

fn f(a, b, c, cache) {
  use <- memoize(cache, #(a, b, c))
  // function body goes here
}

set

</>

pub fn set(
  in cache: Set(a, b),
  for key: a,
  insert value: b,
) -> Nil

Manually add a key-value pair to the memoization cache.