next-gen 0.0.6

Safe generators on stable Rust.
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

use_prelude!();

use ::core::mem::MaybeUninit;

/// Like `Cell<Option<T>>`, but ensures no layout optimization takes place so
/// that the `Some/None` discriminant can be read directly.
//
// # Safety invariant
//
//   - if `is_some`, then `value` is sound to `assume_init()`
pub
struct CellOption<T> /* = */ {
    is_some: Cell<bool>,
    value: Cell<MaybeUninit<T>>,
}

impl<T> Default for CellOption<T> {
    #[inline]
    fn default ()
      -> Self
    {
        Self::None
    }
}

impl<T> CellOption<T> {
    /// `Cell::new(None)`
    #[allow(bad_style)]
    pub
    const None: Self = Self {
        is_some: Cell::new(false),
        value: Cell::new(MaybeUninit::uninit()),
    };

    /// `Cell::new(Some(value))`
    #[cfg(FALSE)]
    #[allow(bad_style)]
    pub
    const
    fn Some (value: T)
      -> Self
    {
        Self {
            value: Cell::new(MaybeUninit::new(value)),
            is_some: Cell::new(true),
        }
    }

    /// `Cell::replace(self, None)`
    pub
    fn take (self: &'_ Self)
      -> Option<T>
    {
        if self.is_some() { // ------------------------+
            self.is_some.set(false);                // | # Safety
            Some(unsafe {                           // |
                self.value                          // |   - value was init
                    .replace(MaybeUninit::uninit()) // |
                    .assume_init() // <----------------+
            })
        } else {
            None
        }
    }

    /// `Cell::replace(self, Some(value))`
    pub
    fn set (self: &'_ Self, value: T)
      -> Option<T>
    {
        let prev = self.value.replace(MaybeUninit::new(value));
        if self.is_some() {
            Some(unsafe {
                // # Safety
                //
                // From safety invariant.
                prev.assume_init()
            })
        } else {
            self.is_some.set(true);
            None
        }
    }

    /// Returns `true` if and only if the `Cell` contains a value.
    #[inline]
    pub
    fn is_some (self: &'_ Self)
      -> bool
    {
        self.is_some.get()
    }

    /// Returns `true` if and only if the `Cell` contains no value.
    #[inline]
    pub
    fn is_none (self: &'_ Self)
      -> bool
    {
        use ::core::ops::Not;
        self.is_some().not()
    }
}