projections 0.2.0

Macro-free pin projections because why not?
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

mod lib {
    use core::pin::Pin;

    use projections::Sp;

    // Sealed unique type to make namespace collisions impossible.
    pub struct Seal;

    pub type StructurallyPinnedStruct =
        Sp<u32, String, Option<&'static [u8]>, Seal>;

    pub struct StructurallyPinnedStructBuilder {
        pub a: u32,
        pub b: String,
        pub c: Option<&'static [u8]>,
    }

    impl StructurallyPinnedStructBuilder {
        pub fn build(self) -> StructurallyPinnedStruct {
            let Self { a, b, c } = self;
            Sp::from_a(a).with_b(b).with_c(c).with_d(Seal)
        }
    }

    pub trait StructurallyPinnedStructApi {
        fn use_pinned_types(self: Pin<&mut Self>);
    }

    impl StructurallyPinnedStructApi for StructurallyPinnedStruct {
        fn use_pinned_types(mut self: Pin<&mut Self>) {
            let _a: Pin<&mut u32> = self.as_mut().a();
            let _b: Pin<&mut String> = self.as_mut().b();
            let _c: Pin<&mut Option<&'static [u8]>> = self.as_mut().c();
        }
    }
}

use core::pin::Pin;

use lib::{StructurallyPinnedStructApi, StructurallyPinnedStructBuilder};

fn main() {
    let mut structurally_pinned_struct = StructurallyPinnedStructBuilder {
        a: 4,
        b: "eight".to_string(),
        c: Some(b"15"),
    }
    .build();

    Pin::new(&mut structurally_pinned_struct).use_pinned_types();
}