Crate xactor

Xactor is a rust actors framework based on async-std

Documentation

• GitHub repository
• Cargo package
• Minimum supported Rust version: 1.39 or later

Features

• Async actors.
• Actor communication in a local context.
• Using Futures for asynchronous message handling.
• Typed messages (No Any type). Generic messages are allowed.

Examples

use xactor::*;

#[message(result = "String")]
struct ToUppercase(String);

struct MyActor;

impl Actor for MyActor {}

#[async_trait::async_trait]
impl Handler<ToUppercase> for MyActor {
    async fn handle(&mut self, _ctx: &mut Context<Self>, msg: ToUppercase) -> String {
        msg.0.to_uppercase()
    }
}

#[xactor::main]
async fn main() -> Result<()> {
    // Start actor and get its address
    let mut addr = MyActor.start().await?;

    // Send message `ToUppercase` to actor via addr
    let res = addr.call(ToUppercase("lowercase".to_string())).await?;
    assert_eq!(res, "LOWERCASE");
    Ok(())
}

Performance

Actix vs. Xactor

	Wait for response	Send only
Actix	1548 ms	14 ms
Xactor	930 ms	18 ms

GitHub repository

References

• Actix
• Async-std

Structs

• Addr
  The address of an actor.
• Broker
  Message broker is used to support publishing and subscribing to messages.
• Caller
  Caller of a specific message type
• Context
  An actor execution context.
• Sender
  Sender of a specific message type
• Supervisor
  Actor supervisor
• WeakAddr

Traits

• Actor
  Actors are objects which encapsulate state and behavior. Actors run within a specific execution context Context<A>. The context object is available only during execution. Each actor has a separate execution context.
• Handler
  Describes how to handle messages of a specific type. Implementing Handler is a general way to handle incoming messages. The type T is a message which can be handled by the actor.
• LocalService
  Trait define a local service.
• Message
  Represents a message that can be handled by the actor.
• Service
  Trait define a global service.
• StreamHandler
  Describes how to handle messages of a specific type. Implementing Handler is a general way to handle incoming streams. The type T is a stream message which can be handled by the actor. Stream messages do not need to implement the Message trait.

Functions

• block_on
  Spawns a task and blocks the current thread on its result.
• sleep
  Sleeps for the specified amount of time.
• spawn
  Spawns a task.
• timeout
  Awaits a future or times out after a duration of time.

Type Aliases

• ActorId
• Error
  Alias of anyhow::Error
• Result
  Alias of anyhow::Result

Attribute Macros

• main
  Implement an xactor main function.
• message
  Implement an xactor message type.