sloth

This crate provides a generic pointer-like Lazy<T, Eval> struct for lazily initialized values. It can be used for expensive-to-calculate values to ensure that the evaluation logic runs only once and only if needed.

For example: ```rust use sloth::Lazy;

fn getexpensivestring() -> String { // do something expensive here to obtain the result, // such as read and process file contents String::from("some expensive string we got from a file or something") }

fn getexpensivenumber() -> i32 { // do something expensive here to calculate the result, // such as build a supercomputer and wait 7.5 million years 42 }

let lazystring = Lazy::new(getexpensivestring); let lazynumber = Lazy::new(getexpensivenumber);

//... let mustusestring = true; //...

if mustusestring { println!("Expensive string is: {}", *lazystring); println!("It has length: {}", lazystring.len());

// get_expensive_string() has been called only once,
// get_expensive_number() has not been called

} else { println!("Expensive number is: {}", *lazynumber); println!("Its square is {}", lazynumber.pow(2));

// get_expensive_string() has not been called,
// get_expensive_number() has been called only once

}

```

The evaluated value of a mutable Lazy can be modified: ```rust use sloth::Lazy;

let mut lazy_vec = Lazy::new(|| vec![2, -5, 6, 0]);

lazy_vec.retain(|n| *n > 0);

asserteq!(*lazyvec, vec![2, 6]); ```

Lazy can be consumed and turned into its value via unwrap(): ```rust use sloth::Lazy;

let lazy_value = Lazy::new(|| "moo");

let output = String::from("a cow goes ") + lazy_value.unwrap(); ```