rumpsteak 0.1.0

Session types for asynchronous communication between multiple parties.
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

pub use rumpsteak_macros::{Role, Roles};

use crate::channel;
use std::marker::PhantomData;

pub trait Role {
    type Message;
}

pub trait Pair<P: Pair<Self> + Role<Message = Self::Message>>: Role + Sized {
    fn pair() -> (Self, P);
}

pub trait Route<R: Route<Self> + Role<Message = Self::Message>>: Role + Sized {
    type Route: Pair<R::Route> + Role<Message = Self::Message>;

    fn route(&mut self) -> &mut Self::Route;
}

pub trait Sender<R: Role<Message = Self::Message>>: Role {
    fn sender(&mut self) -> &mut channel::Sender<Self::Message>;
}

pub trait Receiver<R: Role<Message = Self::Message>>: Role {
    fn receiver(&mut self) -> &mut channel::Receiver<Self::Message>;
}

pub struct Nil<R: Role>(PhantomData<R>);

impl<R: Role> Role for Nil<R> {
    type Message = R::Message;
}

impl<Q: Role, R: Role<Message = Q::Message>> Pair<Nil<R>> for Nil<Q> {
    #[inline]
    fn pair() -> (Nil<Q>, Nil<R>) {
        (Nil(PhantomData), Nil(PhantomData))
    }
}

pub struct To<R: Role>(channel::Sender<R::Message>);

impl<R: Role> Role for To<R> {
    type Message = R::Message;
}

impl<Q: Role, R: Role<Message = Q::Message>> Pair<From<R>> for To<Q> {
    #[inline]
    fn pair() -> (To<Q>, From<R>) {
        let (to, from) = channel::channel();
        (To(to), From(from))
    }
}

impl<R: Role> Sender<R> for To<R> {
    #[inline]
    fn sender(&mut self) -> &mut channel::Sender<R::Message> {
        &mut self.0
    }
}

pub struct From<R: Role>(channel::Receiver<R::Message>);

impl<R: Role> Role for From<R> {
    type Message = R::Message;
}

impl<Q: Role, R: Role<Message = Q::Message>> Pair<To<R>> for From<Q> {
    #[inline]
    fn pair() -> (From<Q>, To<R>) {
        let (to, from) = channel::channel();
        (From(from), To(to))
    }
}

impl<R: Role> Receiver<R> for From<R> {
    #[inline]
    fn receiver(&mut self) -> &mut channel::Receiver<R::Message> {
        &mut self.0
    }
}

pub struct ToFrom<R: Role>(To<R>, From<R>);

impl<R: Role> Role for ToFrom<R> {
    type Message = R::Message;
}

impl<Q: Role, R: Role<Message = Q::Message>> Pair<ToFrom<R>> for ToFrom<Q> {
    #[inline]
    fn pair() -> (ToFrom<Q>, ToFrom<R>) {
        let (left_to, left_from) = Pair::pair();
        let (right_to, right_from) = Pair::pair();
        (ToFrom(left_to, right_from), ToFrom(right_to, left_from))
    }
}

impl<R: Role> Sender<R> for ToFrom<R> {
    #[inline]
    fn sender(&mut self) -> &mut channel::Sender<R::Message> {
        self.0.sender()
    }
}

impl<R: Role> Receiver<R> for ToFrom<R> {
    #[inline]
    fn receiver(&mut self) -> &mut channel::Receiver<R::Message> {
        self.1.receiver()
    }
}