hyperlight_host::func

Struct HostFunction

pub struct HostFunction<Output, Args>where
    Args: ParameterTuple,
    Output: SupportedReturnType,
{ /* private fields */ }

Expand description

Re-export for HostFunction trait A representation of a host function. This is a thin wrapper around a Fn(Args) -> Result<Output>.

Implementations§

impl<Args, Output> HostFunction<Output, Args>
where Args: ParameterTuple, Output: SupportedReturnType,

pub fn call(&self, args: Args) -> Result<Output>

Call the host function with the given arguments.

Trait Implementations§

impl<Output, Args> Clone for HostFunction<Output, Args>
where Args: ParameterTuple + Clone, Output: SupportedReturnType + Clone,

fn clone(&self) -> HostFunction<Output, Args>

Returns a duplicate of the value. Read more

1.0.0 · Source§

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

impl<F, R> From<F> for HostFunction<R::ReturnType, ()>
where F: FnMut() -> R + Send + 'static, (): ParameterTuple, R: ResultType,

fn from(func: F) -> HostFunction<R::ReturnType, ()>

Converts to this type from the input type.

impl<F, R, P1> From<F> for HostFunction<R::ReturnType, (P1,)>
where F: FnMut(P1) -> R + Send + 'static, (P1,): ParameterTuple, R: ResultType,

fn from(func: F) -> HostFunction<R::ReturnType, (P1,)>

Converts to this type from the input type.

impl<F, R, P1, P2> From<F> for HostFunction<R::ReturnType, (P1, P2)>
where F: FnMut(P1, P2) -> R + Send + 'static, (P1, P2): ParameterTuple, R: ResultType,

fn from(func: F) -> HostFunction<R::ReturnType, (P1, P2)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3> From<F> for HostFunction<R::ReturnType, (P1, P2, P3)>
where F: FnMut(P1, P2, P3) -> R + Send + 'static, (P1, P2, P3): ParameterTuple, R: ResultType,

fn from(func: F) -> HostFunction<R::ReturnType, (P1, P2, P3)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4)>
where F: FnMut(P1, P2, P3, P4) -> R + Send + 'static, (P1, P2, P3, P4): ParameterTuple, R: ResultType,

fn from(func: F) -> HostFunction<R::ReturnType, (P1, P2, P3, P4)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5)>
where F: FnMut(P1, P2, P3, P4, P5) -> R + Send + 'static, (P1, P2, P3, P4, P5): ParameterTuple, R: ResultType,

fn from(func: F) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6)>
where F: FnMut(P1, P2, P3, P4, P5, P6) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6): ParameterTuple, R: ResultType,

fn from(func: F) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6, P7> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7)>
where F: FnMut(P1, P2, P3, P4, P5, P6, P7) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6, P7): ParameterTuple, R: ResultType,

fn from(func: F) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6, P7, P8> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8)>
where F: FnMut(P1, P2, P3, P4, P5, P6, P7, P8) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6, P7, P8): ParameterTuple, R: ResultType,

fn from( func: F, ) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6, P7, P8, P9> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9)>
where F: FnMut(P1, P2, P3, P4, P5, P6, P7, P8, P9) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6, P7, P8, P9): ParameterTuple, R: ResultType,

fn from( func: F, ) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10)>
where F: FnMut(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10): ParameterTuple, R: ResultType,

fn from( func: F, ) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11)>
where F: FnMut(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11): ParameterTuple, R: ResultType,

fn from( func: F, ) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12)>
where F: FnMut(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12): ParameterTuple, R: ResultType,

fn from( func: F, ) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13)>
where F: FnMut(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13): ParameterTuple, R: ResultType,

fn from( func: F, ) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14)>
where F: FnMut(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14): ParameterTuple, R: ResultType,

fn from( func: F, ) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15)>
where F: FnMut(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15): ParameterTuple, R: ResultType,

fn from( func: F, ) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16)>
where F: FnMut(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16): ParameterTuple, R: ResultType,

fn from( func: F, ) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17)>
where F: FnMut(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17): ParameterTuple, R: ResultType,

fn from( func: F, ) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18)>
where F: FnMut(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18): ParameterTuple, R: ResultType,

fn from( func: F, ) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)>
where F: FnMut(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19): ParameterTuple, R: ResultType,

fn from( func: F, ) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)>
where F: FnMut(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20): ParameterTuple, R: ResultType,

fn from( func: F, ) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21)>
where F: FnMut(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21): ParameterTuple, R: ResultType,

fn from( func: F, ) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22)>
where F: FnMut(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22): ParameterTuple, R: ResultType,

fn from( func: F, ) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23)>
where F: FnMut(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23): ParameterTuple, R: ResultType,

fn from( func: F, ) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24)>
where F: FnMut(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24): ParameterTuple, R: ResultType,

fn from( func: F, ) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25)>
where F: FnMut(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25): ParameterTuple, R: ResultType,

fn from( func: F, ) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26)>
where F: FnMut(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26): ParameterTuple, R: ResultType,

fn from( func: F, ) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27)>
where F: FnMut(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27): ParameterTuple, R: ResultType,

fn from( func: F, ) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27, P28> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27, P28)>
where F: FnMut(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27, P28) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27, P28): ParameterTuple, R: ResultType,

fn from( func: F, ) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27, P28)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27, P28, P29> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27, P28, P29)>
where F: FnMut(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27, P28, P29) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27, P28, P29): ParameterTuple, R: ResultType,

fn from( func: F, ) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27, P28, P29)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27, P28, P29, P30> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27, P28, P29, P30)>
where F: FnMut(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27, P28, P29, P30) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27, P28, P29, P30): ParameterTuple, R: ResultType,

fn from( func: F, ) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27, P28, P29, P30)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27, P28, P29, P30, P31> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27, P28, P29, P30, P31)>
where F: FnMut(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27, P28, P29, P30, P31) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27, P28, P29, P30, P31): ParameterTuple, R: ResultType,

fn from( func: F, ) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27, P28, P29, P30, P31)>

Converts to this type from the input type.

impl<F, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27, P28, P29, P30, P31, P32> From<F> for HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27, P28, P29, P30, P31, P32)>
where F: FnMut(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27, P28, P29, P30, P31, P32) -> R + Send + 'static, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27, P28, P29, P30, P31, P32): ParameterTuple, R: ResultType,

fn from( func: F, ) -> HostFunction<R::ReturnType, (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, P24, P25, P26, P27, P28, P29, P30, P31, P32)>

Converts to this type from the input type.

Auto Trait Implementations§

impl<Output, Args> Freeze for HostFunction<Output, Args>

impl<Output, Args> !RefUnwindSafe for HostFunction<Output, Args>

impl<Output, Args> Send for HostFunction<Output, Args>

impl<Output, Args> Sync for HostFunction<Output, Args>

impl<Output, Args> Unpin for HostFunction<Output, Args>

impl<Output, Args> !UnwindSafe for HostFunction<Output, Args>

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> CloneToUninit for T
where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)

Performs copy-assignment from self to dest. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

impl<T, U> Into<U> for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> Pointable for T

const ALIGN: usize

The alignment of pointer.

type Init = T

The type for initializers.

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more

impl<T> ToOwned for T
where T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom<U> for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

fn vzip(self) -> V

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more