Trait rai_core::Func

pub trait Func<InKind, In, Out> {
    // Required method
    fn apply(&self, input: In) -> Out;
}

Required Methods

fn apply(&self, input: In) -> Out

Implementors

impl<A, B, C, D, E, F, G, H, I, J, K, L, OUT, FUNC> Func<Tuple<(A, B, C, D, E, F, G, H, I, J, K, L)>, (A, B, C, D, E, F, G, H, I, J, K, L), OUT> for FUNC

where FUNC: Fn(A, B, C, D, E, F, G, H, I, J, K, L) -> OUT,

impl<A, B, C, D, E, F, G, H, I, J, K, OUT, FUNC> Func<Tuple<(A, B, C, D, E, F, G, H, I, J, K)>, (A, B, C, D, E, F, G, H, I, J, K), OUT> for FUNC

where FUNC: Fn(A, B, C, D, E, F, G, H, I, J, K) -> OUT,

impl<A, B, C, D, E, F, G, H, I, J, OUT, FUNC> Func<Tuple<(A, B, C, D, E, F, G, H, I, J)>, (A, B, C, D, E, F, G, H, I, J), OUT> for FUNC

where FUNC: Fn(A, B, C, D, E, F, G, H, I, J) -> OUT,

impl<A, B, C, D, E, F, G, H, I, OUT, FUNC> Func<Tuple<(A, B, C, D, E, F, G, H, I)>, (A, B, C, D, E, F, G, H, I), OUT> for FUNC

where FUNC: Fn(A, B, C, D, E, F, G, H, I) -> OUT,

impl<A, B, C, D, E, F, G, H, OUT, FUNC> Func<Tuple<(A, B, C, D, E, F, G, H)>, (A, B, C, D, E, F, G, H), OUT> for FUNC

where FUNC: Fn(A, B, C, D, E, F, G, H) -> OUT,

impl<A, B, C, D, E, F, G, OUT, FUNC> Func<Tuple<(A, B, C, D, E, F, G)>, (A, B, C, D, E, F, G), OUT> for FUNC

where FUNC: Fn(A, B, C, D, E, F, G) -> OUT,

impl<A, B, C, D, E, F, OUT, FUNC> Func<Tuple<(A, B, C, D, E, F)>, (A, B, C, D, E, F), OUT> for FUNC

where FUNC: Fn(A, B, C, D, E, F) -> OUT,

impl<A, B, C, D, E, OUT, FUNC> Func<Tuple<(A, B, C, D, E)>, (A, B, C, D, E), OUT> for FUNC

where FUNC: Fn(A, B, C, D, E) -> OUT,

impl<A, B, C, D, OUT, FUNC> Func<Tuple<(A, B, C, D)>, (A, B, C, D), OUT> for FUNC

where FUNC: Fn(A, B, C, D) -> OUT,

impl<A, B, C, OUT, FUNC> Func<Tuple<(A, B, C)>, (A, B, C), OUT> for FUNC

where FUNC: Fn(A, B, C) -> OUT,

impl<A, B, OUT, FUNC> Func<Tuple<(A, B)>, (A, B), OUT> for FUNC

where FUNC: Fn(A, B) -> OUT,

impl<A, OUT, FUNC> Func<Tuple<(A,)>, (A,), OUT> for FUNC

where FUNC: Fn(A) -> OUT,

impl<I, O, F> Func<Basic, I, O> for F

where F: Fn(I) -> O,

impl<I, O, F> Func<Module, I, O> for F

where F: Fn(I) -> O, I: Module,

impl<I, OUT, FUNC> Func<Array<[I; 1]>, [I; 1], OUT> for FUNC

where FUNC: Fn(I) -> OUT,

impl<I, OUT, FUNC> Func<Array<[I; 2]>, [I; 2], OUT> for FUNC

where FUNC: Fn(I, I) -> OUT,

impl<I, OUT, FUNC> Func<Array<[I; 3]>, [I; 3], OUT> for FUNC

where FUNC: Fn(I, I, I) -> OUT,

impl<I, OUT, FUNC> Func<Array<[I; 4]>, [I; 4], OUT> for FUNC

where FUNC: Fn(I, I, I, I) -> OUT,

impl<I, OUT, FUNC> Func<Array<[I; 5]>, [I; 5], OUT> for FUNC

where FUNC: Fn(I, I, I, I, I) -> OUT,

impl<I, OUT, FUNC> Func<Array<[I; 6]>, [I; 6], OUT> for FUNC

where FUNC: Fn(I, I, I, I, I, I) -> OUT,

impl<I, OUT, FUNC> Func<Array<[I; 7]>, [I; 7], OUT> for FUNC

where FUNC: Fn(I, I, I, I, I, I, I) -> OUT,

impl<I, OUT, FUNC> Func<Array<[I; 8]>, [I; 8], OUT> for FUNC

where FUNC: Fn(I, I, I, I, I, I, I, I) -> OUT,

impl<I, OUT, FUNC> Func<Array<[I; 9]>, [I; 9], OUT> for FUNC

where FUNC: Fn(I, I, I, I, I, I, I, I, I) -> OUT,

impl<I, OUT, FUNC> Func<Array<[I; 10]>, [I; 10], OUT> for FUNC

where FUNC: Fn(I, I, I, I, I, I, I, I, I, I) -> OUT,

impl<I, OUT, FUNC> Func<Array<[I; 11]>, [I; 11], OUT> for FUNC

where FUNC: Fn(I, I, I, I, I, I, I, I, I, I, I) -> OUT,

impl<I, OUT, FUNC> Func<Array<[I; 12]>, [I; 12], OUT> for FUNC

where FUNC: Fn(I, I, I, I, I, I, I, I, I, I, I, I) -> OUT,