Trait Pipe

pub trait Pipe {
    // Provided methods
    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, Return, Function>(&'a self, f: Function) -> Return
       where Self: AsRef<Param>,
             Param: ?Sized + 'a,
             Function: FnOnce(&'a Param) -> Return { ... }
    fn pipe_as_mut<'a, Param, Return, Function>(
        &'a mut self,
        f: Function,
    ) -> Return
       where Self: AsMut<Param>,
             Param: ?Sized + 'a,
             Function: FnOnce(&'a mut Param) -> Return { ... }
    fn pipe_deref<'a, Param, Return, Function>(&'a self, f: Function) -> Return
       where Self: Deref<Target = Param>,
             Param: ?Sized + 'a,
             Function: FnOnce(&'a Param) -> Return { ... }
    fn pipe_deref_mut<'a, Param, Return, Function>(
        &'a mut self,
        f: Function,
    ) -> Return
       where Self: DerefMut<Target = Param>,
             Param: ?Sized + 'a,
             Function: FnOnce(&'a mut Param) -> Return { ... }
    fn pipe_borrow<'a, Param, Return, Function>(&'a self, f: Function) -> Return
       where Self: Borrow<Param>,
             Param: ?Sized + 'a,
             Function: FnOnce(&'a Param) -> Return { ... }
    fn pipe_borrow_mut<'a, Param, Return, Function>(
        &'a mut self,
        f: Function,
    ) -> Return
       where Self: BorrowMut<Param>,
             Param: ?Sized + '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, Return, Function>(&'a self, f: Function) -> Return

where Self: AsRef<Param>, Param: ?Sized + '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, Return, Function>(&'a mut self, f: Function) -> Return

where Self: AsMut<Param>, Param: ?Sized + '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, Return, Function>(&'a self, f: Function) -> Return

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

Apply f to &self where f takes a single parameter of type Param and Self implements trait Deref<Target = 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, Return, Function>( &'a mut self, f: Function, ) -> Return

where Self: DerefMut<Target = Param>, Param: ?Sized + '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<Target = 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, Return, Function>(&'a self, f: Function) -> Return

where Self: Borrow<Param>, Param: ?Sized + 'a, Function: FnOnce(&'a Param) -> Return,

Apply f to &self where f takes a single parameter of type Param and Self implements trait Borrow<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, Return, Function>( &'a mut self, f: Function, ) -> Return

where Self: BorrowMut<Param>, Param: ?Sized + '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 BorrowMut<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]);

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<X> Pipe for X