Actor framework for Rust, modelled after Pony's actors:
Actors cannot deadlock!
Sending a message to an Actor can never fail.
No async in Actors. Behaviors cannot block.
Actors are garbage collected.
The implemention of tractor is rather simple compared against other Actor
implementations in Rust.
It uses tokio but was using async_std in the past.
In Cargo.toml add tractor = "*" and tokio = "1.2.0".
```rust use tractor::*;
pub struct Adder { sum: usize, }
impl Adder { fn inc(&mut self) { self.sum += 1; }
fn add(&mut self, num: usize) { self.sum += num; } }
async fn main() {
let adder: Addr
/// This sends the inc message to the actor.
adder.inc();
/// This sends the add message to the actor.
adder.add(42);
ActorSystem::waitforcompletion().await; } ```
Actors have unbounded mailboxes and send is non-blocking.
Actors cannot be manually stopped. They terminate as soon as no further
reference to them exists and their mailbox is empty. This implies that
sending a message to an Actor can never fail except for running out of
memory. To avoid overloading of an Actor you can check it's current length
of it's mailbox.
The behaviors of an Actor have no return value! As such, Actors do not
support "waiting" for a result. To "simulate" Request/Response, pass the
Actors address in the message and respond to it.
The behaviors of an Actor are NOT async fns! Async would imply that
the execution can "halt". There might be AsyncActor for convenience in the
future.
NOTE: Any Actor cycles will defeat the garbage collection of Actors.