piping

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

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

let piped = pipe! { num |> add(2, ) |> origanddouble(), (_, 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.

How does it work?

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

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

let num = 4;

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

// Expands to... let piped = { let pipelinevalue = num; let pipelinevalue = add(2, pipelinevalue); let (, doubled) = origanddouble(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.

To use _ as it is normally in Rust, use __ instead.

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