Crate theatre 

Theatre: A concise async actor model implementation

Example:

use theatre::prelude::*;

#[derive(Default)]
struct Accumulator {
    count: i32,
}

impl Actor for Accumulator {}

// A message to increase the count of the accumulator by one
struct Increment;
impl Message for Increment {
    type Return = ();
}

// A message to get the current count of the accumulator
struct GetCount;
impl Message for GetCount {
    type Return = i32;
}

// Handle `Increment` messages for the accumulator
#[async_trait]
impl Handler<Increment> for Accumulator {
    async fn handle(
        &mut self,
        _msg: Increment,
        _context: &mut Context<Self>,
    ) -> <Increment as Message>::Return {
        println!("Adding 1");
        self.count += 1
    }
}

// Handle `GetCount`
#[async_trait]
impl Handler<GetCount> for Accumulator {
    async fn handle(
        &mut self,
        _msg: GetCount,
        _context: &mut Context<Self>,
    ) -> <GetCount as Message>::Return {
        self.count
    }
}

#[tokio::main]
async fn main() {
    let mut acc = Accumulator::default().spawn().await;

    assert_eq!(0, acc.send(GetCount).await.unwrap());

    acc.send(Increment).await.unwrap(); // Output: `Adding 1`
    acc.send(Increment).await.unwrap(); // Output: `Adding 1`
    acc.send(Increment).await.unwrap(); // Output: `Adding 1`
    acc.send(Increment).await.unwrap(); // Output: `Adding 1`

    println!("Value: {}", acc.send(GetCount).await.unwrap()); // Output: Value: 4
    assert_eq!(4, acc.send(GetCount).await.unwrap());
}

Modules

actors

Provided utility actors

mailbox

Structures related to the actor mailbox

prelude

Convenience module for common actor types

Structs

ActorHandle

ActorHandle is a method of awaiting the actor’s task. Dropping the ActorHandle will not shutdown the actor.

Config

Context

Context is the execution context of the actor. It allows for the actor to dynamically retrieve the address of the actor’s Mailbox.

Enums

TheatreError

Possible error variants.

Traits

Actor

Actor is one of the core traits of theatre.

ActorExt

Extensions for Actors. This is blanket impl’d on any type that implements Actor.

Handler

The Handler trait allows for an actor to have a per-message type handle implementation.

Functions

start

Start an actor in a dedicated task and return its address and handle.