Trait react::FnMutOfArgs

pub trait FnMutOfArgs<TArgs>: FnOnceOfArgs<TArgs> {
    type DynFnMut: ?Sized + DynFnMut<ArgsTuple = TArgs>;
    fn into_box_dyn_fn_mut(self: Box<Self>) -> Box<Self::DynFnMut>
    where
        Self: 'static;
}

Associated Types

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

Required methods

fn into_box_dyn_fn_mut(self: Box<Self>) -> Box<Self::DynFnMut> where
    Self: 'static, 

Implementations on Foreign Types

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

type DynFnMut = Self

fn into_box_dyn_fn_mut(self: Box<Self>) -> Box<Self::DynFnMut> where
    Self: 'static, 

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

type DynFnMut = dyn FnMut() -> TReturn

fn into_box_dyn_fn_mut(self: Box<Self>) -> Box<Self::DynFnMut> where
    Self: 'static, 

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

type DynFnMut = Self

fn into_box_dyn_fn_mut(self: Box<Self>) -> Box<Self::DynFnMut> where
    Self: 'static, 

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

type DynFnMut = dyn FnMut(A) -> TReturn

fn into_box_dyn_fn_mut(self: Box<Self>) -> Box<Self::DynFnMut> where
    Self: 'static, 

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

type DynFnMut = Self

fn into_box_dyn_fn_mut(self: Box<Self>) -> Box<Self::DynFnMut> where
    Self: 'static, 

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

type DynFnMut = dyn FnMut(A, B) -> TReturn

fn into_box_dyn_fn_mut(self: Box<Self>) -> Box<Self::DynFnMut> where
    Self: 'static, 

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

type DynFnMut = Self

fn into_box_dyn_fn_mut(self: Box<Self>) -> Box<Self::DynFnMut> where
    Self: 'static, 

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

type DynFnMut = dyn FnMut(A, B, C) -> TReturn

fn into_box_dyn_fn_mut(self: Box<Self>) -> Box<Self::DynFnMut> where
    Self: 'static, 

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

type DynFnMut = Self

fn into_box_dyn_fn_mut(self: Box<Self>) -> Box<Self::DynFnMut> where
    Self: 'static, 

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

type DynFnMut = dyn FnMut(A, B, C, D) -> TReturn

fn into_box_dyn_fn_mut(self: Box<Self>) -> Box<Self::DynFnMut> where
    Self: 'static, 

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

type DynFnMut = Self

fn into_box_dyn_fn_mut(self: Box<Self>) -> Box<Self::DynFnMut> where
    Self: 'static, 

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

type DynFnMut = dyn FnMut(A, B, C, D, E) -> TReturn

fn into_box_dyn_fn_mut(self: Box<Self>) -> Box<Self::DynFnMut> where
    Self: 'static, 

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

type DynFnMut = Self

fn into_box_dyn_fn_mut(self: Box<Self>) -> Box<Self::DynFnMut> where
    Self: 'static, 

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

type DynFnMut = dyn FnMut(A, B, C, D, E, F) -> TReturn

fn into_box_dyn_fn_mut(self: Box<Self>) -> Box<Self::DynFnMut> where
    Self: 'static, 

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

type DynFnMut = Self

fn into_box_dyn_fn_mut(self: Box<Self>) -> Box<Self::DynFnMut> where
    Self: 'static, 

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

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

fn into_box_dyn_fn_mut(self: Box<Self>) -> Box<Self::DynFnMut> where
    Self: 'static, 

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

type DynFnMut = Self

fn into_box_dyn_fn_mut(self: Box<Self>) -> Box<Self::DynFnMut> where
    Self: 'static, 

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

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

fn into_box_dyn_fn_mut(self: Box<Self>) -> Box<Self::DynFnMut> where
    Self: 'static, 

Implementors

impl<TFunc, A, B, C, D, E, F, G, H, TReturn> FnMutOfArgs<(A, B, C, D, E, F, G, H)> for TFunc where
    TFunc: FnMut(A, B, C, D, E, F, G, H) -> TReturn, 

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

impl<TFunc, A, B, C, D, E, F, G, TReturn> FnMutOfArgs<(A, B, C, D, E, F, G)> for TFunc where
    TFunc: FnMut(A, B, C, D, E, F, G) -> TReturn, 

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

impl<TFunc, A, B, C, D, E, F, TReturn> FnMutOfArgs<(A, B, C, D, E, F)> for TFunc where
    TFunc: FnMut(A, B, C, D, E, F) -> TReturn, 

type DynFnMut = dyn FnMut(A, B, C, D, E, F) -> TReturn

impl<TFunc, A, B, C, D, E, TReturn> FnMutOfArgs<(A, B, C, D, E)> for TFunc where
    TFunc: FnMut(A, B, C, D, E) -> TReturn, 

type DynFnMut = dyn FnMut(A, B, C, D, E) -> TReturn

impl<TFunc, A, B, C, D, TReturn> FnMutOfArgs<(A, B, C, D)> for TFunc where
    TFunc: FnMut(A, B, C, D) -> TReturn, 

type DynFnMut = dyn FnMut(A, B, C, D) -> TReturn

impl<TFunc, A, B, C, TReturn> FnMutOfArgs<(A, B, C)> for TFunc where
    TFunc: FnMut(A, B, C) -> TReturn, 

type DynFnMut = dyn FnMut(A, B, C) -> TReturn

impl<TFunc, A, B, TReturn> FnMutOfArgs<(A, B)> for TFunc where
    TFunc: FnMut(A, B) -> TReturn, 

type DynFnMut = dyn FnMut(A, B) -> TReturn

impl<TFunc, A, TReturn> FnMutOfArgs<(A,)> for TFunc where
    TFunc: FnMut(A) -> TReturn, 

type DynFnMut = dyn FnMut(A) -> TReturn

impl<TFunc, TReturn> FnMutOfArgs<()> for TFunc where
    TFunc: FnMut() -> TReturn, 

type DynFnMut = dyn FnMut() -> TReturn