pipe-trait 0.4.0

Make it possible to chain regular functions
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

Make it possible to chain regular functions.

**API Overview:**

By adding `use pipe_trait::*`, 9 methods are added to all types:

|        identifier       |       pipe syntax      |  traditional syntax |
|:-----------------------:|:----------------------:|:-------------------:|
| `Pipe::pipe`            | `x.pipe(f)`            | `f(x)`              |
| `Pipe::pipe_ref`        | `x.pipe_ref(f)`        | `f(&x)`             |
| `Pipe::pipe_mut`        | `x.pipe_mut(f)`        | `f(&mut x)`         |
| `Pipe::pipe_as_ref`     | `x.pipe_as_ref(f)`     | `f(x.as_ref())`     |
| `Pipe::pipe_as_mut`     | `x.pipe_as_mut(f)`     | `f(x.as_mut())`     |
| `Pipe::pipe_deref`      | `x.pipe_deref(f)`      | `f(&x)`             |
| `Pipe::pipe_deref_mut`  | `x.pipe_deref_mut(f)`  | `f(&mut x)`         |
| `Pipe::pipe_borrow`     | `x.pipe_borrow(f)`     | `f(x.borrow())`     |
| `Pipe::pipe_borrow_mut` | `x.pipe_borrow_mut(f)` | `f(x.borrow_mut())` |

**Example:** Same type

```rust
use pipe_trait::*;
let inc = |x| x + 1;
let double = |x| x + x;
let square = |x| x * x;
let a = (123i32).pipe(inc).pipe(double).pipe(square);
let b = square(double(inc(123i32)));
assert_eq!(a, b);
```

**Example:** Type transformation

```rust
use pipe_trait::*;
let x = 'x';
let a = x
    .pipe(|x| (x, x, x)) // (char, char, char)
    .pipe(|x| [x, x]) // [(char, char, char); 2]
    .pipe(|x| format!("{:?}", x)); // String
let b = "[('x', 'x', 'x'), ('x', 'x', 'x')]";
assert_eq!(a, b);
```

**Example:** Pipe amongst method chain

```rust
# async {
# use std::fmt::*;
# use futures::future::*;
# #[derive(Debug, Copy, Clone)]
# struct Num(pub i32);
# impl Num {
#     pub fn inc(&self) -> Self { Self(self.0 + 1) }
#     pub fn double(&self) -> Self { Self(self.0 * 2) }
#     pub fn square(&self) -> Self { Self(self.0 * self.0) }
#     pub fn get(&self) -> i32 { self.0 }
#     pub fn future(self) -> Ready<Self> { ready(self) }
# }
# let my_future = Num(12).future();
use pipe_trait::*;
fn log<X: Debug>(x: X) -> X {
    println!("value: {:?}", x);
    x
}
my_future
    .pipe(log)
    .await
    .pipe(log)
    .inc()
    .pipe(log)
    .double()
    .pipe(log)
    .square()
    .pipe(log)
    .get()
    .pipe(log);
# };
```

**Example:** Explicit type annotation

```rust
use pipe_trait::*;
let x = "abc".to_string();
let a = x
    .pipe_ref::<&str, _>(AsRef::as_ref)
    .chars()
    .pipe::<Box<_>, _>(Box::new)
    .collect::<Vec<_>>();
let b = vec!['a', 'b', 'c'];
assert_eq!(a, b);
```