Trait FnOnceOfArgs

pub trait FnOnceOfArgs<TArgs> {
    type Output;
    type DynFnOnce: ?Sized + DynFnOnce<ArgsTuple = TArgs>;

    // Required method
    fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>
       where Self: 'static;
}

Required Associated Types

type Output

type DynFnOnce: ?Sized + DynFnOnce<ArgsTuple = TArgs>

Required Methods

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

Implementations on Foreign Types

impl<A, B, C, D, E, F, G, H, TReturn> FnOnceOfArgs<(A, B, C, D, E, F, G, H)> for dyn Fn(A, B, C, D, E, F, G, H) -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B, C, D, E, F, G, H) -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

impl<A, B, C, D, E, F, G, H, TReturn> FnOnceOfArgs<(A, B, C, D, E, F, G, H)> for dyn FnMut(A, B, C, D, E, F, G, H) -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B, C, D, E, F, G, H) -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

impl<A, B, C, D, E, F, G, H, TReturn> FnOnceOfArgs<(A, B, C, D, E, F, G, H)> for dyn FnOnce(A, B, C, D, E, F, G, H) -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B, C, D, E, F, G, H) -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

impl<A, B, C, D, E, F, G, TReturn> FnOnceOfArgs<(A, B, C, D, E, F, G)> for dyn Fn(A, B, C, D, E, F, G) -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B, C, D, E, F, G) -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

impl<A, B, C, D, E, F, G, TReturn> FnOnceOfArgs<(A, B, C, D, E, F, G)> for dyn FnMut(A, B, C, D, E, F, G) -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B, C, D, E, F, G) -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

impl<A, B, C, D, E, F, G, TReturn> FnOnceOfArgs<(A, B, C, D, E, F, G)> for dyn FnOnce(A, B, C, D, E, F, G) -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B, C, D, E, F, G) -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

impl<A, B, C, D, E, F, TReturn> FnOnceOfArgs<(A, B, C, D, E, F)> for dyn Fn(A, B, C, D, E, F) -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B, C, D, E, F) -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

impl<A, B, C, D, E, F, TReturn> FnOnceOfArgs<(A, B, C, D, E, F)> for dyn FnMut(A, B, C, D, E, F) -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B, C, D, E, F) -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

impl<A, B, C, D, E, F, TReturn> FnOnceOfArgs<(A, B, C, D, E, F)> for dyn FnOnce(A, B, C, D, E, F) -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B, C, D, E, F) -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

impl<A, B, C, D, E, TReturn> FnOnceOfArgs<(A, B, C, D, E)> for dyn Fn(A, B, C, D, E) -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B, C, D, E) -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

impl<A, B, C, D, E, TReturn> FnOnceOfArgs<(A, B, C, D, E)> for dyn FnMut(A, B, C, D, E) -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B, C, D, E) -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

impl<A, B, C, D, E, TReturn> FnOnceOfArgs<(A, B, C, D, E)> for dyn FnOnce(A, B, C, D, E) -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B, C, D, E) -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

impl<A, B, C, D, TReturn> FnOnceOfArgs<(A, B, C, D)> for dyn Fn(A, B, C, D) -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B, C, D) -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

impl<A, B, C, D, TReturn> FnOnceOfArgs<(A, B, C, D)> for dyn FnMut(A, B, C, D) -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B, C, D) -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

impl<A, B, C, D, TReturn> FnOnceOfArgs<(A, B, C, D)> for dyn FnOnce(A, B, C, D) -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B, C, D) -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

impl<A, B, C, TReturn> FnOnceOfArgs<(A, B, C)> for dyn Fn(A, B, C) -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B, C) -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

impl<A, B, C, TReturn> FnOnceOfArgs<(A, B, C)> for dyn FnMut(A, B, C) -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B, C) -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

impl<A, B, C, TReturn> FnOnceOfArgs<(A, B, C)> for dyn FnOnce(A, B, C) -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B, C) -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

impl<A, B, TReturn> FnOnceOfArgs<(A, B)> for dyn Fn(A, B) -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B) -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

impl<A, B, TReturn> FnOnceOfArgs<(A, B)> for dyn FnMut(A, B) -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B) -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

impl<A, B, TReturn> FnOnceOfArgs<(A, B)> for dyn FnOnce(A, B) -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B) -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

impl<A, TReturn> FnOnceOfArgs<(A,)> for dyn Fn(A) -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce(A) -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

impl<A, TReturn> FnOnceOfArgs<(A,)> for dyn FnMut(A) -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce(A) -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

impl<A, TReturn> FnOnceOfArgs<(A,)> for dyn FnOnce(A) -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce(A) -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

impl<TReturn> FnOnceOfArgs<()> for dyn Fn() -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce() -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

impl<TReturn> FnOnceOfArgs<()> for dyn FnMut() -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce() -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

impl<TReturn> FnOnceOfArgs<()> for dyn FnOnce() -> TReturn

type Output = TReturn

type DynFnOnce = dyn FnOnce() -> TReturn

fn into_box_dyn_fn_once(self: Box<Self>) -> Box<Self::DynFnOnce>

where Self: 'static,

Implementors

impl<TFunc, A, B, C, D, E, F, G, H, TReturn> FnOnceOfArgs<(A, B, C, D, E, F, G, H)> for TFunc

where TFunc: FnOnce(A, B, C, D, E, F, G, H) -> TReturn,

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B, C, D, E, F, G, H) -> TReturn

impl<TFunc, A, B, C, D, E, F, G, TReturn> FnOnceOfArgs<(A, B, C, D, E, F, G)> for TFunc

where TFunc: FnOnce(A, B, C, D, E, F, G) -> TReturn,

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B, C, D, E, F, G) -> TReturn

impl<TFunc, A, B, C, D, E, F, TReturn> FnOnceOfArgs<(A, B, C, D, E, F)> for TFunc

where TFunc: FnOnce(A, B, C, D, E, F) -> TReturn,

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B, C, D, E, F) -> TReturn

impl<TFunc, A, B, C, D, E, TReturn> FnOnceOfArgs<(A, B, C, D, E)> for TFunc

where TFunc: FnOnce(A, B, C, D, E) -> TReturn,

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B, C, D, E) -> TReturn

impl<TFunc, A, B, C, D, TReturn> FnOnceOfArgs<(A, B, C, D)> for TFunc

where TFunc: FnOnce(A, B, C, D) -> TReturn,

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B, C, D) -> TReturn

impl<TFunc, A, B, C, TReturn> FnOnceOfArgs<(A, B, C)> for TFunc

where TFunc: FnOnce(A, B, C) -> TReturn,

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B, C) -> TReturn

impl<TFunc, A, B, TReturn> FnOnceOfArgs<(A, B)> for TFunc

where TFunc: FnOnce(A, B) -> TReturn,

type Output = TReturn

type DynFnOnce = dyn FnOnce(A, B) -> TReturn

impl<TFunc, A, TReturn> FnOnceOfArgs<(A,)> for TFunc

where TFunc: FnOnce(A) -> TReturn,

type Output = TReturn

type DynFnOnce = dyn FnOnce(A) -> TReturn

impl<TFunc, TReturn> FnOnceOfArgs<()> for TFunc

where TFunc: FnOnce() -> TReturn,

type Output = TReturn

type DynFnOnce = dyn FnOnce() -> TReturn