21 unstable releases (4 breaking)

0.5.0-rc.1 Jan 5, 2021
0.5.0-beta.5 Sep 13, 2020
0.5.0-beta.4 Jul 30, 2020
0.2.6 Mar 18, 2020

#41 in Asynchronous

Download history 50/week @ 2020-11-14 62/week @ 2020-11-21 26/week @ 2020-11-28 68/week @ 2020-12-05 61/week @ 2020-12-12 10/week @ 2020-12-19 7/week @ 2020-12-26 187/week @ 2021-01-02 365/week @ 2021-01-09 191/week @ 2021-01-16 221/week @ 2021-01-23 103/week @ 2021-01-30 126/week @ 2021-02-06 155/week @ 2021-02-13 308/week @ 2021-02-20 124/week @ 2021-02-27

241 downloads per month
Used in 2 crates

MPL-2.0 license

77KB
1K SLoC

xtra

A tiny, fast, and safe actor framework. It is modelled around Actix (copyright and license here).

For better ergonomics with xtra, try the spaad crate.

Features

  • Safe: there is no unsafe code in xtra.
  • Tiny: xtra is less than 1k loc.
  • Lightweight: xtra has few dependencies, most of which are lightweight (except futures).
  • Asynchronous and synchronous message handlers.
  • Simple asynchronous message handling interface which allows async/await syntax even when borrowing self.
  • Does not depend on its own runtime and can be run with any futures executor (Tokio, async-std, smol, and wasm-bindgen-futures have the Actor::spawn convenience method implemented out of the box).
  • Quite fast. Running on Tokio, <170ns time from sending a message to it being processed for sending without waiting for a result on my development machine with an AMD Ryzen 3 3200G.
  • However, it is also relatively new and less mature than other options.

Example

use xtra::prelude::*;
use xtra::spawn::Tokio;
use async_trait::async_trait;

struct Printer {
    times: usize,
}

impl Printer {
    fn new() -> Self {
        Printer { times: 0 }
    }
}

impl Actor for Printer {}

struct Print(String);
impl Message for Print {
    type Result = ();
}

#[async_trait]
impl Handler<Print> for Printer {
    async fn handle(&mut self, print: Print, _ctx: &mut Context<Self>) {
        self.times += 1; // no ActorFuture or anything just to access `self`
        println!("Printing {}. Printed {} times so far.", print.0, self.times);
    }
}

#[tokio::main]
async fn main() {
    let addr = Printer::new().create(None).spawn(&mut Tokio::Global);
    loop {
        addr.send(Print("hello".to_string()))
            .await
            .expect("Printer should not be dropped");
    }
}

For a longer example, check out Vertex, a chat application written with xtra and spaad on the server.

Too verbose? Check out the spaad sister-crate!

Okay, sounds great! How do I use it?

Check out the docs and the examples to get started! Enabling the with-tokio-1, with-async_std-1, with-smol-1, or with-wasm_bindgen-0_2 features is recommended in order to enable some convenience methods (such as Actor::spawn). Which you enable will depend on which executor you want to use (check out their docs to learn more about each). If you have any questions, feel free to open an issue or message me on the Rust discord.

Latest Breaking Changes

To see the breaking changes for each version, see here. The latest version is 0.5.

Dependencies

~0.8–3MB
~57K SLoC