Trait Fn

pub trait Fn<Args>: FnMut<Args>
where
    Args: Tuple,
{
    // Required method
    extern "rust-call" fn call(&self, args: Args) -> Self::Output;
}

The version of the call operator that takes an immutable receiver.

Instances of Fn can be called repeatedly without mutating state.

This trait (Fn) is not to be confused with function pointers (fn).

Fn is implemented automatically by closures which only take immutable references to captured variables or don’t capture anything at all, as well as (safe) function pointers (with some caveats, see their documentation for more details). Additionally, for any type F that implements Fn, &F implements Fn, too.

Since both FnMut and FnOnce are supertraits of Fn, any instance of Fn can be used as a parameter where a FnMut or FnOnce is expected.

Use Fn as a bound when you want to accept a parameter of function-like type and need to call it repeatedly and without mutating state (e.g., when calling it concurrently). If you do not need such strict requirements, use FnMut or FnOnce as bounds.

See the chapter on closures in The Rust Programming Language for some more information on this topic.

Also of note is the special syntax for Fn traits (e.g. Fn(usize, bool) -> usize). Those interested in the technical details of this can refer to the relevant section in the Rustonomicon.

Examples

Calling a closure

let square = |x| x * x;
assert_eq!(square(5), 25);

Using a Fn parameter

fn call_with_one<F>(func: F) -> usize
    where F: Fn(usize) -> usize {
    func(1)
}

let double = |x| x * 2;
assert_eq!(call_with_one(double), 2);

Required Methods

extern "rust-call" fn call(&self, args: Args) -> Self::Output

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

Performs the call operation.

Trait Implementations

impl<A, R> IntoWasmAbi for &dyn Fn(&A) -> R

where A: RefFromWasmAbi, R: ReturnWasmAbi,

type Abi = WasmSlice

The Wasm ABI type that this converts into when crossing the ABI boundary.

fn into_abi(self) -> WasmSlice

Convert self into Self::Abi so that it can be sent across the wasm ABI boundary.

impl<R> IntoWasmAbi for &dyn Fn() -> R

where R: ReturnWasmAbi,

type Abi = WasmSlice

The Wasm ABI type that this converts into when crossing the ABI boundary.

fn into_abi(self) -> WasmSlice

Convert self into Self::Abi so that it can be sent across the wasm ABI boundary.

impl<A, R> IntoWasmAbi for &dyn Fn(A) -> R

where A: FromWasmAbi, R: ReturnWasmAbi,

type Abi = WasmSlice

The Wasm ABI type that this converts into when crossing the ABI boundary.

fn into_abi(self) -> WasmSlice

Convert self into Self::Abi so that it can be sent across the wasm ABI boundary.

impl<A, B, R> IntoWasmAbi for &dyn Fn(A, B) -> R

where A: FromWasmAbi, B: FromWasmAbi, R: ReturnWasmAbi,

type Abi = WasmSlice

The Wasm ABI type that this converts into when crossing the ABI boundary.

fn into_abi(self) -> WasmSlice

Convert self into Self::Abi so that it can be sent across the wasm ABI boundary.

impl<A, B, C, R> IntoWasmAbi for &dyn Fn(A, B, C) -> R

where A: FromWasmAbi, B: FromWasmAbi, C: FromWasmAbi, R: ReturnWasmAbi,

type Abi = WasmSlice

The Wasm ABI type that this converts into when crossing the ABI boundary.

fn into_abi(self) -> WasmSlice

Convert self into Self::Abi so that it can be sent across the wasm ABI boundary.

impl<A, B, C, D, R> IntoWasmAbi for &dyn Fn(A, B, C, D) -> R

where A: FromWasmAbi, B: FromWasmAbi, C: FromWasmAbi, D: FromWasmAbi, R: ReturnWasmAbi,

type Abi = WasmSlice

The Wasm ABI type that this converts into when crossing the ABI boundary.

fn into_abi(self) -> WasmSlice

Convert self into Self::Abi so that it can be sent across the wasm ABI boundary.

impl<A, B, C, D, E, R> IntoWasmAbi for &dyn Fn(A, B, C, D, E) -> R

where A: FromWasmAbi, B: FromWasmAbi, C: FromWasmAbi, D: FromWasmAbi, E: FromWasmAbi, R: ReturnWasmAbi,

type Abi = WasmSlice

The Wasm ABI type that this converts into when crossing the ABI boundary.

fn into_abi(self) -> WasmSlice

Convert self into Self::Abi so that it can be sent across the wasm ABI boundary.

impl<A, B, C, D, E, F, R> IntoWasmAbi for &dyn Fn(A, B, C, D, E, F) -> R

where A: FromWasmAbi, B: FromWasmAbi, C: FromWasmAbi, D: FromWasmAbi, E: FromWasmAbi, F: FromWasmAbi, R: ReturnWasmAbi,

type Abi = WasmSlice

The Wasm ABI type that this converts into when crossing the ABI boundary.

fn into_abi(self) -> WasmSlice

Convert self into Self::Abi so that it can be sent across the wasm ABI boundary.

impl<A, B, C, D, E, F, G, R> IntoWasmAbi for &dyn Fn(A, B, C, D, E, F, G) -> R

where A: FromWasmAbi, B: FromWasmAbi, C: FromWasmAbi, D: FromWasmAbi, E: FromWasmAbi, F: FromWasmAbi, G: FromWasmAbi, R: ReturnWasmAbi,

type Abi = WasmSlice

The Wasm ABI type that this converts into when crossing the ABI boundary.

fn into_abi(self) -> WasmSlice

Convert self into Self::Abi so that it can be sent across the wasm ABI boundary.

impl<A, B, C, D, E, F, G, H, R> IntoWasmAbi for &dyn Fn(A, B, C, D, E, F, G, H) -> R

where A: FromWasmAbi, B: FromWasmAbi, C: FromWasmAbi, D: FromWasmAbi, E: FromWasmAbi, F: FromWasmAbi, G: FromWasmAbi, H: FromWasmAbi, R: ReturnWasmAbi,

type Abi = WasmSlice

The Wasm ABI type that this converts into when crossing the ABI boundary.

fn into_abi(self) -> WasmSlice

Convert self into Self::Abi so that it can be sent across the wasm ABI boundary.

impl<T> ToChildren<ChildrenOptContainer<T>> for Box<dyn Fn() -> AnyView + Send>

where T: IntoAny + Clone + Send + 'static,

fn to_children(t: ChildrenOptContainer<T>) -> Box<dyn Fn() -> AnyView + Send>

Convert the provided type (generally a closure) to Self (generally a “children” type, e.g., Children). See the implementations to see exactly which input types are supported and which “children” type they are converted to.

impl<F, C> ToChildren<F> for Box<dyn Fn() -> AnyView + Send>

where F: Fn() -> C + Send + 'static, C: RenderHtml + Send + 'static,

fn to_children(f: F) -> Box<dyn Fn() -> AnyView + Send>

Convert the provided type (generally a closure) to Self (generally a “children” type, e.g., Children). See the implementations to see exactly which input types are supported and which “children” type they are converted to.

Implementors

impl<A, F> Fn<A> for &F

where A: Tuple, F: Fn<A> + ?Sized,

impl<Args, F, A> Fn<Args> for Box<F, A>

where Args: Tuple, F: Fn<Args> + ?Sized, A: Allocator,

impl<T> Fn() for ArcReadSignal<T>

where ArcReadSignal<T>: Get,

impl<T> Fn() for ArcRwSignal<T>

where ArcRwSignal<T>: Get,

impl<T> Fn(T) for ArcRwSignal<T>

where ArcRwSignal<T>: Set<Value = T>,

impl<T> Fn(T) for ArcWriteSignal<T>

where ArcWriteSignal<T>: Set<Value = T>,

impl<T, S> Fn() for MaybeSignal<T, S>

where MaybeSignal<T, S>: Get, S: Storage<T> + Storage<Option<T>> + Storage<SignalTypes<Option<T>, S>>,

impl<T, S> Fn() for ArcMemo<T, S>

where ArcMemo<T, S>: Get, S: Storage<T> + Storage<Option<T>> + Storage<SignalTypes<Option<T>, S>>,

impl<T, S> Fn() for ArcSignal<T, S>

where ArcSignal<T, S>: Get, S: Storage<T> + Storage<Option<T>> + Storage<SignalTypes<Option<T>, S>>,

impl<T, S> Fn() for MaybeProp<T, S>

where MaybeProp<T, S>: Get, S: Storage<T> + Storage<Option<T>> + Storage<SignalTypes<Option<T>, S>>,

impl<T, S> Fn() for Memo<T, S>

where Memo<T, S>: Get, S: Storage<T> + Storage<Option<T>> + Storage<SignalTypes<Option<T>, S>>,

impl<T, S> Fn() for ReadSignal<T, S>

where ReadSignal<T, S>: Get, S: Storage<T> + Storage<Option<T>> + Storage<SignalTypes<Option<T>, S>>,

impl<T, S> Fn() for RwSignal<T, S>

where RwSignal<T, S>: Get, S: Storage<T> + Storage<Option<T>> + Storage<SignalTypes<Option<T>, S>>,

impl<T, S> Fn() for Signal<T, S>

where Signal<T, S>: Get, S: Storage<T> + Storage<Option<T>> + Storage<SignalTypes<Option<T>, S>>,

impl<T, S> Fn(T) for RwSignal<T, S>

where RwSignal<T, S>: Set<Value = T>,

impl<T, S> Fn(T) for SignalSetter<T, S>

where SignalSetter<T, S>: Set<Value = T>,

impl<T, S> Fn(T) for WriteSignal<T, S>

where WriteSignal<T, S>: Set<Value = T>,