effect-rs 0.1.0

A high-performance, strictly-typed, functional effect system 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

use effect_rs::{Effect, EffectStream, Exit, Runtime};

#[test]
fn test_stream_iter_collect() {
    let rt = Runtime::new();
    let stream = EffectStream::<(), (), i32>::from_iter(vec![1, 2, 3]);
    let program = stream.map(|i| i * 2).run_collect();

    let res = rt.block_on(program, ());
    match res {
        Exit::Success(vec) => assert_eq!(vec, vec![2, 4, 6]),
        Exit::Failure(_) => panic!("Stream failed"),
    }
}

#[test]
fn test_stream_merge() {
    let rt = Runtime::new();

    let s1 = EffectStream::<(), (), i32>::from_iter(vec![1, 2]);
    let s2 = EffectStream::<(), (), i32>::from_iter(vec![3, 4]);

    let program = s1.merge(s2).run_collect();

    let res = rt.block_on(program, ());
    match res {
        Exit::Success(mut items) => {
            items.sort(); // Merge order is nondeterministic
            assert_eq!(items, vec![1, 2, 3, 4]);
        }
        _ => panic!("Stream failed"),
    }
}

#[test]
fn test_stream_map_par() {
    let rt = Runtime::new();
    let data: Vec<i32> = (0..10).collect();

    let stream = EffectStream::<(), (), i32>::from_iter(data);

    // Map par with concurrency 4
    let program = stream
        .map_par(4, |n| {
            Effect::succeed(n * 2).delay(tokio::time::Duration::from_millis(10)) // Simulate work
        })
        .run_collect();

    let res = rt.block_on(program, ());
    match res {
        Exit::Success(mut items) => {
            items.sort();
            assert_eq!(items, vec![0, 2, 4, 6, 8, 10, 12, 14, 16, 18]);
        }
        _ => panic!("Map par failed"),
    }
}