#persistent #caching #science #hpc #memoization

nightly persistentcache

Macros for persistently caching function calls using files or Redis

7 releases

Uses old Rust 2015

0.1.6 Jun 2, 2018
0.1.5 Mar 17, 2018
0.1.2 Dec 6, 2017
0.1.1 Nov 24, 2017

#281 in Science

38 downloads per month


589 lines

Build Status


persistentcache-rs implements the macros cache! and cache_func! and the procedural macro #[peristent_cache] to cache function calls or entire functions. The implemented storages are persistent and can be shared between processes. Storages either store on disk (FileStorage) or Redis (RedisStorage).

The documentation and examples can be found here.


Here is an example using the #[peristent_cache] procedural macro:

extern crate lazy_static;
extern crate persistentcache;
extern crate persistentcache_procmacro;
use persistentcache::*;
use persistentcache::storage::{FileStorage, RedisStorage};
use persistentcache_procmacro::persistent_cache;

// Either store it in a `FileStorage`...
#[params(FileStorage, "test_dir")]
fn add_two_file(a: u64) -> u64 {
    println!("Calculating {} + 2...", a);
    a + 2

// ... or in a `RedisStorage`
#[params(RedisStorage, "redis://")]
fn add_two_redis(a: u64) -> u64 {
    println!("Calculating {} + 2...", a);
    a + 2

fn main() {
    // Function is called and will print "Calculating 2 + 2..." and "4"
    println!("{}", add_two_file(2));
    // Value will be cached from Redis, will only print "4"
    println!("{}", add_two_file(2));
    // Function is called and will print "Calculating 3 + 2..." and "5"
    println!("{}", add_two_redis(3));
    // Value will be cached from Redis, will only print "5"
    println!("{}", add_two_redis(3));

This will print:

Calculating 2 + 2...
Calculating 3 + 2...


This crate is inspired by owls-cache and its primary goal is to teach myself Rust. While working on it, I realised that a similar crate already exists: cached-rs. I've borrowed a couple of ideas from there. I suggest you have a look at the cached-rs crate, too. Unfortunately it lacks the 'persistent' part and the caches cannot be shared between processes/threads, but it should be fairly easy to extend it. Furthermore, the excellent accel has been very helpful. I shamelessly copied parts of it for the persistentcache_procmacro crate.


Licensed under either of

at your option.


Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.


~225K SLoC