#pipe #function #elixir #macro #composition

pipeline

A macro collection to pipe |> your functions calls, like in F# or Elixir

3 unstable releases

0.5.0 Sep 9, 2015
0.4.1 Sep 9, 2015
0.4.0 Sep 3, 2015

#99 in Rust patterns

Download history 61/week @ 2018-08-21 47/week @ 2018-08-28 56/week @ 2018-09-04 29/week @ 2018-09-11 36/week @ 2018-09-18 157/week @ 2018-09-25 77/week @ 2018-10-02 135/week @ 2018-10-09 187/week @ 2018-10-16 127/week @ 2018-10-23 53/week @ 2018-10-30 247/week @ 2018-11-06 59/week @ 2018-11-13

273 downloads per month
Used in 3 crates (1 directly)

MIT license

8KB
206 lines

pipeline.rs

Pipeline is a macro collection to pipe your functions calls, like in F# or Elixir. Instead of the nice |> operator it uses => as a pipe character, due to limitations in the Rust macro system.

Usage

Put this in your Cargo.toml

[dependencies]

pipeline = "0.4.1"

Then you can import the macros with extern crate and macro_use

#[macro_use]
extern crate pipeline;

Examples

// pipe_res exits the pipeline early if a function returns an Err()
let result = pipe_res!("http://rust-lang.org" => download => parse => get_links)
fn times(a: u32, b: u32) -> u32{
    return a * b;
}

let num = pipe!(
  4
  => (times(10))
  => {|i: u32| i * 2}
  => (times(4))
);

// takes a string length, doubles it and converts it back into a string
let length = pipe!(
    "abcd"
    => [len]
    => (as u32)
    => times(2)
    => [to_string]
);

Macros

  • pipe! is the "standard" pipe macro
  • pipe_res! works like pipe! but takes only functions that return a Result (of the same type) and returns early if that result is an Err. Useful for combining multiple IO transformations like opening a file, reading the contents and making an HTTP request.
  • pipe_opt! works like pipe! but takes only functions that return an Option (of the same type). The pipeline will continue to operate on the initial value as long as None is returned from all functions. If a function in the pipeline returns Some, the macro will exit early and return that value. This can be useful if you want to try out several functions to see which can make use of that value in a specified order.

Syntax Features

Any pipe starts with an expression as initial value and requires you to specify a function to transform that initial value.

let result = pipe!(2 => times2);

You can get more fancy with functions, too, if you add parentheses like in a normal function call, the passed parameters will be applied to that function after the transformed value.

You have to put it in parentheses because the Rust macro system can be very restrictive. If you figure out a way to do it without please make a PR.

let result = pipe!(2 => (times(2)));

You can pass closures \o/! A closure must be wrapped in curly brackets ({})

let result = pipe!(
  2
  => (times(2))
  => {|i: u32| i * 2}
);

If you want a function to be called as a method on the transform value, put it in square brackets ([]).

let result = pipe!(
    "abcd"
    => [len]
);

No runtime deps