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 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
//! Make it possible to chain regular functions. //! //! **Example:** Pipe amongst method chain //! //! ``` //! # async { //! # use std::fmt::*; //! # use futures::future::*; //! # #[derive(Debug, Copy, Clone)] //! # struct Num(pub i32); //! # impl Num { //! # pub fn inc(&self) -> Self { Self(self.0 + 1) } //! # pub fn double(&self) -> Self { Self(self.0 * 2) } //! # pub fn square(&self) -> Self { Self(self.0 * self.0) } //! # pub fn get(&self) -> i32 { self.0 } //! # pub fn future(self) -> Ready<Self> { ready(self) } //! # } //! # let my_future = Num(12).future(); //! 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); //! # }; //! ``` //! //! **Example:** 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); //! ``` //! //! **Example:** 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); //! ``` #![no_std] pub use core::marker::Sized; /// All sized types implement this trait. pub trait Pipe: Sized { /// Apply `f` to `self`. #[inline] fn pipe<Return>(self, f: impl FnOnce(Self) -> Return) -> Return { f(self) } } impl<X: Sized> Pipe for X {} #[cfg(test)] mod tests;