atticus 0.3.0

A mimimal API to create asynchronous actors
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
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

use async_trait::async_trait;
use atticus::{actor, Actor};

pub enum CarRequest {
    Park,
    Drive,
    Brake,
    Reverse,
}

pub type CarResponse = String;

#[async_trait]
pub trait Car {
    async fn park(&self) -> CarResponse;
    async fn drive(&self) -> CarResponse;
    async fn brake(&self) -> CarResponse;
    async fn reverse(&self) -> CarResponse;
}

pub struct Sedan;

#[async_trait]
impl Car for Sedan {
    async fn park(&self) -> CarResponse {
        String::from("Sedan: park")
    }
    async fn drive(&self) -> CarResponse {
        String::from("Sedan: drive")
    }
    async fn brake(&self) -> CarResponse {
        String::from("Sedan: brake")
    }
    async fn reverse(&self) -> CarResponse {
        String::from("Sedan: reverse")
    }
}

#[async_trait]
impl Actor for Sedan {
    type Request = CarRequest;
    type Response = String;

    async fn handle(&mut self, message: Self::Request) -> Option<Self::Response> {
        match message {
            CarRequest::Park => Some(self.park().await),
            CarRequest::Drive => Some(self.drive().await),
            CarRequest::Brake => Some(self.brake().await),
            CarRequest::Reverse => Some(self.reverse().await),
        }
    }
}

impl Sedan {
    pub fn new() -> Self {
        Self
    }
}

pub struct Suv;

#[async_trait]
impl Car for Suv {
    async fn park(&self) -> CarResponse {
        String::from("SUV: park")
    }
    async fn drive(&self) -> CarResponse {
        String::from("SUV: drive")
    }
    async fn brake(&self) -> CarResponse {
        String::from("SUV: brake")
    }
    async fn reverse(&self) -> CarResponse {
        String::from("SUV: reverse")
    }
}

#[async_trait]
impl Actor for Suv {
    type Request = CarRequest;
    type Response = String;

    async fn handle(&mut self, message: Self::Request) -> Option<Self::Response> {
        match message {
            CarRequest::Park => Some(self.park().await),
            CarRequest::Drive => Some(self.drive().await),
            CarRequest::Brake => Some(self.brake().await),
            CarRequest::Reverse => Some(self.reverse().await),
        }
    }
}

impl Suv {
    pub fn new() -> Self {
        Self
    }
}

async fn run_car<T>(car: T)
where
    T: Car + Actor,
    T: Actor<Request = CarRequest>,
    T: Actor<Response = String>,
    <T as Actor>::Request: Send + Sync,
    <T as Actor>::Response: Send + Sync,
{
    let actor_handle = actor::run(car, 1);
    let requestor = actor_handle.requestor;

    let response = requestor.request(CarRequest::Park).await.unwrap();
    println!("{}", response.unwrap());

    let response = requestor.request(CarRequest::Drive).await.unwrap();
    println!("{}", response.unwrap());

    let response = requestor.request(CarRequest::Brake).await.unwrap();
    println!("{}", response.unwrap());

    let response = requestor.request(CarRequest::Reverse).await.unwrap();
    println!("{}", response.unwrap());
}

#[tokio::main(flavor = "current_thread")]
async fn main() {
    run_car(Sedan::new()).await;
    run_car(Suv::new()).await;
}