Crate hannibal

Expand description

Hannibal is a rust actors framework based on async-std

Documentation

GitHub repository
Cargo package
Minimum supported Rust version: 1.56 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 hannibal::*;

#[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()
    }
}

#[hannibal::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(())
}

References


Actix	the original inspiration
Async-std	a supported runtime
Tokio	a supported runtime
Xactor	original version of this

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

Weak version of Addr<A>.

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

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.