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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
/*!
A fast and flexible actor-framework for building fault-tolerant Rust applications.
# Documentation
All items are self-documented, but for a new user it is recommended to go skim through the docs in
the following order. Every module gives an overview of what is contained inside, introduces some
new concepts and then gives an example on how to use it.
- [`messaging`] - Defining a protocol in order to send messages.
- [`actor_reference`] - Interacting with an actor through it's child or address.
- [`actor_type`] - Specifying the type of an actor statically and dynamically.
- [`spawning`] - Spawning of actors.
- [`handler`] - A simpler way to write your actors.
- [`runtime`] - Runtime configuration.
- [`supervision`] - (Not yet implemented)
- [`distribution`] - (Not yet implemented)
# Minimal example
```
#[macro_use]
extern crate zestors;
use zestors::{messaging::RecvError, prelude::*};
// Let's define a single request ..
#[derive(Message, Envelope, Debug)]
#[request(u32)]
struct MyRequest {
param: String,
}
// .. and create a protocol that accepts this request.
#[protocol]
enum MyProtocol {
MyRequest(MyRequest),
String(String),
}
#[tokio::main]
async fn main() {
// Now we can spawn a simple actor ..
let (child, address) = spawn(|mut inbox: Inbox<MyProtocol>| async move {
loop {
match inbox.recv().await {
Ok(msg) => match msg {
MyProtocol::MyRequest((request, tx)) => {
println!("Received request: {:?}", request.param);
tx.send(100).unwrap();
}
MyProtocol::String(string) => {
println!("Received message: {:?}", string);
}
},
Err(e) => match e {
RecvError::Halted => break "Halted",
RecvError::ClosedAndEmpty => break "Closed",
},
}
}
});
// .. and send it some messages!
address.send("Hi".to_string()).await.unwrap();
let response = address
.request(MyRequest {
param: "Hi".to_string(),
})
.await
.unwrap();
assert_eq!(response, 100);
let response = address
.my_request("Hi".to_string())
.request()
.await
.unwrap();
assert_eq!(response, 100);
child.halt();
assert_eq!(child.await.unwrap(), "Halted");
}
```
*/
extern crate self as zestors;
pub
pub use ;