Lib.rs

Rust 的会话类型

这是 Rust 的会话类型实现。

使用此库，您可以实现具有编译时保证，即双方都不会违反通信协议的**双向进程通信**。

入门

session-types 可在 crates.io 上找到。建议您在那里查找最新发布的版本以及指向最新文档构建的链接。

在更新此 README 的最后，最新发布的版本可以使用如下方式

将以下依赖项添加到您的 Cargo 清单...

[dependencies]
session_types = "0.3.1"

...并查看 文档 了解如何使用它。

示例

extern crate session_types;
use session_types::*;
use std::thread;

type Server = Recv<i64, Send<bool, Eps>>;
type Client = <Server as HasDual>::Dual;

fn srv(c: Chan<(), Server>) {
    let (c, n) = c.recv();
    if n % 2 == 0 {
        c.send(true).close()
    } else {
        c.send(false).close()
    }
}

fn cli(c: Chan<(), Client>) {
    let n = 42;
    let c = c.send(n);
    let (c, b) = c.recv();

    if b {
        println!("{} is even", n);
    } else {
        println!("{} is odd", n);
    }

    c.close();
}

fn main() {
    let (server_chan, client_chan) = session_channel();

    let srv_t = thread::spawn(move || srv(server_chan));
    let cli_t = thread::spawn(move || cli(client_chan));

    let _ = (srv_t.join(), cli_t.join());
}

我们首先指定一个 协议。协议是由协议类型 Send、Recv、Choose、Offer、Rec 和 Var 构建的（见 协议类型）。在这种情况下，我们的协议是

type Server = Recv<i64, Send<bool, Eps>>;

它读取

• 接收一个有符号的 64 位整数
• 发送一个布尔值
• 关闭通道

Client 协议是 双，这是会话类型中的一个明确概念。简而言之，这意味着一个进程中的每个协议步骤在另一个进程中都有一个匹配的步骤。如果一个进程想发送一个值，另一个进程必须准备好接收它。 Server 的双是

type Client = Send<i64, Recv<bool, Eps>>;

使用 session-types，我们不需要手动构建双，因为我们利用特例系统使用 HasDual 特例来模拟此概念。这允许我们这样做

type Client = <Server as HasDual>::Dual;

为什么它很酷？

会话类型不是一个新概念。它们很酷，因为它们允许进行 编译时 验证进程通信。换句话说，我们能够静态地检查两个通信进程是否遵守其共享的通信协议。

但是实现会话类型需要一种方式来模拟协议中某些动作已经发生。在大多数编程语言中，这通常是一个静态操作中的复杂事情，但在Rust中，由于移动语义，这变得很容易。

使用移动语义，我们确保协议中的“前进一步”（发送、接收等）不能重复。

协议类型

任何会话类型的通信协议都是由一些基本构建块构成的。本节逐对介绍它们，展示一个动作及其对偶。

会话类型的通道定义为Chan<E, P>，其中E是一个环境，P是一个协议。环境E对于新创建的通道始终是()（即它是空的）。

type Close = Eps;

let (a, b) = session_channel::<Eps>();
a.close();
b.close();

type S = Send<String, Eps>;
type R = Recv<String, Eps>; // <S as HasDual>::Dual

type C = Choose<Send<String, Eps>, Recv<String, Eps>>;
type O = Offer<Recv<String, Eps>, Send<String, Eps>>; // <C as Hasdual>::Dual

enum Branch<L, R> {
    Left(L),
    Right(R),
}

match c.offer() {
    Branch::Left(c) => …,
    Branch::Right(c) => …,
}

type RS = Rec<Send<String, Var<Z>>>;
type RR = Rec<Recv<String, Var<Z>>>; // <RS as HasDual>::Dual

let c: Chan<(), Rec<Send<String, Var<Z>>> = …;
let mut c = c.enter();
loop {
    c = c.send("Hello!".to_string()).zero();
}

type Server = Rec<
                  Offer<
                      Eps,
                      Recv<String, Send<usize, Var<Z>>>
                  >
              >;

let c: Chan<(), Server> = …;
let mut c = c.enter();                  // c: Chan<(Offer<…>, ()), Offer<…>>
loop {
    c = match c.offer() {
        Branch::Left(c) => {            // c: Chan<(Offer<…>, ()), Eps>
            c.close();
            break
        },
        Branch::Right(c) => {           // c: Chan<(Offer<…>, ()), Recv<String, Send<usize, Var<Z>>>>
            let (c, str) = c.recv();    // c: Chan<(Offer<…>, ()), Send<usize, Var<Z>>>
            let c = c.send(str.len());  // c: Chan<(Offer<…>, ()), Var<Z>>
            c.zero()                    // c: Chan<(Offer<…>, ()), Offer<…>>
        }
    };
}