CacheAdvance - Never miss the cache again.

All the key types, traits, and macros in one place. For complete API documentation, see docs.rs/acton-reactive.

Core Types

The actor system runtime.

let runtime = ActonApp::launch_async().await;

Configures actors before spawning.

let handle = runtime
    .new_actor::<Counter>()
    .mutate_on::<Increment>(handler)
    .act_on::<GetCount>(handler)
    .start()
    .await;

Method	Description
`mutate_on::<M>(handler)`	Register state-changing handler
`act_on::<M>(handler)`	Register read-only handler
`before_start(hook)`	Lifecycle hook before start
`after_stop(hook)`	Lifecycle hook after stop
`expose_for_ipc()`	Expose actor for IPC using its name
`start().await`	Spawn the actor
`handle()`	Get handle before starting

Reference to a running actor.

handle.send(Message).await;
handle.stop().await.ok();

Method	Description
`send(msg).await`	Fire-and-forget message
`stop().await`	Stop the actor
`subscribe::<M>().await`	Subscribe to broadcast messages
`reply_address()`	Get address for replies
`create_envelope(target)`	Create envelope for sending
`supervise(child).await`	Start and supervise a child
`id()`	Get actor's identifier

Handler return type.

Message wrapper with routing information.

Method	Description
`message()`	Access the message data
`reply_envelope()`	Create envelope back to sender
`new_envelope(&address)`	Create envelope to different recipient
`send(msg).await`	Send via this envelope

Marks a struct as actor state.

#[acton_actor]
struct Counter {
    count: i32,
}

Marks a struct as a message.

#[acton_message]
struct Increment;

#[acton_message(ipc)]  // Enable IPC serialization
struct GetValue;

Sets up the async runtime.

#[acton_main]
async fn main() {
    let runtime = ActonApp::launch_async().await;
    // ...
}

Import everything:

use acton_reactive::prelude::*;

Includes: ActonApp, ActorHandle, Reply, all macros.