Murray

The murray crate provides a actor macro that helps defining erlang inspired actors. The actor is targeted at async and tokio but can be adapted by useing other mpsc channels.

Use

``` actor! { Foo, Messages: { Msg1, Msg2, Msg3 { ch: mpsc::Receiver } } }

impl FooActor { fn handle(&self, state: &mut FooActorState, msg: FooActorMessages) -> () { () }

}

actor! { Bar, Options: { sup: Foo, id: String, }, Messages: { A, B { x: bool, }, }, State: { foo: TypeC, } }

impl BarActor { fn handle(&self, state: &mut BarActorState, msg: BarActorMessages) -> () { () } }

let sup = FooActor{}.start(); let id = String::from("abar"); let abar = BarActor{}.start(sup, &id);

abar.send(BarActorMessages::B(true));

```

This will produce struct FooActor, enum FooActorMessages and a struct FooActorState (and similar for Bar). If you include Options they may include a sup naming the agent's supervisor and a id naming the type of actors id. The type must be Clone.

The State struct includes a tx Sender channel so that your handlers can send messages back to the actor. If the actor has a supervisor it will also include a sup_ch and an id field if it's included in options. The actor definition includes a State with extra properties they will be included in the state struct as Option initialized to None.