Crate act_zero

act-zero

An actor system for Rust, designed with several goals in mind:

• No boilerplate.
• Ergonomic.
• Supports standard trait-based static and dynamic polymorphism.
• Embraces async/await.
• Executor agnostic.

Very little code is required to get started:

use std::error::Error;

use futures::executor::LocalPool;
use act_zero::*;

struct SimpleGreeter {
    number_of_greets: i32,
}

impl Actor for SimpleGreeter {}

impl SimpleGreeter {
    async fn greet(&mut self, name: String) -> ActorResult<String> {
        self.number_of_greets += 1;
        Produces::ok(format!(
            "Hello, {}. You are number {}!",
            name, self.number_of_greets
        ))
    }
}

fn main() -> Result<(), Box<dyn Error>> {
    let mut pool = LocalPool::new();
    let spawner = pool.spawner();
    pool.run_until(async move {
        let actor_ref = Addr::new(
            &spawner,
            SimpleGreeter {
                number_of_greets: 0,
            },
        )?;

        let greeting = call!(actor_ref.greet("John".into())).await?;
        println!("{}", greeting);

        let greeting = call!(actor_ref.greet("Emma".into())).await?;
        println!("{}", greeting);
        Ok(())
    })
}

For mixing traits and actors, it's recommended to use the async_trait crate to allow using async methods in traits.

Modules

runtimes	Contains integrations with specific runtimes
timer	Functionality related to timers.

Macros

call	Sends a method call to be executed by the actor, and returns a future that can be awaited to get back the result.
send	Sends a method call to be executed by the actor.
upcast	Converts an Addr<T> or WeakAddr<T> to an Addr<dyn Trait> or WeakAddr<dyn Trait>.

Structs

Addr	A strong reference to a spawned actor. Actors can be spawned using Addr::new.
Termination	A future which completes upon termination of an actor.
WeakAddr	A weak reference to a spawned actor.

Enums

Produces

A concrete type similar to a BoxFuture<'static, Result<T, oneshot::Canceled>>, but without requiring an allocation if the value is immediately ready. This type implements the Future trait and can be directly awaited.

Traits

Actor	Trait implemented by all actors. This trait is defined using the #[async_trait] attribute:
AddrLike	Trait provides methods for spawning futures onto an actor. Implemented by Addr and WeakAddr alike.
AsAddr	Implemented by addresses and references to addresses
IntoActorResult	Actor methods may return any type implementing this trait.

Type Definitions

ActorError	The type of error returned by an actor method.
ActorResult	Short alias for a Result<Produces<T>, ActorError>.