lazy_rc 0.1.3

Provides implementations of Rc<T> and Arc<T> with lazy initialization.
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

/*
 * lazy_rc - Rc<T> and Arc<T> with *lazy* initialization
 * This is free and unencumbered software released into the public domain.
 */
use std::error::Error;
use std::fmt::Debug;
use std::io::{Error as IoError, Result as IoResult};
use std::fmt::Display;
use std::ops::DerefMut;

type FnInit<T> = dyn Fn() -> T + Sync;
type FnInitFailable<T> = dyn Fn() -> IoResult<T> + Sync;

/// A wrapper that optionally contains a (possibly failable) initializer.
pub enum DefaultInit<T> {
    None,
    Infailable(Box<FnInit<T>>),
    Failable(Box<FnInitFailable<T>>),
}

/// An error that indicates that the initialization has failed.
#[derive(Debug)]
pub enum InitError {
    /// Initialization failed, because **no** default initializer is available!
    NoDefaultInitializer,
    /// The initializer function has failed! The original error is forwarded as
    /// "inner" value of this [`InitError`] variant.
    Failed(IoError),
}

pub fn or_init_with<T, F>(mut inner: impl DerefMut<Target = Option<T>>, init_fn: F) -> T
where
    T: Clone,
    F: FnOnce() -> T,
{
    match inner.as_ref() {
        Some(existing) => existing.clone(),
        None => inner.insert(init_fn()).clone(),
    }
}

pub fn or_try_init_with<T, E, F>(
    mut inner: impl DerefMut<Target = Option<T>>,
    init_fn: F,
) -> Result<T, E>
where
    T: Clone,
    F: FnOnce() -> Result<T, E>,
{
    match inner.as_ref() {
        Some(existing) => Ok(existing.clone()),
        None => match init_fn() {
            Ok(value) => Ok(inner.insert(value).clone()),
            Err(error) => Err(error),
        },
    }
}

impl<T> Debug for DefaultInit<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::None => write!(f, "None"),
            Self::Infailable(_) => write!(f, "Infailable"),
            Self::Failable(_) => write!(f, "Failable"),
        }
    }
}

impl Display for InitError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            InitError::NoDefaultInitializer => write!(f, "No default initializer available!"),
            InitError::Failed(error) => Display::fmt(&error, f),
        }
    }
}

impl Error for InitError {}