Struct lunatic::protocol::Protocol

pub struct Protocol<P: 'static, S = Bincode> { /* private fields */ }

A Protocol is a specific type of Process.

It uses session types to check during compile time that all messages exchanged between two processes are in the correct order and of the correct type.

Implementations

impl<P, A, S> Protocol<Send<A, P>, S>where
    S: Serializer<A>,

pub fn send(self, message: A) -> Protocol<P, S>

Send a value of type A over the session. Returns a session with protocol P.

impl<P, A, S> Protocol<Recv<A, P>, S>where
    S: Serializer<A>,

pub fn receive(self) -> (Protocol<P, S>, A)

Receives a value of type A from the session. Returns a tuple containing the resulting session and the received value.

impl<A, S> Protocol<Recv<A, TaskEnd>, S>where
    S: Serializer<A>,

pub fn result(self) -> A

A task is a special case of a protocol spawned with the spawn!(@task ...) macro. It only returns one value.

pub fn result_timeout(self, duration: Duration) -> MailboxResult<A>

A task is a special case of a protocol spawned with the spawn!(@task ...) macro. It only returns one value.

impl<P, Q, S> Protocol<Choose<P, Q>, S>where
    S: Serializer<bool>,

pub fn select_left(self) -> Protocol<P, S>

Perform an active choice, selecting protocol P.

pub fn select_right(self) -> Protocol<Q, S>

Perform an active choice, selecting protocol Q.

impl<P, Q, S> Protocol<Offer<P, Q>, S>where
    S: Serializer<bool>,

pub fn offer(self) -> Branch<Protocol<P, S>, Protocol<Q, S>>

Passive choice. This allows the other end of the session to select one of two options for continuing the protocol: either P or Q.

Trait Implementations

impl<P: Debug + 'static, S: Debug> Debug for Protocol<P, S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<P: 'static, S> Drop for Protocol<P, S>

fn drop(&mut self)

Executes the destructor for this type.

impl<P: Hash + 'static, S: Hash> Hash for Protocol<P, S>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,

Feeds a slice of this type into the given Hasher.