#pipe #trait #fp #pipeline

no-std pipe-trait

Make it possible to chain regular functions

16 releases

0.3.2 Apr 8, 2021
0.3.1 Mar 25, 2021
0.2.1 Nov 7, 2020
0.2.0 May 26, 2020
0.1.11 May 23, 2020

#123 in Rust patterns

Download history 114/week @ 2021-08-10 326/week @ 2021-08-17 855/week @ 2021-08-24 326/week @ 2021-08-31 327/week @ 2021-09-07 660/week @ 2021-09-14 324/week @ 2021-09-21 734/week @ 2021-09-28 392/week @ 2021-10-05 262/week @ 2021-10-12 306/week @ 2021-10-19 157/week @ 2021-10-26 96/week @ 2021-11-02 134/week @ 2021-11-09 294/week @ 2021-11-16 409/week @ 2021-11-23

966 downloads per month
Used in 12 crates (11 directly)

MIT license

15KB
180 lines

Pipe Trait

Test Crates.io Version

Make it possible to chain regular functions.

APIs

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())

Read the docs for more information.

Usage Examples

Same type

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);

Type transformation

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);

Pipe amongst method chain

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);

Explicit type annotation

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);

License

MIT © Hoàng Văn Khải

No runtime deps