pipa 0.4.1

Pipe Operator Library 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
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

use std::time::Duration;

use pipa::{pipa, pipa_await_try, pipa_try};

fn f(a: i32) -> u64 {
    (a + 1) as u64
}

fn g(a: u64) -> String {
    (a + 1).to_string()
}

fn h(s: String) -> u64 {
    let ret = s.parse::<u64>();
    ret.unwrap() + 10
}

#[test]
fn pipe() {
    let ret = pipa!(123);
    println!("pipe: {}", ret);
    assert_eq!(123, ret);
    let ret = pipa!(123 => f => g => h);
    println!("pipe: {}", ret);
    assert_eq!(135, ret);
}

// ----

fn add_one(x: i32) -> Option<i32> {
    Some(x + 1)
}

fn double(x: i32) -> Option<i32> {
    Some(x * 2)
}

fn sdf() -> Option<i32> {
    let result = pipa_try!(5 => add_one => double);
    Some(result)
}

#[test]
fn pipe2() {
    let result = sdf().unwrap_or_default();
    println!("pipe2: {}", result);
    assert_eq!(12, result);
}

fn try_add_one(x: i32) -> Result<i32, ()> {
    Ok(x + 1)
}

fn try_double(x: i32) -> Result<i32, ()> {
    Ok(x * 2)
}

fn try_sdf() -> Result<i32, ()> {
    let result = pipa_try!(5 => try_add_one => try_double);
    Ok(result)
}

#[test]
fn pipe3() {
    let result = try_sdf().unwrap_or_default();
    println!("pipe3: {}", result);
    assert_eq!(12, result);
}

async fn await_try_add_one(x: i32) -> Result<i32, ()> {
    dbg!("await_try_add_one awaiting...");
    tokio::time::sleep(Duration::from_millis(100)).await;
    dbg!("await_try_add_one finished awaiting");
    Ok(x + 1)
}

async fn await_try_double(x: i32) -> Result<i32, ()> {
    dbg!("await_try_double awaiting...");
    tokio::time::sleep(Duration::from_millis(10)).await;
    dbg!("await_try_double finished awaiting");
    Ok(x * 2)
}

async fn await_try_sdf() -> Result<i32, ()> {
    dbg!("await_try_sdf awaiting...");
    tokio::time::sleep(Duration::from_millis(400)).await;
    let result = pipa_await_try!(5 => await_try_add_one => await_try_double);
    dbg!("await_try_sdf finished awaiting");
    Ok(result)
}

#[tokio::test]
async fn pipe4() {
    let result = await_try_sdf().await.unwrap();
    println!("pipe3: {}", result);
    assert_eq!(12, result);
}