pipecircuit 0.0.22

Correct. Robust. Fast. Portable. Pick four.
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

pub use crate::{TransportFrom, TransportTo};

use core::marker::PhantomData;

use crate::{Pipe, StateMachine, StepInputOf};

mod private {
    use super::{Pipe, StateMachine, StepInputOf};

    pub(super) trait StepLaw<'message, Protocol: Pipe> {}

    impl<'message, Machine, Protocol> StepLaw<'message, Protocol> for Machine
    where
        Machine: StateMachine,
        Protocol: Pipe,
        Protocol::In<'message>: StepInputOf<Machine, Outcome = Protocol::Out<'message>>,
    {
    }
}

#[doc(hidden)]
#[allow(private_bounds)]
pub trait StepsPipeInputToOutput<'message, Protocol: Pipe>:
    StateMachine + private::StepLaw<'message, Protocol>
{
    #[must_use = "pipe step outcomes must be routed or settled"]
    #[doc(hidden)]
    fn step_boundary(&mut self, input: Protocol::In<'message>) -> Protocol::Out<'message>;
}

impl<'message, Machine, Protocol> StepsPipeInputToOutput<'message, Protocol> for Machine
where
    Machine: StateMachine,
    Protocol: Pipe,
    Protocol::In<'message>: StepInputOf<Machine, Outcome = Protocol::Out<'message>>,
{
    fn step_boundary(&mut self, input: Protocol::In<'message>) -> Protocol::Out<'message> {
        input.step(self)
    }
}

/// A synchronous transport bound to one named pipe and one local implementation.
/// Use `for_pipe` when the protocol is separate from the implementing machine.
pub struct Inline<Implementation, Protocol = Implementation> {
    destination: Implementation,
    protocol: PhantomData<fn() -> Protocol>,
}

impl<Implementation> Inline<Implementation> {
    pub const fn new(destination: Implementation) -> Self {
        Self {
            destination,
            protocol: PhantomData,
        }
    }

    pub const fn for_pipe<Protocol: Pipe>(
        destination: Implementation,
    ) -> Inline<Implementation, Protocol> {
        Inline {
            destination,
            protocol: PhantomData,
        }
    }
}

impl<Implementation, Protocol> Inline<Implementation, Protocol> {
    pub const fn destination(&self) -> &Implementation {
        &self.destination
    }

    pub fn into_destination(self) -> Implementation {
        self.destination
    }
}

impl<Implementation, Protocol> TransportTo<Protocol> for Inline<Implementation, Protocol>
where
    Protocol: Pipe,
    Implementation: for<'message> StepsPipeInputToOutput<'message, Protocol>,
{
    type Outcome<'transport, 'message>
        = Protocol::Out<'message>
    where
        Self: 'transport;

    fn send<'transport, 'message>(
        &'transport mut self,
        input: Protocol::In<'message>,
    ) -> Self::Outcome<'transport, 'message> {
        self.destination.step_boundary(input)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    struct Counter(u8);

    impl StateMachine for Counter {}

    struct Add(u8);

    impl Pipe for Counter {
        type In<'message> = Add;
        type Out<'message> = u8;
    }

    impl StepInputOf<Counter> for Add {
        type Outcome = u8;

        fn step(self, counter: &mut Counter) -> Self::Outcome {
            counter.0 = counter.0.saturating_add(self.0);
            counter.0
        }
    }

    #[test]
    fn inline_transport_completes_the_precise_step() {
        let mut transport = Inline::new(Counter(3));
        assert_eq!(TransportTo::<Counter>::send(&mut transport, Add(4)), 7);
        assert_eq!(transport.into_destination().0, 7);
    }
}