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>.