Memoize
Thread-safe memoization for a function.
Thread-safe memoization for a function.
This works like a lazy val indexed by the input value. The memo is held as part of the state of the returned function, so keeping a reference to the function will keep a reference to the (unbounded) memo table. The memo table will never forget a result, and will retain a reference to the corresponding input values as well.
If the computation has side-effects, they will happen exactly once per input, even if multiple threads attempt to memoize the same input at one time, unless the computation throws an exception. If an exception is thrown, then the result will not be stored, and the computation will be attempted again upon the next access. Only one value will be computed at a time. The overhead required to ensure that the effects happen only once is paid only in the case of a miss (once per input over the life of the memo table). Computations for different input values will not block each other.
The combination of these factors means that this method is useful for functions that will only ever be called on small numbers of inputs, are expensive compared to a hash lookup and the memory overhead, and will be called repeatedly.