#cache #memoization

fn-cache

A copy-less and clone-less function caching library

7 releases (4 breaking)

✓ Uses Rust 2018 edition

0.5.0 Nov 14, 2019
0.4.1 Sep 19, 2019
0.3.0 Aug 31, 2019
0.2.0 Aug 29, 2019
0.1.1 Aug 24, 2019

#16 in Caching

Download history 27/week @ 2019-08-20 36/week @ 2019-08-27 31/week @ 2019-09-03 14/week @ 2019-09-10 72/week @ 2019-09-17 32/week @ 2019-09-24 12/week @ 2019-10-01 2/week @ 2019-10-08 18/week @ 2019-10-15 28/week @ 2019-10-22 8/week @ 2019-10-29 14/week @ 2019-11-05

98 downloads per month

MIT license

28KB
702 lines

fn_cache crate

This crate implements an easy way to cache values for a function. If you have a slow running function, this can be used to speed up successive runs dramatically. It is also quite useful for memoization of recursive functions, to prevent calculating the same function twice in different calls.

Of particular note, this caching is done without cloning or copying, allowing functions to return large objects, while the cache only returns a reference to them instead of copying them.

Allowed functions

This crate attempts to remain fairly flexible with the functions it accepts. All of the following should be allowed:

  • fn types.
  • Fn types that have no references.
  • Fn + 'static types that take only static references.
  • Fn + 'a types that take references of lifetime 'a.

For obvious reasons, FnMut and FnOnce are not allowed, as functions need to be rerunnable and pure.

Examples

The following example shows a recursive fibonacci implementation, which would be O(2ⁿ) without memoization (caching). With memoization, it becomes O(n), and can easily be calculated.

use fn_cache::HashCache;

let mut cache = HashCache::<u8,u128>::new(|cache, x|
    match x {
        0 => 0,
        1 => 1,
        _ => *cache.get(x - 1) + *cache.get(x - 2),
    }
);

assert_eq!(
    *cache.get(186),
    332_825_110_087_067_562_321_196_029_789_634_457_848
);

For even bigger results, the num crate might be employed. In order to avoid copying the BigUints while accessing the cache twice, you can to change the result to be stored in an Rc.

use std::rc::Rc;
use fn_cache::HashCache;
use num_bigint::BigUint;

let mut cache = HashCache::<u64,Rc<BigUint>>::new(|cache, x|
    match x {
        0 => BigUint::new(vec![0]),
        1 => BigUint::new(vec![1]),
        _ => cache.get(x - 1).clone().as_ref()
            + cache.get(x - 2).clone().as_ref(),
    }
);

assert_eq!(
    cache.get(999).clone().as_ref(),
    &BigUint::parse_bytes(b"26863810024485359386146727202142923967616609318986952340123175997617981700247881689338369654483356564191827856161443356312976673642210350324634850410377680367334151172899169723197082763985615764450078474174626", 10).unwrap()
);

No runtime deps