Struct async_session_types::Chan

pub struct Chan<P, E, R> { /* private fields */ }

A session typed channel. P is the protocol and E is the environment, containing potential recursion targets. R is the representation of messages, which could be DynMessage, or perhaps something we know statically how to turn into JSON or bytes.

Implementations

impl<E, R> Chan<Eps, E, R>

pub fn close(self) -> SessionResult<()>

Close a channel. Should always be used at the end of your program.

impl<P, E, R> Chan<P, E, R>

pub fn abort<T, F: Error + Send + 'static>(self, e: F) -> SessionResult<T>

Close the channel and return an error due to some business logic violation.

pub fn abort_dyn<T>(self, e: Box<dyn Error + Send>) -> SessionResult<T>

impl<P, E, T, R: Repr<T>> Chan<Send<T, P>, E, R>

pub fn send(self, v: T) -> SessionResult<Chan<P, E, R>>

Send a value of type T over the channel. Returns a channel with protocol P.

impl<P, E, T, R: Repr<T>> Chan<Recv<T, P>, E, R>

pub async fn recv(self, timeout: Duration) -> SessionResult<(Chan<P, E, R>, T)>

Receives a value of type T from the channel. Returns a tuple containing the resulting channel and the received value.

impl<P: Outgoing, Q: Outgoing, E, R> Chan<Choose<P, Q>, E, R>

pub fn sel1(self) -> Chan<P, E, R>

Perform an active choice, selecting protocol P. We haven’t sent any value yet, so the agency stays on our side.

pub fn sel2(self) -> Chan<Q, E, R>

Perform an active choice, selecting protocol Q. We haven’t sent any value yet, so the agency stays on our side.

impl<P: Incoming, Q: Incoming, E, R> Chan<Offer<P, Q>, E, R> where
    P::Expected: 'static,
    R: Repr<P::Expected>, 

pub async fn offer(
    self,
    t: Duration
) -> SessionResult<Branch<Chan<P, E, R>, Chan<Q, E, R>>>

Passive choice. This allows the other end of the channel to select one of two options for continuing the protocol: either P or Q. Both options mean they will have to send a message to us, the agency is on their side.

impl<P, E, R> Chan<Rec<P>, E, R>

pub fn enter(self) -> Chan<P, (P, E), R>

Enter a recursive environment, putting the current environment on the top of the environment stack.

impl<P, E, R> Chan<Var<Z>, (P, E), R>

pub fn zero(self) -> SessionResult<Chan<P, (P, E), R>>

Recurse to the environment on the top of the environment stack. The agency must be kept, since there’s no message exchange here, we just start from the top as a continuation of where we are.

impl<P, E, N, R> Chan<Var<S<N>>, (P, E), R>

pub fn succ(self) -> Chan<Var<N>, E, R>

Pop the top environment from the environment stack.

Trait Implementations

impl<P, E, R> Drop for Chan<P, E, R>

A sanity check destructor that kicks in if we abandon the channel by returning Ok(_) without closing it first.

fn drop(&mut self)

Executes the destructor for this type.