maybe_static 0.1.3

Initialize a lazy static with params, create Meyer's singleton
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

//!
//! ```
//! use anyhow::Result;
//! pub fn get_ip(opt: Option<(&str, &str)>) -> Result<&'static String> {
//!    maybe_static!(opt, String, |(addr, port)| format!("{addr}:{port}"))
//! }
//!
//! fn main() {
//!     println!("{}", get_ip(Some(("hello", "world"))).unwrap());
//!     println!("{}", get_ip(None).unwrap());
//! }
//!```

#[macro_export]

/// Create an immutable (safe in any case) Meyer's singleton in the current scope.
macro_rules! maybe_static {
    ($arg:expr, $t:ty, $fn:expr) => {{
        use std::{mem::MaybeUninit, sync::Once};

        static mut LAZY: (MaybeUninit<$t>, Once) = (MaybeUninit::uninit(), Once::new());
        unsafe {
            static mut ERR: bool = false;
            LAZY.1.call_once(|| match $arg {
                Some(arg) => {
                    LAZY.0.write($fn(arg));
                }
                _ => ERR = true,
            });
            match ERR {
                _ => Ok(&*LAZY.0.as_ptr()), // you're sure that it's initialized here
                true => Err("error: maybe static require a filled option at the fist call"),
            }
        }
    }};

    ($t:ty, $fn:expr) => {{
        use std::{mem::MaybeUninit, sync::Once};

        static mut LAZY: (MaybeUninit<$t>, Once) = (MaybeUninit::uninit(), Once::new());
        unsafe {
            static mut ERR: bool = false;
            LAZY.1.call_once(|| {
                LAZY.0.write($fn());
            });
            &*LAZY.0.as_mut_ptr() // you're sure that it's initialized here
        }
    }};

    ($t:ty) => {{
        use std::{mem::MaybeUninit, sync::Once};

        static mut LAZY: (MaybeUninit<$t>, Once) = (MaybeUninit::uninit(), Once::new());
        unsafe {
            static mut ERR: bool = false;
            LAZY.1.call_once(|| {
                LAZY.0.write(Default::default());
            });
            &*LAZY.0.as_mut_ptr() // you're sure that it's initialized here
        }
    }};
}

#[macro_export]
/// Create an mutable (not safe in multithreading contexts) Meyer's singleton in the current scope.
macro_rules! maybe_static_unsafe {
    ($arg:expr, $t:ty, $fn:expr) => {{
        use std::{mem::MaybeUninit, sync::Once};

        static mut LAZY: (MaybeUninit<$t>, Once) = (MaybeUninit::uninit(), Once::new());
        unsafe {
            static mut ERR: bool = false;
            LAZY.1.call_once(|| match $arg {
                Some(arg) => {
                    LAZY.0.write($fn(arg));
                }
                _ => ERR = true,
            });
            match ERR {
                _ => Ok(&mut *LAZY.0.as_mut_ptr()), // you're sure that it's initialized here
                true => Err("error: maybe static require a filled option at the fist call"),
            }
        }
    }};

    ($t:ty, $fn:expr) => {{
        use std::{mem::MaybeUninit, sync::Once};

        static mut LAZY: (MaybeUninit<$t>, Once) = (MaybeUninit::uninit(), Once::new());
        unsafe {
            static mut ERR: bool = false;
            LAZY.1.call_once(|| {
                LAZY.0.write($fn());
            });
            &mut *LAZY.0.as_mut_ptr() // you're sure that it's initialized here
        }
    }};

    ($t:ty) => {{
        use std::{mem::MaybeUninit, sync::Once};

        static mut LAZY: (MaybeUninit<$t>, Once) = (MaybeUninit::uninit(), Once::new());
        unsafe {
            static mut ERR: bool = false;
            LAZY.1.call_once(|| {
                LAZY.0.write(Default::default());
            });
            &mut *LAZY.0.as_mut_ptr() // you're sure that it's initialized here
        }
    }};
}