par 0.3.10

Session types, as an implementation of linear logic with MIX
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

use par::{
    exchange::{Recv, Send},
    runtimes::tokio::fork,
    Dual,
};

enum Op {
    Plus,
    Times,
}

type Calculator = Send<i64, Send<Op, Send<i64, Recv<i64>>>>;
type User = Dual<Calculator>; // Recv<i64, Recv<Op, Recv<i64, Send<i64>>>>

fn start_calculator() -> Calculator {
    fork(|user: User| async {
        let (x, user) = user.recv().await;
        let (op, user) = user.recv().await;
        let (y, user) = user.recv().await;
        let result = match op {
            Op::Plus => x + y,
            Op::Times => x * y,
        };
        user.send1(result);
    })
}

#[tokio::main]
async fn main() {
    let sum = start_calculator()
        .send(3)
        .send(Op::Plus)
        .send(4)
        .recv1()
        .await;

    let product = start_calculator()
        .send(3)
        .send(Op::Times)
        .send(4)
        .recv1()
        .await;

    assert_eq!(sum, 7);
    assert_eq!(product, 12);
}