Trait Split

pub trait Split<Args, Ret> {
    type Trampoline;

    // Required method
    fn trampoline() -> Self::Trampoline;
}

A helper trait used by split_closure() to get a trampoline function which will invoke the closure.

This trait is automatically implemented for any FnMut() callable, you shouldn’t implement it yourself.

Required Associated Types

type Trampoline

Required Methods

fn trampoline() -> Self::Trampoline

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<Func, Ret> Split<(), Ret> for Func

where Func: FnMut() -> Ret,

type Trampoline = unsafe extern "C" fn(*mut c_void) -> Ret

impl<Func, Ret, A> Split<(A,), Ret> for Func

where Func: FnMut(A) -> Ret,

type Trampoline = unsafe extern "C" fn(*mut c_void, A) -> Ret

impl<Func, Ret, A, B> Split<(A, B), Ret> for Func

where Func: FnMut(A, B) -> Ret,

type Trampoline = unsafe extern "C" fn(*mut c_void, A, B) -> Ret

impl<Func, Ret, A, B, C> Split<(A, B, C), Ret> for Func

where Func: FnMut(A, B, C) -> Ret,

type Trampoline = unsafe extern "C" fn(*mut c_void, A, B, C) -> Ret

impl<Func, Ret, A, B, C, D> Split<(A, B, C, D), Ret> for Func

where Func: FnMut(A, B, C, D) -> Ret,

type Trampoline = unsafe extern "C" fn(*mut c_void, A, B, C, D) -> Ret

impl<Func, Ret, A, B, C, D, E> Split<(A, B, C, D, E), Ret> for Func

where Func: FnMut(A, B, C, D, E) -> Ret,

type Trampoline = unsafe extern "C" fn(*mut c_void, A, B, C, D, E) -> Ret

impl<Func, Ret, A, B, C, D, E, F> Split<(A, B, C, D, E, F), Ret> for Func

where Func: FnMut(A, B, C, D, E, F) -> Ret,

type Trampoline = unsafe extern "C" fn(*mut c_void, A, B, C, D, E, F) -> Ret

impl<Func, Ret, A, B, C, D, E, F, G> Split<(A, B, C, D, E, F, G), Ret> for Func

where Func: FnMut(A, B, C, D, E, F, G) -> Ret,

type Trampoline = unsafe extern "C" fn(*mut c_void, A, B, C, D, E, F, G) -> Ret

impl<Func, Ret, A, B, C, D, E, F, G, H> Split<(A, B, C, D, E, F, G, H), Ret> for Func

where Func: FnMut(A, B, C, D, E, F, G, H) -> Ret,

type Trampoline = unsafe extern "C" fn(*mut c_void, A, B, C, D, E, F, G, H) -> Ret

impl<Func, Ret, A, B, C, D, E, F, G, H, I> Split<(A, B, C, D, E, F, G, H, I), Ret> for Func

where Func: FnMut(A, B, C, D, E, F, G, H, I) -> Ret,

type Trampoline = unsafe extern "C" fn(*mut c_void, A, B, C, D, E, F, G, H, I) -> Ret

impl<Func, Ret, A, B, C, D, E, F, G, H, I, K> Split<(A, B, C, D, E, F, G, H, I, K), Ret> for Func

where Func: FnMut(A, B, C, D, E, F, G, H, I, K) -> Ret,

type Trampoline = unsafe extern "C" fn(*mut c_void, A, B, C, D, E, F, G, H, I, K) -> Ret

impl<Func, Ret, A, B, C, D, E, F, G, H, I, K, L> Split<(A, B, C, D, E, F, G, H, I, K, L), Ret> for Func

where Func: FnMut(A, B, C, D, E, F, G, H, I, K, L) -> Ret,

type Trampoline = unsafe extern "C" fn(*mut c_void, A, B, C, D, E, F, G, H, I, K, L) -> Ret

impl<Func, Ret, A, B, C, D, E, F, G, H, I, K, L, M> Split<(A, B, C, D, E, F, G, H, I, K, L, M), Ret> for Func

where Func: FnMut(A, B, C, D, E, F, G, H, I, K, L, M) -> Ret,

type Trampoline = unsafe extern "C" fn(*mut c_void, A, B, C, D, E, F, G, H, I, K, L, M) -> Ret

impl<Func, Ret, A, B, C, D, E, F, G, H, I, K, L, M, N> Split<(A, B, C, D, E, F, G, H, I, K, L, M, N), Ret> for Func

where Func: FnMut(A, B, C, D, E, F, G, H, I, K, L, M, N) -> Ret,

type Trampoline = unsafe extern "C" fn(*mut c_void, A, B, C, D, E, F, G, H, I, K, L, M, N) -> Ret

impl<Func, Ret, A, B, C, D, E, F, G, H, I, K, L, M, N, O> Split<(A, B, C, D, E, F, G, H, I, K, L, M, N, O), Ret> for Func

where Func: FnMut(A, B, C, D, E, F, G, H, I, K, L, M, N, O) -> Ret,

type Trampoline = unsafe extern "C" fn(*mut c_void, A, B, C, D, E, F, G, H, I, K, L, M, N, O) -> Ret