I am trying to find a simple way to use something like Perl&#39;s hash functions in R (essentially caching), as I intended to do both Perl-style hashing and write my own memoisation of calculations.  However, others have beaten me to the punch and have packages for memoisation.  The more I dig, the more I find, e.g.`memoise` and `R.cache`, but differences aren&#39;t readily clear.  In addition, it&#39;s not clear how else one can get Perl-style hashes (or Python-style dictionaries) and write one&#39;s own memoization, other than to use the `hash` package, which doesn&#39;t seem to underpin the two memoization packages.

Since I can find no information on CRAN or elsewhere to distinguish between the options, perhaps this should be a community wiki question on SO: What are the options for memoization and caching in R, and what are their differences?

----
As a basis for comparison, here is a list of the options I&#39;ve found.  Also, it seems to me that all depend on hashing, so I&#39;ll note the hashing options as well.  Key/value storage is somewhat related, but opens a huge can of worms regarding DB systems (e.g. BerkeleyDB, Redis, MemcacheDB and [scores of others](http://en.wikipedia.org/wiki/Key-value_store)).

It looks like the options are:

### Hashing ###
 * [digest](http://cran.r-project.org/web/packages/digest/index.html) - provides hashing for arbitrary R objects.

### Memoization ###
 * [memoise](http://cran.r-project.org/web/packages/memoise/index.html) - a very simple tool for memoization of functions.
 * [R.cache](http://cran.r-project.org/web/packages/R.cache/index.html) - offers more functionality for memoization, though it seems some of the functions lack examples.

### Caching ###
 * [hash](http://cran.r-project.org/web/packages/hash/) - Provides caching functionality akin to Perl&#39;s hashes and Python dictionaries.

### Key/value storage ###
 These are basic options for external storage of R objects.

 * [stashr](http://cran.r-project.org/web/packages/stashR/index.html)
 * [filehash](http://cran.r-project.org/web/packages/filehash/index.html)

### Checkpointing ###
 * [cacher](http://cran.r-project.org/web/packages/cacher/index.html) - this seems to be more akin to [checkpointing](http://en.wikipedia.org/wiki/Application_checkpointing).
 * [CodeDepends](http://www.omegahat.org/CodeDepends/) - An OmegaHat project that underpins `cacher` and provides some useful functionality.
 * [DMTCP](http://dmtcp.sourceforge.net/) (not an R package) - appears to support checkpointing in a bunch of languages, and [a developer recently sought assistance testing DMTCP checkpointing in R](http://r.789695.n4.nabble.com/DMTCP-checkpoint-restart-for-R-td3735097.html).

### Other ###
 * Base R supports: named vectors and lists, row and column names of data frames, and names of items in environments. It seems to me that using a list is a bit of a kludge.  (There&#39;s also `pairlist`, but [it is deprecated](http://cran.r-project.org/doc/manuals/R-lang.html#Pairlist-objects).)
 * The [data.table](http://datatable.r-forge.r-project.org/) package supports rapid lookups of elements in a data table.

----
### Use case ###

Although I&#39;m mostly interested in knowing the options, I have two basic use cases that arise:

 1. Caching: Simple counting of strings.  [Note: This isn&#39;t for NLP, but general use, so NLP libraries are overkill; tables are inadequate because I prefer not to wait until the entire set of strings are loaded into memory.  Perl-style hashes are at the right level of utility.]
 2. Memoization of monstrous calculations.

These really arise because I&#39;m [digging in to the profiling of some slooooow code](https://stackoverflow.com/questions/7252602/digging-into-r-profiling-information) and I&#39;d really like to just count simple strings and see if I can speed up some calculations via memoization.  Being able to hash the input values, even if I don&#39;t memoize, would let me see if memoization can help.

----
Note 1: The [CRAN Task View on Reproducible Research](http://cran.r-project.org/web/views/ReproducibleResearch.html) lists a couple of the packages (`cacher` and `R.cache`), but there is no elaboration on usage options.

Note 2: To aid others looking for related code, here a few notes on some of the authors or packages.  Some of the authors use SO.  :)

 * Dirk Eddelbuettel: `digest` - a lot of other packages depend on this.
 * Roger Peng: `cacher`, `filehash`, `stashR` - these address different problems in different ways; see [Roger&#39;s site](http://www.biostat.jhsph.edu/~rpeng/software/index.html) for more packages.
 * Christopher Brown: `hash` - Seems to be a useful package, but the links to ODG are down, unfortunately.
 * Henrik Bengtsson: `R.cache` &amp; Hadley Wickham: `memoise` -- it&#39;s not yet clear when to prefer one package over the other.

Note 3: Some people use memoise/memoisation others use memoize/memoization.  Just a note if you&#39;re searching around.  Henrik uses &quot;z&quot; and Hadley uses &quot;s&quot;.

All Memoise Solutions on Gang of Coders

Total of 1 Memoise Solutions

Options for caching / memoization / hashing in R