#static #lazy-evaluation #singleton #parameters

maybe_static

Initialize a lazy static with params, create Meyer's singleton

4 releases

0.1.3 Apr 20, 2023
0.1.2 Jun 30, 2022
0.1.1 Jun 30, 2022
0.1.0 Jun 30, 2022

#2786 in Rust patterns

MIT license

7KB
84 lines

Maybe static

Initialize in a lazy way a static variable with parameters.

Example of a simple usage:

use maybe_static::maybe_static;

pub fn get_lazy(opt: Option<(&str, &str)>) -> Result<&'static String, &'static str> {
    maybe_static!(opt, String, |(a, b)| format!("{a}:{b}"))
}

fn main() {
    println!("{}", get_lazy(Some(("hello", "world"))).unwrap());
    println!("{}", get_lazy(None).unwrap());
}

The macro will create a local static variable that is initialized once, ONLY ONCE. It's also totally thread safe.

fn main() {
    println!("{}", get_lazy(Some(("hello", "world"))).unwrap());
    // print hello:world (initialize)
    println!("{}", get_lazy(None).unwrap());
    // print hello:world
    println!("{}", get_lazy(Some(("foo", "bar"))).unwrap());
    // still print hello:world
}

Require a Some for the first initialization.

fn main() {
    println!("{}", get_lazy(None).unwrap()); // Error!
}

Create a new unique value by scope.

fn main() {
    let a = maybe_static!(Some(("hello", "world")), String, |(a, b)| format!(
        "{a}:{b}"
    ))
    .unwrap();
    let b = maybe_static!(Some(("foo", "bar")), String, |(a, b)| format!(
        "{a}:{b}"
    ))
    .unwrap();
    println!("{a}\n{b}")
    // hello:world
    // foo:bar


    for i in 0..3 {
        print!("{}", maybe_static!(Some(i), usize, |i| i).unwrap());
    }
    // 000
}

Initially developed around the article in the maybeuninit blog

No runtime deps