rusty_chain 0.1.18

This library abstracts over functional processing units called `chain links`. Each link in the chain is meant to be independent, immutable, idempotent, and highly testable.
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


// This example demonstrates a recursive example

use fibonacci::sequence::{FibonacciSequence, FibonacciSequenceInitializer};
use rusty_chain::framework::ChainLink;

mod fibonacci {

    pub mod sequence {
        use rusty_chain::chain_link;

        chain_link!(FibonacciSequence, input: (u32, u32) => (u32, u32), {
            if let Some(fib_tuple) = input.received {
                let (a, b) = &*fib_tuple.read().await;
                Some((*b, *a + *b))
            }
            else {
                None
            }
        });
    }
}

#[tokio::main]
async fn main() {
    
    let fibonacci_sequence = FibonacciSequence::new_raw(
        FibonacciSequenceInitializer { }
    ).await;

    // push on the initial set
    fibonacci_sequence.push_raw((0, 1)).await;

    for i in 0..12 {
        // process the next set of numbers
        fibonacci_sequence.process().await;

        // pull out the next set of numbers
        if let Some(numbers) = fibonacci_sequence.try_pop().await {
            let locked_numbers = numbers.read().await;
            let (a, b) = (locked_numbers.0, locked_numbers.1);
            
            if i == 0 {
                println!("{}", a);
            }
            println!("{}", b);

            // push on the next set
            fibonacci_sequence.push_raw((a, b)).await;
        }
    }
}