Trait Reacting 

pub trait Reacting: Sized + 'static {
    type Kept: 'static;

    // Required methods
    async fn hear(&mut self, said: Message) -> Result<(), Failure>;
    async fn answer(&mut self, asked: Message) -> Result<Answer, Failure>;
    async fn finish(self) -> Result<Self::Kept, Failure>;
}

One shell’s reaction, for as long as that shell can speak.

It runs as a task of its own, so it owns what it holds ('static) and is never sent to another thread. Awaiting inside a method yields to the other shells’ tasks; synchronous work blocks them for its duration.

hear	a Message nobody is waiting on
answer	one the shell blocks on; the task writes the Answer back to it
finish	what is left, which lands in Attended::kept

No method has a default body. The two implementations below are the templates to copy.

Required Associated Types

type Kept: 'static

What is left when the shell can no longer speak. Self where nothing is released at the end.

Required Methods

async fn hear(&mut self, said: Message) -> Result<(), Failure>

A Failure from this or answer ends the conversation: under Driving the subject is killed and the run yields that reason.

async fn answer(&mut self, asked: Message) -> Result<Answer, Failure>

An answer is a command, and every answer is the same kind of thing. Saying no is a command that returns non-zero — Answer::unknown for a word this rig has no answer for.

async fn finish(self) -> Result<Self::Kept, Failure>

The conversation is over; release what this held.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl Reacting for ()

A reaction that keeps nothing and answers nothing.

type Kept = ()

async fn hear(&mut self, _said: Message) -> Result<(), Failure>

async fn answer(&mut self, _asked: Message) -> Result<Answer, Failure>

async fn finish(self) -> Result<Self, Failure>

impl Reacting for Vec<Message>

A reaction that keeps every message, and has no answer to any of them.

type Kept = Vec<Message>

async fn hear(&mut self, said: Message) -> Result<(), Failure>

async fn answer(&mut self, asked: Message) -> Result<Answer, Failure>

async fn finish(self) -> Result<Self, Failure>

Implementors