Trait pipe_trait::Pipe

pub trait Pipe {
    fn pipe<Return, Function>(self, f: Function) -> Return
    where
        Self: Sized,
        Function: FnOnce(Self) -> Return,
    { ... }
    fn pipe_ref<'a, Return, Function>(&'a self, f: Function) -> Return
    where
        Function: FnOnce(&'a Self) -> Return,
    { ... }
    fn pipe_mut<'a, Return, Function>(&'a mut self, f: Function) -> Return
    where
        Function: FnOnce(&'a mut Self) -> Return,
    { ... }
    fn pipe_as_ref<'a, Param: ?Sized, Return, Function>(
        &'a self, 
        f: Function
    ) -> Return
    where
        Self: AsRef<Param>,
        Param: 'a,
        Function: FnOnce(&'a Param) -> Return,
    { ... }
    fn pipe_as_mut<'a, Param: ?Sized, Return, Function>(
        &'a mut self, 
        f: Function
    ) -> Return
    where
        Self: AsMut<Param>,
        Param: 'a,
        Function: FnOnce(&'a mut Param) -> Return,
    { ... }
    fn pipe_deref<'a, Param: ?Sized, Return, Function>(
        &'a self, 
        f: Function
    ) -> Return
    where
        Self: Deref<Target = Param>,
        Param: 'a,
        Function: FnOnce(&'a Param) -> Return,
    { ... }
    fn pipe_deref_mut<'a, Param: ?Sized, Return, Function>(
        &'a mut self, 
        f: Function
    ) -> Return
    where
        Self: DerefMut<Target = Param>,
        Param: 'a,
        Function: FnOnce(&'a mut Param) -> Return,
    { ... }
    fn pipe_borrow<'a, Param: ?Sized, Return, Function>(
        &'a self, 
        f: Function
    ) -> Return
    where
        Self: Borrow<Param>,
        Param: 'a,
        Function: FnOnce(&'a Param) -> Return,
    { ... }
    fn pipe_borrow_mut<'a, Param: ?Sized, Return, Function>(
        &'a mut self, 
        f: Function
    ) -> Return
    where
        Self: BorrowMut<Param>,
        Param: 'a,
        Function: FnOnce(&'a mut Param) -> Return,
    { ... }
}

All sized types implement this trait.

Provided methods

fn pipe<Return, Function>(self, f: Function) -> Return where
    Self: Sized,
    Function: FnOnce(Self) -> Return, 

Apply f to self.

assert_eq!(
    12.pipe(double).pipe(Foo),
    Foo(double(12)),
)

fn pipe_ref<'a, Return, Function>(&'a self, f: Function) -> Return where
    Function: FnOnce(&'a Self) -> Return, 

Apply f to &self.

#[derive(Debug, PartialEq, Eq)]
struct Foo(i32);
let a = Foo(12);
let b = a
    .pipe_ref(|a| a.0) // a is not moved
    .pipe(Foo);
assert_eq!(a, b); // a is used again

fn pipe_mut<'a, Return, Function>(&'a mut self, f: Function) -> Return where
    Function: FnOnce(&'a mut Self) -> Return, 

Apply f to &mut self.

#[derive(Debug, PartialEq, Eq)]
struct Foo(i32, i32);
let mut a = Foo(0, 0);
a.pipe_mut(|a| a.0 = 12);
a.pipe_mut(|a| a.1 = 34);
assert_eq!(a, Foo(12, 34));

fn pipe_as_ref<'a, Param: ?Sized, Return, Function>(
    &'a self,
    f: Function
) -> Return where
    Self: AsRef<Param>,
    Param: 'a,
    Function: FnOnce(&'a Param) -> Return, 

Apply f to &self where f takes a single parameter of type Param and Self implements trait AsRef<Param>.

fn uppercase(x: &str) -> String {
  x.to_uppercase()
}
let x: String = "abc".to_string();
let y: String = x.pipe_as_ref(uppercase);
assert_eq!(y, "ABC");

fn pipe_as_mut<'a, Param: ?Sized, Return, Function>(
    &'a mut self,
    f: Function
) -> Return where
    Self: AsMut<Param>,
    Param: 'a,
    Function: FnOnce(&'a mut Param) -> Return, 

Apply f to &mut self where f takes a single parameter of type Param and Self implements trait AsMut<Param>.

fn modify(target: &mut [i32]) {
  target[0] = 123;
}
let mut vec: Vec<i32> = vec![0, 1, 2, 3];
vec.pipe_as_mut(modify);
assert_eq!(vec, vec![123, 1, 2, 3]);

fn pipe_deref<'a, Param: ?Sized, Return, Function>(
    &'a self,
    f: Function
) -> Return where
    Self: Deref<Target = Param>,
    Param: 'a,
    Function: FnOnce(&'a Param) -> Return, 

Apply f to &self where f takes a single parameter of type Param and Self implements trait Deref<Param>.

fn uppercase(x: &str) -> String {
  x.to_uppercase()
}
let x: String = "abc".to_string();
let y: String = x.pipe_deref(uppercase);
assert_eq!(y, "ABC");

fn pipe_deref_mut<'a, Param: ?Sized, Return, Function>(
    &'a mut self,
    f: Function
) -> Return where
    Self: DerefMut<Target = Param>,
    Param: 'a,
    Function: FnOnce(&'a mut Param) -> Return, 

Apply f to &mut self where f takes a single parameter of type Param and Self implements trait DerefMut<Param>.

fn modify(target: &mut [i32]) {
  target[0] = 123;
}
let mut vec: Vec<i32> = vec![0, 1, 2, 3];
vec.pipe_deref_mut(modify);
assert_eq!(vec, vec![123, 1, 2, 3]);

fn pipe_borrow<'a, Param: ?Sized, Return, Function>(
    &'a self,
    f: Function
) -> Return where
    Self: Borrow<Param>,
    Param: 'a,
    Function: FnOnce(&'a Param) -> Return, 

Apply f to &self where f takes a single parameter of type Param and Self implements trait Deref<Param>.

fn uppercase(x: &str) -> String {
  x.to_uppercase()
}
let x: String = "abc".to_string();
let y: String = x.pipe_borrow(uppercase);
assert_eq!(y, "ABC");

fn pipe_borrow_mut<'a, Param: ?Sized, Return, Function>(
    &'a mut self,
    f: Function
) -> Return where
    Self: BorrowMut<Param>,
    Param: 'a,
    Function: FnOnce(&'a mut Param) -> Return, 

Apply f to &mut self where f takes a single parameter of type Param and Self implements trait DerefMut<Param>.

fn modify(target: &mut [i32]) {
  target[0] = 123;
}
let mut vec: Vec<i32> = vec![0, 1, 2, 3];
vec.pipe_borrow_mut(modify);
assert_eq!(vec, vec![123, 1, 2, 3]);

Loading content...

Implementors

impl<X> Pipe for X

Loading content...