#memoization #cache #proc-macro


Attribute macro for auto-memoizing functions with somewhat-simple signatures

18 releases

0.4.1 Oct 27, 2023
0.4.0 Jan 18, 2023
0.3.3 Dec 2, 2022
0.3.1 Aug 9, 2022
0.1.4 Oct 16, 2020

#38 in Caching

Download history 1946/week @ 2023-08-15 2582/week @ 2023-08-22 2185/week @ 2023-08-29 2286/week @ 2023-09-05 2285/week @ 2023-09-12 2374/week @ 2023-09-19 1793/week @ 2023-09-26 1862/week @ 2023-10-03 2060/week @ 2023-10-10 1473/week @ 2023-10-17 2314/week @ 2023-10-24 2809/week @ 2023-10-31 2533/week @ 2023-11-07 2557/week @ 2023-11-14 2595/week @ 2023-11-21 2419/week @ 2023-11-28

10,504 downloads per month
Used in 3 crates

MIT license



Docs.rs Crates.rs CI

A #[memoize] attribute for somewhat simple Rust functions: That is, functions with one or more Clone-able arguments, and a Clone-able return type. That's it.

NEWS: The crate has been updated so that you don't need to separately import lru, lazy_static, and other dependencies. Now everything should work automatically. Remember to enable the full feature to use LRU caching and other additional features.

Read the documentation (cargo doc --open) for the sparse details, or take a look at the examples/, if you want to know more:

// From examples/test2.rs

use memoize::memoize;

fn hello(arg: String, arg2: usize) -> bool {
  arg.len()%2 == arg2

fn main() {
  // `hello` is only called once here.
  assert!(! hello("World".to_string(), 0));
  assert!(! hello("World".to_string(), 0));
  // Sometimes one might need the original function.
  assert!(! memoized_original_hello("World".to_string(), 0));

This is expanded into (with a few simplifications):

std::thread_local! {
  static MEMOIZED_MAPPING_HELLO : RefCell<HashMap<(String, usize), bool>> = RefCell::new(HashMap::new());

pub fn memoized_original_hello(arg: String, arg2: usize) -> bool {
  arg.len() % 2 == arg2

fn hello(arg: String, arg2: usize) -> bool {
    let mut ATTR_MEMOIZE_HM__ = ATTR_MEMOIZE_HM__.borrow_mut();
    ATTR_MEMOIZE_HM__.get(&(arg.clone(), arg2.clone())).cloned()

  let ATTR_MEMOIZE_RETURN__ = memoized_original_hello(arg.clone(), arg2.clone());

    let mut ATTR_MEMOIZE_HM__ = ATTR_MEMOIZE_HM__.borrow_mut();
    ATTR_MEMOIZE_HM__.insert((arg, arg2), ATTR_MEMOIZE_RETURN__.clone());


Further Functionality

As can be seen in the above example, each thread has its own cache by default. If you would prefer that every thread share the same cache, you can specify the SharedCache option like below to wrap the cache in a std::sync::Mutex. For example:

fn hello(key: String) -> ComplexStruct {
  // ...

You can choose to use an LRU cache. In fact, if you know that a memoized function has an unbounded number of different inputs, you should do this! In that case, use the attribute like this:

// From examples/test1.rs
// Compile with --features=full
use memoize::memoize;

#[derive(Debug, Clone)]
struct ComplexStruct {
  // ...

#[memoize(Capacity: 123)]
fn hello(key: String) -> ComplexStruct {
  // ...

Adding more caches and configuration options is relatively simple, and a matter of parsing attribute parameters. Currently, compiling will fail if you use a parameter such as Capacity without the feature full being enabled.

Another parameter is TimeToLive, specifying how long a cached value is allowed to live:

#[memoize(Capacity: 123, TimeToLive: Duration::from_secs(2))]

chrono::Duration is also possible, but would have to first be converted to std::time::Duration

#[memoize(TimeToLive: chrono::Duration::hours(3).to_std().unwrap())]

The cached value will never be older than duration provided and instead recalculated on the next request.

You can also specifiy a custom hasher, like AHash using CustomHasher.

#[memoize(CustomHasher: ahash::HashMap)]

As some hashers initializing functions other than new(), you can specifiy a HasherInit function call:

#[memoize(CustomHasher: FxHashMap, HasherInit: FxHashMap::default())]


If you memoize a function f, there will be a function called memoized_flush_f() that allows you to clear the memoization cache.


...are always welcome! This being my first procedural-macros crate, I am grateful for improvements of functionality and style. Please send a pull request, and don't be discouraged if it takes a while for me to review it; I'm sometimes a bit slow to catch up here :) -- Lewin


~34K SLoC