mf <- memoise(f) creates mf, a memoised copy of f. A memoised copy is basically a lazier version of the same function: it saves the answers of new invocations, and re-uses the answers of old ones. Under the right circumstances, this can provide a very nice speedup indeed.

memoise(
  f,
  ...,
  envir = environment(f),
  cache = cache_memory(),
  omit_args = c()
)

Arguments

f

Function of which to create a memoised copy.

...

optional variables to use as additional restrictions on caching, specified as one-sided formulas (no LHS). See Examples for usage.

envir

Environment of the returned function.

cache

Cache function.

omit_args

Names of arguments to ignore when calculating hash.

Details

There are two main ways to use the memoise function. Say that you wish to memoise glm, which is in the stats package; then you could use
mem_glm <- memoise(glm), or you could use
glm <- memoise(stats::glm).
The first form has the advantage that you still have easy access to both the memoised and the original function. The latter is especially useful to bring the benefits of memoisation to an existing block of R code.

Two example situations where memoise could be of use:

  • You're evaluating a function repeatedly over the rows (or larger chunks) of a dataset, and expect to regularly get the same input.

  • You're debugging or developing something, which involves a lot of re-running the code. If there are a few expensive calls in there, memoising them can make life a lot more pleasant. If the code is in a script file that you're source()ing, take care that you don't just put
    glm <- memoise(stats::glm)
    at the top of your file: that would reinitialise the memoised function every time the file was sourced. Wrap it in
    if (!is.memoised(glm)) , or do the memoisation call once at the R prompt, or put it somewhere else where it won't get repeated.

It is recommended that functions in a package are not memoised at build-time, but when the package is loaded. The simplest way to do this is within .onLoad() with, for example

# file.R
fun &lt;- function() {
 some_expensive_process()
}

# zzz.R
.onLoad &lt;- function(libname, pkgname) {
 fun &lt;&lt;- memoise::memoise(fun)
}

See also

Examples

# a() is evaluated anew each time. memA() is only re-evaluated # when you call it with a new set of parameters. a <- function(n) { runif(n) } memA <- memoise(a) replicate(5, a(2))
#> [,1] [,2] [,3] [,4] [,5] #> [1,] 0.6007609 0.007399441 0.4977774 0.7328820 0.8746007 #> [2,] 0.1572084 0.466393497 0.2897672 0.7725215 0.1749406
replicate(5, memA(2))
#> [,1] [,2] [,3] [,4] [,5] #> [1,] 0.03424133 0.03424133 0.03424133 0.03424133 0.03424133 #> [2,] 0.32038573 0.32038573 0.32038573 0.32038573 0.32038573
# Caching is done based on parameters' value, so same-name-but- # changed-value correctly produces two different outcomes... N <- 4; memA(N)
#> [1] 0.40232824 0.19566983 0.40353812 0.06366146
N <- 5; memA(N)
#> [1] 0.3887013 0.9755478 0.2898923 0.6783804 0.7353196
# ... and same-value-but-different-name correctly produces # the same cached outcome. N <- 4; memA(N)
#> [1] 0.40232824 0.19566983 0.40353812 0.06366146
N2 <- 4; memA(N2)
#> [1] 0.40232824 0.19566983 0.40353812 0.06366146
# memoise() knows about default parameters. b <- function(n, dummy="a") { runif(n) } memB <- memoise(b) memB(2)
#> [1] 0.1959567 0.9805397
memB(2, dummy="a")
#> [1] 0.1959567 0.9805397
# This works, because the interface of the memoised function is the same as # that of the original function. formals(b)
#> $n #> #> #> $dummy #> [1] "a" #>
formals(memB)
#> $n #> #> #> $dummy #> [1] "a" #>
# However, it doesn't know about parameter relevance. # Different call means different caching, no matter # that the outcome is the same. memB(2, dummy="b")
#> [1] 0.74152153 0.05144628
# You can create multiple memoisations of the same function, # and they'll be independent. memA(2)
#> [1] 0.03424133 0.32038573
memA2 <- memoise(a) memA(2) # Still the same outcome
#> [1] 0.03424133 0.32038573
memA2(2) # Different cache, different outcome
#> [1] 0.5302125 0.6958239
# Don't do the same memoisation assignment twice: a brand-new # memoised function also means a brand-new cache, and *that* # you could as easily and more legibly achieve using forget(). # (If you're not sure whether you already memoised something, # use is.memoised() to check.) memA(2)
#> [1] 0.03424133 0.32038573
memA <- memoise(a) memA(2)
#> [1] 0.68855600 0.03123033
# Making a memoized automatically time out after 10 seconds. memA3 <- memoise(a, ~{current <- as.numeric(Sys.time()); (current - current %% 10) %/% 10 }) memA3(2)
#> [1] 0.2255625 0.3008308
# The timeout function is an easy way to do the above. memA4 <- memoise(a, ~timeout(10)) memA4(2)
#> [1] 0.6364656 0.4790245