As always, continuations yield an elegant tailcall solution: open System.Collections.Generic let cache = Dictionary<_,_>() // TODO move inside let memoizedTRFactorial = let rec fac n k = // must make tailcalls to k match cache.TryGetValue(n) with | true, r -> k r | _ -> if n=0 then k 1 else fac (n-1) (fun r1 … Read more
What YOU want from memoization may not be the same as what the compiler memoization option would provide. You may know that it is only profitable to memoize the last 10 or so distinct values computed, because you know how the function will be used. You may know that it only makes sense to memoize … Read more
There is an interesting way to do it that does rely neither on rebinding nor the behavior of def. The main trick is to go around the limitations of recursion by passing a function as an argument to itself: (defn make-fibo [y] (let [fib (fn [mem-fib x] (let [fib (fn [a] (mem-fib mem-fib a))] (if … Read more
This library is a straightforward combinatorization of the well-known technique of memoization. Let’s start with the canonical example: fib = (map fib’ [0..] !!) where fib’ 0 = 0 fib’ 1 = 1 fib’ n = fib (n-1) + fib (n-2) I interpret what you said to mean that you know how and why this … Read more
How about this? First write a one-argument memoizer: static Func<A, R> Memoize<A, R>(this Func<A, R> f) { var d = new Dictionary<A, R>(); return a=> { R r; if (!d.TryGetValue(a, out r)) { r = f(a); d.Add(a, r); } return r; }; } Straightforward. Now write a function tuplifier: static Func<Tuple<A, B>, R> Tuplify<A, B, … Read more
You can’t do what you want using lru_cache, since it doesn’t provide an API to access the cache, and it might be rewritten in C in future releases. If you really want to save the cache you have to use a different solution that gives you access to the cache. It’s simple enough to write … Read more
You could take a Map as cache and take nested maps for all following arguments. This cache works for arbitrary count of arguments and reuses the values from the former calls. It works by taking a curried function and an optional Map. If the map is not supplied, a new map is created which serves … Read more
Here is the commit (and subsequent discussion) where Memoizable was deprecated: https://github.com/rails/rails/commit/36253916b0b788d6ded56669d37c96ed05c92c5c The author advocates the @foo ||= … approach and points to this commit as an example for migration: https://github.com/rails/rails/commit/f2c0fb32c0dce7f8da0ce446e2d2f0cba5fd44b3. Edit: Note that I don’t necessarily interpret this change as meaning that all instances of memoize can or should be replaced w/ this pattern. … Read more
I found a better way to memoize using Scala: def memoize[I, O](f: I => O): I => O = new mutable.HashMap[I, O]() { override def apply(key: I) = getOrElseUpdate(key, f(key)) } Now you can write fibonacci as follows: lazy val fib: Int => BigInt = memoize { case 0 => 0 case 1 => 1 … Read more
Python offers a very elegant way to do this – decorators. Basically, a decorator is a function that wraps another function to provide additional functionality without changing the function source code. Your decorator can be written like this: import json def persist_to_file(file_name): def decorator(original_func): try: cache = json.load(open(file_name, ‘r’)) except (IOError, ValueError): cache = {} … Read more