Crate sesh

Sesh 🥂

Sesh is an implementation of deadlock-free binary session types with failure in Rust.

What does that mean?

• The session types bit means that it uses Rust types to describe communication protocols, and ensure that they’re implemented correctly.
• The binary bit means that for any protocol, there’s two parties involved, no more, no less.
• The deadlock-free bit means, well, that if you write your session typed programs using Sesh, and you don’t cheat by using other concurrency constructs, your can be sure your programs won’t deadlock!
• The with failure bit means Sesh is aware that sometimes programs may fail, and that it takes failure into account. If one of the parties involved in a protocol crashes, like if the thread panics, the Sesh lets the other party know, to make sure it doesn’t end up just waiting forever.

The author of this package is an academic, so she is contractually obliged to only come up with uninspiring examples. With that in mind, let’s pretend you want a server that does addition. You send it two numbers, and it sends you a number back. There’s two session types associated with that protocol. One for the client and one for the server. The type for the server, using Sesh, would be:

type AddServer = Recv<i64, Recv<i64, Send<i64, End>>>;

Session types are always dual. If the client sends a number, the server should be ready to receive a number, otherwise we’d be in trouble. We can get the session type for the client using duality. This just replaces all sends by receives, and vice versa:

type AddClient = <AddServer as Session>::Dual;

Once you’ve written down the protocol, the hard part is out of the way. Rust will make sure our server follows the protocol:

fn add_server(s: AddServer) -> Result<(), Box<dyn Error>> {
  let (i, s) = recv(s)?;  // Receive the first number.
  let (j, s) = recv(s)?;  // Receive the second number.
  let s = send(i + j, s); // Send the sum of both numbers.
  close(s)                // Close the session.
}

Macros

choose

Choose between many different sessions wrapped in an enum

offer

Offer a choice between many different sessions wrapped in an enum

Structs

End

End of communication.

Recv

Receive T, then continue as S.

Send

Send T, then continue as S.

Traits

Session

Trait for session types. Provides duality.

Functions

cancel

Cancels a session. Always succeeds. If the partner calls recv or close after cancellation, those calls fail.

choose_left

Given a choice between sessions S1 and S1, choose the first option.

choose_right

Given a choice between sessions S1 and S1, choose the second option.

close

Closes a session. Synchronises with the partner, and fails if the partner has crashed.

fork

Creates a child process, and a session with two dual endpoints of type S and S::Dual. The first endpoint is given to the child process. Returns the second endpoint.

offer_either

Offer a choice between two sessions S1 and S2.

recv

Receive a value of type T. Can fail. Returns either a pair of the received value and the continuation of the session S or an error.

select

Selects the first active session. Receives from the selected session. Returns the received value, the continuation of the selected session, and a copy of the input vector without the selected session.

select_mut

Selects the first active session. Receives from the selected session, and removes the endpoint from the input vector. Returns the received value and the continuation of the selected session.

send

Send a value of type T. Always succeeds. Returns the continuation of the session S.

Type Aliases

Choose

Choose between two sessions S1 and S2. Implemented using Send and Either.

Offer

Offer a choice between two sessions S1 and S1. Implemented using Recv and Either.