rsactor 0.14.1

A Simple and Efficient In-Process Actor Model Implementation for Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

@startuml Message Passing
title Message Passing (tell and ask)

actor Client
participant "ActorRef<T>" as ActorRef_obj
participant "MailboxChannel (mpsc)" as MailboxChannel
participant "run_actor_lifecycle()" as Runtime_obj
participant "MessageHandler::handle()" as DynMsgHandler
participant "UserActor::handle(msg)" as UserHandler
participant "oneshot::channel" as OneshotChannel

box "Actor Task" #LightBlue
    participant Runtime_obj
    participant DynMsgHandler
    participant UserHandler
end box

== Tell Operation (Fire-and-Forget) ==
Client -> ActorRef_obj: actor_ref.tell(MyMessage).await
activate ActorRef_obj
ActorRef_obj -> ActorRef_obj: Wraps MyMessage in MailboxMessage::Envelope (reply_channel = None)
ActorRef_obj -> MailboxChannel: sender.send(envelope).await
deactivate ActorRef_obj
Client <-- ActorRef_obj: Returns Result<()>

MailboxChannel -> Runtime_obj: tokio::select! receives Envelope from mailbox
activate Runtime_obj
Runtime_obj -> DynMsgHandler: payload.handle_message(&mut actor, actor_ref, reply_channel).await
activate DynMsgHandler
DynMsgHandler -> UserHandler: Calls specific Message<MyMessage>::handle method
activate UserHandler
UserHandler --> DynMsgHandler: Returns Reply (e.g., ())
deactivate UserHandler
DynMsgHandler --> Runtime_obj: Message processing complete
deactivate DynMsgHandler
note right of Runtime_obj: For tell, reply is discarded (no reply_channel)
Runtime_obj -> Runtime_obj: Continue select! loop
deactivate Runtime_obj

== Ask Operation (Request-Reply) ==
Client -> ActorRef_obj: actor_ref.ask(MyQuery).await
activate ActorRef_obj
ActorRef_obj -> OneshotChannel: Creates (reply_tx, reply_rx)
ActorRef_obj -> ActorRef_obj: Wraps MyQuery in MailboxMessage::Envelope (with reply_tx)
ActorRef_obj -> MailboxChannel: sender.send(envelope).await
ActorRef_obj -> OneshotChannel: reply_rx.await (waits for reply)
activate OneshotChannel

MailboxChannel -> Runtime_obj: tokio::select! receives Envelope from mailbox
activate Runtime_obj
Runtime_obj -> DynMsgHandler: payload.handle_message(&mut actor, actor_ref, Some(reply_channel)).await
activate DynMsgHandler
DynMsgHandler -> UserHandler: Calls specific Message<MyQuery>::handle method
activate UserHandler
UserHandler --> DynMsgHandler: Returns QueryReply
deactivate UserHandler
DynMsgHandler -> OneshotChannel: reply_tx.send(QueryReply) (via reply_channel)
DynMsgHandler --> Runtime_obj: Message processing complete
deactivate DynMsgHandler

OneshotChannel --> ActorRef_obj: Receives reply
deactivate OneshotChannel
ActorRef_obj -> ActorRef_obj: Type-safe reply (no downcasting needed with ActorRef<T>)
ActorRef_obj --> Client: Returns QueryReply
deactivate ActorRef_obj
Runtime_obj -> Runtime_obj: Continue select! loop
deactivate Runtime_obj

note over Client, UserHandler
  Type Safety: ActorRef<T> ensures compile-time type checking.
  Only messages that actor T implements handlers for can be sent.
  Reply types are also statically verified.
end note

@enduml