Trait core_extensions::callable::CallExt[−][src]

pub trait CallExt {
    fn ref_call<P>(&self, params: P) -> Self::Returns
    where
        Self: CallRef<P>,
    { ... }

    fn mut_call<P>(&mut self, params: P) -> Self::Returns
    where
        Self: CallMut<P>,
    { ... }

    fn into_call<P>(self, params: P) -> Self::Returns
    where
        Self: Sized,
        Self: CallInto<P>,
    { ... }
}
This is supported on crate feature callable only.

Extension trait for calling Call* closures.

Provided methods

fn ref_call<P>(&self, params: P) -> Self::Returns where
    Self: CallRef<P>, [src]

For calling CallRef::ref_call_, with the ability to specify the types of the arguments..

Example

use core_extensions::{impl_call, CallExt};

struct PushTwice;

impl_call! { 
    fn ref_call[T](self: PushTwice, vector: &mut Vec<T>, value: T )
    where[ T: Clone ]
    {
        vector.push(value.clone());
        vector.push(value);
    }
}

let mut vector = Vec::new();

// `Call*` style closures encode multiple parameters as tuples
PushTwice.ref_call((&mut vector, 3));
assert_eq!(vector, [3, 3]);

// The turbofish operator can be used to specify the types of the arguments.
PushTwice.ref_call::<(_, u128)>((&mut vector, 5));
assert_eq!(vector, [3, 3, 5, 5]);

PushTwice.ref_call((&mut vector, 8));
assert_eq!(vector, [3, 3, 5, 5, 8, 8]);

fn mut_call<P>(&mut self, params: P) -> Self::Returns where
    Self: CallMut<P>, [src]

For calling CallMut::mut_call_, with the ability to specify the types of the arguments..

Example

use core_extensions::{impl_call, CallExt};

struct ComputeFib {
    nums: [u128; 2],
}

impl_call! { 
    fn mut_call(self: ComputeFib, numbers: &mut Vec<u128>) {
        let [l, r] = self.nums;
        let next = l + r;
        self.nums = [r, next];
        numbers.push(r);
    }
}

let mut fibs = ComputeFib {nums: [0, 1]};
 
let mut numbers = Vec::new();

// The turbofish operator can be used to specify the types of the arguments.
fibs.mut_call::<&mut Vec<u128>>(&mut numbers);
assert_eq!(numbers, [1]);

fibs.mut_call(&mut numbers);
assert_eq!(numbers, [1, 1]);

fibs.mut_call(&mut numbers);
assert_eq!(numbers, [1, 1, 2]);

fibs.mut_call(&mut numbers);
assert_eq!(numbers, [1, 1, 2, 3]);

fibs.mut_call(&mut numbers);
assert_eq!(numbers, [1, 1, 2, 3, 5]);

fibs.mut_call(&mut numbers);
assert_eq!(numbers, [1, 1, 2, 3, 5, 8]);

fn into_call<P>(self, params: P) -> Self::Returns where
    Self: Sized,
    Self: CallInto<P>, [src]

For calling CallInto::into_call_, with the ability to specify the types of the arguments..

Example

use core_extensions::{impl_call, CallExt};

use std::iter::FromIterator;

struct IntoElem<T>(T);

impl_call! { 
    fn into_call[T](self: IntoElem<T>, nth: usize) -> Option<T::Item>
    where[ T: IntoIterator ]
    {
        self.0.into_iter().nth(nth)
    }
}
 
let list = vec![3, 5, 8, 13, 21, 34, 55, 89];
 
// The turbofish operator can be used to specify the types of the arguments.
assert_eq!(IntoElem(list.clone()).into_call::<usize>(0), Some(3));
 
assert_eq!(IntoElem(list.clone()).into_call(1), Some(5));
 
assert_eq!(IntoElem(list.clone()).into_call(2), Some(8));
 
assert_eq!(IntoElem(list.clone()).into_call(3), Some(13));
 
assert_eq!(IntoElem(list.clone()).into_call(7), Some(89));
Loading content...

Implementors

impl<T: ?Sized> CallExt for T[src]

Loading content...