clojure.core/memoize

View this page on ClojureDocs

Type: function Added: Clojure 1.0 Examples: 6 Runnable: 3

([f])

Returns a memoized version of a referentially transparent function. The memoized version of the function keeps a cache of the mapping from arguments to results and, when calls with the same arguments are repeated often, has higher performance at the expense of higher memory use.

Examples

by gstamp on 2010-08-04 . May have evaluation errors. ▶

;; First we define a function that presumably have some expensive computation. (defn myfunc[a] (println "doing some work") (+ a 10)) #'user/myfunc ;; Next we create a memoized version of the function. (def myfunc-memo (memoize myfunc)) #'user/myfunc-memo ;; The first time we call the function with a particular argument the ;; original function is invoked and the value is returned. The next ;; time the function is called with the same argument the cached result ;; is returned and the original function is NOT called. (myfunc-memo 1) doing some work 11 (myfunc-memo 1) 11 (myfunc-memo 20) doing some work 30 (myfunc-memo 20) 30

by discoverfly on 2015-04-17 . May have evaluation errors. ▶

;; Fibonacci number with recursion. (defn fib [n] (condp = n 0 1 1 1 (+ (fib (dec n)) (fib (- n 2))))) (time (fib 30)) ;; "Elapsed time: 8179.04028 msecs" ;; Fibonacci number with recursion and memoize. (def m-fib (memoize (fn [n] (condp = n 0 1 1 1 (+ (m-fib (dec n)) (m-fib (- n 2))))))) (time (m-fib 30)) ;; "Elapsed time: 1.282557 msecs"

by timgilbert on 2017-06-12 ▶

;; It's possible to memoize a function with multiple arguments: (def times (memoize (fn [x y] (* x y)))) (times 1 2) ; => 2 (times 2 0) ; => 0

by comnik on 2018-07-22 . May have evaluation errors. ▶

;; Memoize is a simple way to make a mapping deterministic. (def attribute->id (memoize (fn [attr] (clojure.lang.RT/nextID)))) (attribute->id :name) ; => 16305 (attribute->id :age) ; => 16306 (attribute->id :name) ; => 16305

by harununal on 2019-04-18 ▶

; We can take a rand and use it repeatly ; (Just with same parameter) (defn only-first-one-rand [n] (rand n)) (def ofor-memo (memoize only-first-one-rand)) (ofor-memo 10) ;=> 3.683571228686361 (ofor-memo 10) ;=> 3.683571228686361 ;And we can assign a random value to an integer (ofor-memo 6) ;=> 2.8058589761445867 (ofor-memo 10) ;=> 3.683571228686361

by harununal on 2019-04-18 ▶

; When we use memoize, we say to Clojure : ; " x function returned with y parameters as z value. ; No need to repeat this process everytimes. ; Because you has pure functions. ; Just keep "z value" on your mind. ; Thank you."

Note by rquinlivan

What is the definition of "often" for the purposes of caching? Is there a util like this that allows for different cache eviction strategies?

Note by PetrGlad

@rquinlivan The implementation of clojure.core/memoize is plain straightforward. It should be obvious that computation_cost times number_of_calls should determine whether to use it or not. If you need more control over caching have a look at clojure.core.cache

Note by l3nz

memoize is nice but it may be tricky to use in production, because it just caches everything. Also, the key under which the value is stored are all the parametres you have as input.

If you need something more flexible, with user-definable keys (eg because you are passing in a database connection) or a flexible eviction policy, see clojure.core.memoize that is a wrapper around clojure.core.cache.

See also

• clojure.core/delay (3)

---

Content from the matching ClojureDocs page, with authors credited on each contribution.