piping 0.1.2

Pipeline syntax in Rust. `4isize |> double(_) |> _ as usize`.
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

# piping


`piping` provides a `pipe!` macro that allows you to use the pipeline operator in Rust.

```rs
let wrapped = orig_and_double(add(2, num)).1 as isize;

let piped = pipe! {
	num |> add(2, _) |> orig_and_double(_),
	(_, doubled) |> doubled as isize,
};
```

## Features


- [x] [Hack-like syntax.](https://docs.hhvm.com/hack/expressions-and-operators/pipe)
- [x] Multiple pipelines in one statement.
- [x] Destructuring of previous pipeline results.

## Docs


Documentation is provided on [docs.rs](https://docs.rs/piping).

## How does it work?


```rs
fn add(a: usize, b: usize) -> usize {
	a + b
}

fn orig_and_double(num: usize) -> (usize, usize) {
	(num, num * 2)
}

let num = 4;

let piped = pipe! {
	num |> add(2, _) |> orig_and_double(_),
	(_, doubled) |> doubled as isize,
};

// Expands to...
let piped = {
	let __pipeline_value__ = num;
	let __pipeline_value__ = add(2, __pipeline_value__);
	let (_, doubled) = orig_and_double(__pipeline_value__);
	doubled as isize
};
```

You can pass any expression in as the input.

Notice that you can chain pipelines with `,`s to destructure the result of the previous pipeline.

The macro also tries to optimize the generated code to minimize the amount of reassigning done.