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 Aliases

ActorError

The type of error returned by an actor method.

ActorResult

Short alias for a Result<Produces<T>, ActorError>.