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.
Read the documentation (cargo doc --open) for the sparse details, or take a
look at the examples/, if you want to know more:
```rust // 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".tostring(), 0));
assert!(! hello("World".tostring(), 0));
// Sometimes one might need the original function.
assert!(! memoizedoriginalhello("World".to_string(), 0));
}
```
This is expanded into (with a few simplifications):
```rust
// This is obviously further expanded before compiling.
lazystatic! {
static ref MEMOIZEDMAPPING_HELLO : Mutex
fn memoizedoriginalhello(arg: String, arg2: usize) -> bool { arg.len() % 2 == arg2 }
fn hello(arg: String, arg2: usize) -> bool { let mut hm = &mut MEMOIZEDMAPPINGHELLO.lock().unwrap(); if let Some(r) = hm.get(&(arg.clone(), arg2.clone())) { return r.clone(); } let r = memoizedoriginalhello(arg.clone(), arg2.clone()); hm.insert((arg, arg2), r.clone()); r } ```
...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