3 unstable releases
Uses old Rust 2015
0.5.0 | Sep 9, 2015 |
---|---|
0.4.1 | Sep 9, 2015 |
0.4.0 | Sep 3, 2015 |
#2646 in Rust patterns
6,825 downloads per month
Used in 31 crates
(2 directly)
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 macropipe_res!
works likepipe!
but takes only functions that return aResult
(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 likepipe!
but takes only functions that return anOption
(of the same type). The pipeline will continue to operate on the initial value as long asNone
is returned from all functions. If a function in the pipeline returnsSome
, 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]
);