mpstthree 0.1.17

A library implementing Multiparty Session Types for 2 or more participants
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

use mpstthree::binary::close::close;
use mpstthree::binary::fork::fork_with_thread_id;
use mpstthree::binary::recv::recv;
use mpstthree::binary::send::send;
use mpstthree::binary::struct_trait::{end::End, recv::Recv, send::Send, session::Session};
use mpstthree::{choose, offer};

use rand::{thread_rng, Rng};

use std::error::Error;
use std::thread::spawn;

// S
enum Binary0A {
    Accept(Rec1A),
    Query(Recv<(), Recv<(), Recv<(), Rec0A>>>),
}
enum Binary1A {
    Yes(Recv<(), Recv<(), Recv<(), Recv<(), Recv<(), End>>>>>),
    No(Recv<(), Recv<(), Recv<(), End>>>),
}
type Rec0A = Recv<Binary0A, End>;
type Rec1A = Recv<Binary1A, End>;
type FullA = Rec0A;

fn binary_a(s: FullA) -> Result<(), Box<dyn Error>> {
    offer!(s, {
        Binary0A::Accept(s) => {
            offer!(s, {
                Binary1A::Yes(s) => {
                    let (_yes_a, s) = recv(s)?;
                    let (_yes_s, s) = recv(s)?;
                    let (_payment, s) = recv(s)?;
                    let (_ack, s) = recv(s)?;
                    let (_bye, s) = recv(s)?;
                    close(s)
                },
                Binary1A::No(s) => {
                    let (_no_a, s) = recv(s)?;
                    let (_no_s, s) = recv(s)?;
                    let (_bye_a, s) = recv(s)?;
                    close(s)
                },
            })
        },
        Binary0A::Query(s) => {
            let (_query_a, s) = recv(s)?;
            let (_quote_c, s) = recv(s)?;
            let (_dummy_s, s) = recv(s)?;
            binary_a(s)
        },
    })
}

// C
type FullB = <FullA as Session>::Dual;

fn binary_yes_b(s: FullB) -> Result<(), Box<dyn Error>> {
    let s: Send<Binary1A, End> = choose!(Binary0A::Accept, s);
    let s = choose!(Binary1A::Yes, s);
    let s = send((), s);
    let s = send((), s);
    let s = send((), s);
    let s = send((), s);
    let s = send((), s);
    close(s)
}

fn binary_no_b(s: FullB) -> Result<(), Box<dyn Error>> {
    let s: Send<Binary1A, End> = choose!(Binary0A::Accept, s);
    let s = choose!(Binary1A::No, s);
    let s = send((), s);
    let s = send((), s);
    let s = send((), s);
    close(s)
}

fn binary_query_b(s: FullB) -> Result<FullB, Box<dyn Error>> {
    let s = choose!(Binary0A::Query, s);
    let s = send((), s);
    let s = send((), s);
    let s = send((), s);
    Ok(s)
}

fn main() {
    let mut threads = Vec::new();
    let mut sessions = Vec::new();

    let (thread, session) = fork_with_thread_id(binary_a);

    threads.push(thread);
    sessions.push(session);

    let main = spawn(move || {
        for _ in 0..LOOPS {
            sessions = sessions
                .into_iter()
                .map(|s| binary_query_b(s).unwrap())
                .collect::<Vec<_>>();
        }

        let choice = thread_rng().gen_range(1..=2);

        if choice != 1 {
            sessions.into_iter().for_each(|s| binary_yes_b(s).unwrap());
        } else {
            sessions.into_iter().for_each(|s| binary_no_b(s).unwrap());
        }

        threads.into_iter().for_each(|elt| elt.join().unwrap());
    });

    main.join().unwrap();
}

static LOOPS: i32 = 100;