placid 0.1.0

Separated ownership and in-place construction in 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
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

use core::pin::Pin;

use crate::{
    init::{Init, InitPin, InitPinResult, InitResult, Initializer, IntoInit, IntoInitPin},
    owned::Own,
    pin::DropSlot,
    uninit::Uninit,
};

/// Chains initialization with a post-initialization closure for mutable access.
///
/// This initializer is created by calling the [`Init::and`] method, or by using
/// the [`and()`] factory function. It's chainable with other initializers.
///
/// [`Init`]: crate::init::Init
#[derive(Debug, PartialEq)]
pub struct And<I, F> {
    init: I,
    f: F,
}

impl<I, F> Initializer for And<I, F>
where
    I: Initializer,
{
    type Error = I::Error;
}

impl<T, I, F> InitPin<T> for And<I, F>
where
    T: ?Sized,
    I: Init<T>,
    F: FnOnce(&mut T),
{
    fn init_pin<'a, 'b>(
        self,
        place: Uninit<'a, T>,
        slot: DropSlot<'a, 'b, T>,
    ) -> InitPinResult<'a, 'b, T, I::Error> {
        let mut own = match self.init.init(place) {
            Ok(own) => own,
            Err(e) => return Err(e.into_pin(slot)),
        };
        (self.f)(&mut *own);
        Ok(Own::into_pin(own, slot))
    }
}

impl<T, I, F> Init<T> for And<I, F>
where
    T: ?Sized,
    I: Init<T>,
    F: FnOnce(&mut T),
{
    fn init(self, place: Uninit<'_, T>) -> InitResult<'_, T, I::Error> {
        let mut own = self.init.init(place)?;
        (self.f)(&mut *own);
        Ok(own)
    }
}

/// Chains initialization with a post-initialization closure for mutable access.
///
/// # Examples
///
/// ```rust
/// use placid::prelude::*;
///
/// let owned: Own<Vec<_>> = own!(init::and(vec![1, 2, 3], |v| v.push(4)));
/// assert_eq!(*owned, vec![1, 2, 3, 4]);
/// ```
pub fn and<M, I, F, T: ?Sized>(init: I, f: F) -> And<I::Init, F>
where
    I: IntoInit<T, M>,
    F: FnOnce(&mut T),
{
    And { init: init.into_init(), f }
}

/// Chains initialization with a post-initialization closure for pinned mutable
/// access.
///
/// This initializer is created by calling the [`InitPin::and_pin`] method, or
/// by using the [`and_pin()`] factory function. It's chainable with other
/// initializers.
#[derive(Debug, PartialEq)]
pub struct AndPin<I, F> {
    init: I,
    f: F,
}

impl<I, F> Initializer for AndPin<I, F>
where
    I: Initializer,
{
    type Error = I::Error;
}

impl<T, I, F> InitPin<T> for AndPin<I, F>
where
    T: ?Sized,
    I: InitPin<T>,
    F: FnOnce(Pin<&mut T>),
{
    fn init_pin<'a, 'b>(
        self,
        place: Uninit<'a, T>,
        slot: DropSlot<'a, 'b, T>,
    ) -> InitPinResult<'a, 'b, T, I::Error> {
        let mut own = self.init.init_pin(place, slot)?;
        (self.f)(own.as_mut());
        Ok(own)
    }
}

/// Chains initialization with a post-initialization closure for pinned mutable
/// access.
///
/// # Examples
///
/// ```rust
/// use placid::prelude::*;
/// use core::pin::Pin;
///
/// let owned = pown!(init::and_pin(
///     vec![1, 2, 3],
///     |mut v| v.as_mut().push(4),
/// ));
/// assert_eq!(*owned, [1, 2, 3, 4]);
/// ```
pub fn and_pin<M, I, F, T: ?Sized>(init: I, f: F) -> AndPin<I::Init, F>
where
    I: IntoInitPin<T, M>,
    F: FnOnce(Pin<&mut T>),
{
    AndPin { init: init.into_init(), f }
}