absinthe 0.3.0

Are you an Actor & Async junkie? Then your app needs some Absinthe!
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

use absinthe::prelude::*;

#[tokio::test]
async fn basic_function_fn_add() {
    actor! {
        async fn add(a: u32, b: u32) -> u32 {
            a + b
        }
    }
    
    let actor = add();

    assert_eq!(absinthe::send!(actor, 3, 2).await, 5);
}

#[tokio::test]
async fn basic_function_fn_concat() {
    actor! {
        async fn concat(mut a: String, b: String) -> String {
            a += &b;
            a
        }
    }
    

    let actor = concat();

    assert_eq!(absinthe::send!(actor, "Hello, ".to_string(), "world!".to_string()).await, "Hello, world!");
}

#[tokio::test]
async fn return_tuple() {
    actor! {
        async fn swap(a: u32, b: u32) -> (u32, u32) {
            (b, a)
        }
    }
    
    let actor = swap();

    assert_eq!(absinthe::send!(actor, 3, 2).await, (2, 3));
}

#[tokio::test]
async fn return_unit() {
    actor! {
        async fn print(a: u32) {
            format!("{}", a);
        }
    }
    
    let actor = print();

    assert_eq!(absinthe::send!(actor, 3).await, ());
}

#[tokio::test]
async fn no_arg() {
    actor! {
        async fn print() {
            format!("Hello, world!");
        }
    }

    let actor = print();

    assert_eq!(absinthe::send!(actor).await, ());
}

#[tokio::test]
async fn ping_pong() {
    actor! {
        async fn ping(count: u8, pong: ActorHandle<PongActorFn>) -> String {
            for _ in 0..(count - 1) {
                absinthe::notify!(pong).await;
            }
    
            absinthe::send!(pong).await
        }
    }
    
    actor! {
        async fn pong() -> String {
            "pong".to_string()
        }
    }
    

    let ping = ping();
    let pong = pong();

    assert_eq!(absinthe::send!(ping, 8, pong).await, "pong");
}

#[tokio::test]
async fn generic() {
    actor! {
        async fn add<T: std::ops::Add<Output = T>>(a: T, b: T) -> T {
            a + b
        }
    }
    
    actor! {
        async fn sub<T> (a: T, b: T) -> T
        where
            T: std::ops::Sub<Output = T>,
        {
            a - b
        }
    }    

    let add_u8 = add::<u8>();
    let sub_u32 = sub::<u32>();
    let add_f64 = add::<f64>();


    assert_eq!(absinthe::send!(add_u8, 3, 2).await, 5u8);
    assert_eq!(absinthe::send!(sub_u32, 3, 2).await, 1u32);
    assert_eq!(absinthe::send!(add_f64, 3.0, 2.0).await, 5.0f64);
}