actm 0.1.0

Tiny async actors framework 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

use actm::prelude::*;
use nanorand::Rng;

use crate::{Answers, Test};

// First we define the context type

pub struct StudentContext {
    /// My name
    pub name: String,
}

// Then we define the input event type

#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
pub struct StudentInput {
    /// The test the student is to perform
    pub test: Test,
}

// Then the output event
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
pub struct StudentOutput {
    /// The answers to the test that the student just completed
    pub answers: Answers,
    /// The student's name
    pub name: String,
}

// Generate the impls

wrapped_event!(StudentInputEvent, StudentInput);
wrapped_event!(StudentOutputEvent, StudentOutput);

async fn student_event_handler(
    context: StudentContext,
    event: StudentInputEvent,
) -> (StudentContext, Option<StudentOutputEvent>) {
    let mut rng = nanorand::tls_rng();
    let results = event
        .into_inner()
        .test
        .questions
        .into_iter()
        .map(|x| -> bool { x > rng.generate_range(1_u32..=100) })
        .collect::<Vec<_>>();
    let name = context.name.clone();
    let new_event: StudentOutputEvent = StudentOutput {
        answers: Answers { answers: results },
        name,
    }
    .into();
    (context, Some(new_event))
}

async_actor!(
    Student,
    StudentInputEvent,
    StudentOutputEvent,
    StudentContext,
    student_event_handler
);