o3 0.21.1

shared-nothing primitives
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use std::cell;

use crate::{
    depot::{self, index},
    mem::{self, slot},
};

// SAFETY: the retained cell initialization lasts for the complete output loan.
unsafe impl<'a, T, M> depot::raw::Project<(), T> for &'a slot::Storage<T, M> {
    type Output = &'a T;

    unsafe fn project(self, _: ()) -> Self::Output {
        unsafe { mem::raw::project(self) }
    }
}

// SAFETY: the exclusive initialized cell owns its value and destruction.
unsafe impl<'a, T, M> depot::raw::Project<(), T> for &'a mut slot::Storage<T, M> {
    type Output = mem::raw::Occupied<'a, T>;

    unsafe fn project(self, _: ()) -> Self::Output {
        unsafe { mem::raw::occupy(self) }
    }
}

// SAFETY: the proof retains this exact vacant cell with no intervening writes.
unsafe impl<'a, T, M> depot::raw::Project<(), index::Vacant<T>> for &'a mut slot::Storage<T, M> {
    type Output = mem::raw::Vacant<'a, T>;

    unsafe fn project(self, _: ()) -> Self::Output {
        unsafe { mem::raw::vacancy(self) }
    }
}

// SAFETY: the proof retains an initialized index within this exact array.
unsafe impl<'a, T, const N: usize> depot::raw::Project<usize> for &'a [T; N] {
    type Output = &'a T;

    unsafe fn project(self, index: usize) -> Self::Output {
        unsafe { self.get_unchecked(index) }
    }
}

// SAFETY: the proof retains an exclusive initialized index in this exact array.
unsafe impl<'a, T, const N: usize> depot::raw::Project<usize> for &'a mut [T; N] {
    type Output = &'a mut T;

    unsafe fn project(self, index: usize) -> Self::Output {
        unsafe { self.get_unchecked_mut(index) }
    }
}

// SAFETY: the proof retains an exclusive initialized index in this exact slice.
unsafe impl<'a, T> depot::raw::Project<usize> for &'a mut [T] {
    type Output = &'a mut T;

    unsafe fn project(self, index: usize) -> Self::Output {
        unsafe { self.get_unchecked_mut(index) }
    }
}

// SAFETY: Key preserves each emitted identity and its exact index.
unsafe impl<K: crate::depot::raw::Key> crate::depot::raw::Address for K {
    fn index(self) -> usize {
        crate::depot::raw::Key::index(self)
    }
}

// SAFETY: `None` is absent; `Some` round-trips every item exactly.
unsafe impl<I: Copy + Eq> crate::depot::raw::Link for Option<I> {
    type Item = I;

    const NONE: Self = None;

    fn item(self) -> Option<I> {
        self
    }

    unsafe fn some(item: I) -> Self {
        Some(item)
    }
}

// SAFETY: the maximum primitive value is the reserved sentinel.
unsafe impl crate::depot::raw::Link for u16 {
    type Item = Self;

    const NONE: Self = Self::MAX;

    fn item(self) -> Option<Self> {
        (self != Self::NONE).then_some(self)
    }

    unsafe fn some(item: Self) -> Self {
        item
    }
}

// SAFETY: the maximum primitive value is the reserved sentinel.
unsafe impl crate::depot::raw::Link for u32 {
    type Item = Self;

    const NONE: Self = Self::MAX;

    fn item(self) -> Option<Self> {
        (self != Self::NONE).then_some(self)
    }

    unsafe fn some(item: Self) -> Self {
        item
    }
}

// SAFETY: u32 stores this exact chain's cardinality.
unsafe impl crate::depot::raw::ChainCount for u32 {
    const EMPTY: Self = 0;

    fn storage(count: &cell::Cell<Self>) -> Option<&cell::Cell<u32>> {
        Some(count)
    }
}

// SAFETY: unit deliberately stores no cardinality.
unsafe impl crate::depot::raw::ChainCount for () {
    const EMPTY: Self = ();

    fn storage(_: &cell::Cell<Self>) -> Option<&cell::Cell<u32>> {
        None
    }
}

mod key;
mod rounds;
mod word;

// SAFETY: every u32 is its own complete compact identity; both conversions
// return their scalar input without callbacks, panics, or reentry.
unsafe impl crate::depot::raw::Compact for u32 {
    const MAX: u32 = u32::MAX;

    fn into_raw(self) -> u32 {
        self
    }

    unsafe fn from_raw(raw: u32) -> Self {
        raw
    }
}

mod exacts;

mod tagged;