Trait core_extensions::callable::CallRef

pub trait CallRef<Params>: CallMut<Params> {
    fn call_ref(&self, params: Params) -> Self::Returns;
}

implementable version of ::std::ops::Fn.

Required methods

fn call_ref(&self, params: Params) -> Self::Returns

calls this function

Loading content...

Implementors

impl<A, B, C, D, E, F, Func, Ret> CallRef<(A, B, C, D, E, F)> for Func where
    Func: Fn(A, B, C, D, E, F) -> Ret, 

fn call_ref(&self, (A, B, C, D, E, F): (A, B, C, D, E, F)) -> Ret

impl<A, B, C, D, E, F, G, Func, Ret> CallRef<(A, B, C, D, E, F, G)> for Func where
    Func: Fn(A, B, C, D, E, F, G) -> Ret, 

fn call_ref(&self, (A, B, C, D, E, F, G): (A, B, C, D, E, F, G)) -> Ret

impl<A, B, C, D, E, F, G, H, Func, Ret> CallRef<(A, B, C, D, E, F, G, H)> for Func where
    Func: Fn(A, B, C, D, E, F, G, H) -> Ret, 

fn call_ref(&self, (A, B, C, D, E, F, G, H): (A, B, C, D, E, F, G, H)) -> Ret

impl<A, B, C, D, E, F, G, H, I, Func, Ret> CallRef<(A, B, C, D, E, F, G, H, I)> for Func where
    Func: Fn(A, B, C, D, E, F, G, H, I) -> Ret, 

fn call_ref(
    &self,
    (A, B, C, D, E, F, G, H, I): (A, B, C, D, E, F, G, H, I)
) -> Ret

impl<A, B, C, D, E, F, G, H, I, J, Func, Ret> CallRef<(A, B, C, D, E, F, G, H, I, J)> for Func where
    Func: Fn(A, B, C, D, E, F, G, H, I, J) -> Ret, 

fn call_ref(
    &self,
    (A, B, C, D, E, F, G, H, I, J): (A, B, C, D, E, F, G, H, I, J)
) -> Ret

impl<A, B, C, D, E, F, G, H, I, J, K, Func, Ret> CallRef<(A, B, C, D, E, F, G, H, I, J, K)> for Func where
    Func: Fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret, 

fn call_ref(
    &self,
    (A, B, C, D, E, F, G, H, I, J, K): (A, B, C, D, E, F, G, H, I, J, K)
) -> Ret

impl<A, B, C, D, E, F, G, H, I, J, K, L, Func, Ret> CallRef<(A, B, C, D, E, F, G, H, I, J, K, L)> for Func where
    Func: Fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret, 

fn call_ref(
    &self,
    (A, B, C, D, E, F, G, H, I, J, K, L): (A, B, C, D, E, F, G, H, I, J, K, L)
) -> Ret

impl<A, B, C, D, E, Func, Ret> CallRef<(A, B, C, D, E)> for Func where
    Func: Fn(A, B, C, D, E) -> Ret, 

fn call_ref(&self, (A, B, C, D, E): (A, B, C, D, E)) -> Ret

impl<A, B, C, D, Func, Ret> CallRef<(A, B, C, D)> for Func where
    Func: Fn(A, B, C, D) -> Ret, 

fn call_ref(&self, (A, B, C, D): (A, B, C, D)) -> Ret

impl<A, B, C, Func, Ret> CallRef<(A, B, C)> for Func where
    Func: Fn(A, B, C) -> Ret, 

fn call_ref(&self, (A, B, C): (A, B, C)) -> Ret

impl<A, B, Func, Ret> CallRef<(A, B)> for Func where
    Func: Fn(A, B) -> Ret, 

fn call_ref(&self, (A, B): (A, B)) -> Ret

impl<A, Func, Ret> CallRef<(A,)> for Func where
    Func: Fn(A) -> Ret, 

fn call_ref(&self, (A): (A,)) -> Ret

impl<F, Ret> CallRef<()> for F where
    F: Fn() -> Ret, 

fn call_ref(&self, _: ()) -> Ret

Loading content...