Struct ImmediateClosure 

pub struct ImmediateClosure<'a, T: ?Sized> { /* private fields */ }

A closure wrapper for immediate/synchronous callbacks with unwind safety.

ImmediateClosure wraps a borrowed closure for use in synchronous JS callbacks like Array.forEach, Array.map, etc. The JS side receives the closure, calls it immediately, and discards it - no GC tracking is needed.

Panics are caught and converted to JavaScript exceptions (when built with panic=unwind). No UnwindSafe bounds are required - the closure is wrapped internally.

Unwind Safety

ImmediateClosure provides unwind safety by catching panics and converting them to JavaScript exceptions.

Example

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
extern "C" {
    fn forEach<'a>(cb: &ImmediateClosure<'a, dyn FnMut(JsValue) + 'a>);
}

let mut sum = 0;
let closure = ImmediateClosure::new_mut(&mut |val: JsValue| {
    sum += val.as_f64().unwrap() as i32;
});
forEach(&closure);
// sum is now updated

Note: To ensure borrowed lifetimes are correctly inferred, make sure to pass the lifetime to both the ImmediateClosure lifetime parameter AND its dyn FnMut parameter, as in the example above.

Implementations

impl<'a, T: ?Sized + WasmClosure> ImmediateClosure<'a, T>

pub fn new<F>(f: &'a F) -> ImmediateClosure<'a, F::WithLifetime>

where F: IntoWasmClosureRef<'a, T> + ?Sized + MaybeUnwindSafe,

Creates an immediate closure from an immutable borrow of a Fn closure.

Immutable closures (Fn) are preferred because they are more likely to satisfy UnwindSafe automatically. Use new_mut when you need to mutate captured state.

Note that immutable closures can be upcast() to mutable closures on the JS boundary when required by function signatures.

Panics are caught as JS exceptions when building with panic=unwind. The resulting closure can be upcasted to FnMut using upcast_ref.

Example

let data = vec![1, 2, 3];
let closure = ImmediateClosure::new(&|| {
    println!("data len: {}", data.len());
});
call_closure(&closure);

pub fn new_mut<F>(f: &'a mut F) -> ImmediateClosure<'a, F::WithLifetime>

where F: IntoWasmClosureRefMut<'a, T> + ?Sized + MaybeUnwindSafe,

Creates an immediate closure from a mutable borrow of a FnMut closure.

Use this for closures that need to mutate captured state. For closures that don’t need mutation, new creates an immutable Fn closure that is more likely to satisfy UnwindSafe automatically.

Panics are caught as JS exceptions when building with panic=unwind.

Example

let mut count = 0;
let closure = ImmediateClosure::new_mut(&mut || { count += 1; });
call_closure(&closure);
assert_eq!(count, 1);

impl<'a, T: ?Sized + WasmClosure> ImmediateClosure<'a, T>

pub fn wrap_aborting(f: &'a T) -> Self

Like new, but does not catch panics.

This variant enables type inference from the expected type, since it takes the dyn type directly.

Note: Not unwind safe. Prefer new or wrap_assert_unwind_safe when possible.

pub fn wrap_mut_aborting(f: &'a mut T) -> Self

Like new_mut, but does not catch panics.

This variant enables type inference from the expected type, since it takes the dyn type directly.

Note: Not unwind safe. Prefer new_mut or wrap_mut_assert_unwind_safe when possible.

pub fn wrap_assert_unwind_safe(f: &'a T) -> Self

Like wrap_aborting, but catches panics and converts them to JS exceptions.

Safety: Unwind safety is assumed when using this function, like using AssertUnwindSafe(...), this must be verified explicitly.

Example

let data = vec![1, 2, 3];
// Type is inferred from context
let closure: ImmediateClosure<dyn Fn()> = ImmediateClosure::wrap_assert_unwind_safe(&|| {
    println!("data len: {}", data.len());
});

pub fn wrap_mut_assert_unwind_safe(f: &'a mut T) -> Self

Like wrap_mut_aborting, but catches panics and converts them to JS exceptions.

Safety: Unwind safety is assumed when using this function, like using AssertUnwindSafe(...), this must be verified explicitly.

Example

let mut count = 0;
// Type of `x` is inferred from context
let closure: ImmediateClosure<dyn FnMut(u32)> = ImmediateClosure::wrap_mut_assert_unwind_safe(&mut |x| {
    count += x;
});

pub fn as_mut(&self) -> &ImmediateClosure<'a, T::AsMut>

Returns a reference to this closure as a mutable FnMut closure.

This is safe because every Fn can be called through a FnMut interface. The fat pointer representation is compatible—&dyn Fn can be safely reinterpreted as &dyn FnMut.

Note: Unlike ScopedClosure::as_mut, this only supports the Fn→FnMut conversion with the same argument and return types. ImmediateClosure stores a Rust fat pointer directly, so argument/return type variance is not possible.

Example

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
extern "C" {
    fn needs_fnmut(cb: &ImmediateClosure<dyn FnMut(u32)>);
}

let func: &dyn Fn(u32) = &|x| println!("{}", x);
let closure: ImmediateClosure<dyn Fn(u32)> = ImmediateClosure::wrap_assert_unwind_safe(func);
needs_fnmut(closure.as_mut());

Trait Implementations

impl<T: ?Sized> Debug for ImmediateClosure<'_, T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, 'b, A, R> ErasableGeneric for ImmediateClosure<'a, dyn Fn(&A) -> R + 'b>

where A: ErasableGeneric, R: ErasableGeneric,

type Repr = &'static ImmediateClosure<'static, dyn Fn(<A as ErasableGeneric>::Repr) -> <R as ErasableGeneric>::Repr>

The singular concrete type that all generic variants can be transmuted on

impl<'a, 'b, R> ErasableGeneric for ImmediateClosure<'a, dyn Fn() -> R + 'b>

where R: ErasableGeneric,

type Repr = &'static ImmediateClosure<'static, dyn Fn() -> <R as ErasableGeneric>::Repr>

The singular concrete type that all generic variants can be transmuted on

impl<'a, 'b, A, R> ErasableGeneric for ImmediateClosure<'a, dyn Fn(A) -> R + 'b>

where A: ErasableGeneric, R: ErasableGeneric,

type Repr = &'static ImmediateClosure<'static, dyn Fn(<A as ErasableGeneric>::Repr) -> <R as ErasableGeneric>::Repr>

The singular concrete type that all generic variants can be transmuted on

impl<'a, 'b, A, B, R> ErasableGeneric for ImmediateClosure<'a, dyn Fn(A, B) -> R + 'b>

where A: ErasableGeneric, B: ErasableGeneric, R: ErasableGeneric,

type Repr = &'static ImmediateClosure<'static, dyn Fn(<A as ErasableGeneric>::Repr, <B as ErasableGeneric>::Repr) -> <R as ErasableGeneric>::Repr>

The singular concrete type that all generic variants can be transmuted on

impl<'a, 'b, A, B, C, R> ErasableGeneric for ImmediateClosure<'a, dyn Fn(A, B, C) -> R + 'b>

where A: ErasableGeneric, B: ErasableGeneric, C: ErasableGeneric, R: ErasableGeneric,

type Repr = &'static ImmediateClosure<'static, dyn Fn(<A as ErasableGeneric>::Repr, <B as ErasableGeneric>::Repr, <C as ErasableGeneric>::Repr) -> <R as ErasableGeneric>::Repr>

The singular concrete type that all generic variants can be transmuted on

impl<'a, 'b, A, B, C, D, R> ErasableGeneric for ImmediateClosure<'a, dyn Fn(A, B, C, D) -> R + 'b>

where A: ErasableGeneric, B: ErasableGeneric, C: ErasableGeneric, D: ErasableGeneric, R: ErasableGeneric,

type Repr = &'static ImmediateClosure<'static, dyn Fn(<A as ErasableGeneric>::Repr, <B as ErasableGeneric>::Repr, <C as ErasableGeneric>::Repr, <D as ErasableGeneric>::Repr) -> <R as ErasableGeneric>::Repr>

The singular concrete type that all generic variants can be transmuted on

impl<'a, 'b, A, B, C, D, E, R> ErasableGeneric for ImmediateClosure<'a, dyn Fn(A, B, C, D, E) -> R + 'b>

where A: ErasableGeneric, B: ErasableGeneric, C: ErasableGeneric, D: ErasableGeneric, E: ErasableGeneric, R: ErasableGeneric,

type Repr = &'static ImmediateClosure<'static, dyn Fn(<A as ErasableGeneric>::Repr, <B as ErasableGeneric>::Repr, <C as ErasableGeneric>::Repr, <D as ErasableGeneric>::Repr, <E as ErasableGeneric>::Repr) -> <R as ErasableGeneric>::Repr>

The singular concrete type that all generic variants can be transmuted on

impl<'a, 'b, A, B, C, D, E, F, R> ErasableGeneric for ImmediateClosure<'a, dyn Fn(A, B, C, D, E, F) -> R + 'b>

where A: ErasableGeneric, B: ErasableGeneric, C: ErasableGeneric, D: ErasableGeneric, E: ErasableGeneric, F: ErasableGeneric, R: ErasableGeneric,

type Repr = &'static ImmediateClosure<'static, dyn Fn(<A as ErasableGeneric>::Repr, <B as ErasableGeneric>::Repr, <C as ErasableGeneric>::Repr, <D as ErasableGeneric>::Repr, <E as ErasableGeneric>::Repr, <F as ErasableGeneric>::Repr) -> <R as ErasableGeneric>::Repr>

The singular concrete type that all generic variants can be transmuted on

impl<'a, 'b, A, B, C, D, E, F, G, R> ErasableGeneric for ImmediateClosure<'a, dyn Fn(A, B, C, D, E, F, G) -> R + 'b>

where A: ErasableGeneric, B: ErasableGeneric, C: ErasableGeneric, D: ErasableGeneric, E: ErasableGeneric, F: ErasableGeneric, G: ErasableGeneric, R: ErasableGeneric,

type Repr = &'static ImmediateClosure<'static, dyn Fn(<A as ErasableGeneric>::Repr, <B as ErasableGeneric>::Repr, <C as ErasableGeneric>::Repr, <D as ErasableGeneric>::Repr, <E as ErasableGeneric>::Repr, <F as ErasableGeneric>::Repr, <G as ErasableGeneric>::Repr) -> <R as ErasableGeneric>::Repr>

The singular concrete type that all generic variants can be transmuted on

impl<'a, 'b, A, B, C, D, E, F, G, H, R> ErasableGeneric for ImmediateClosure<'a, dyn Fn(A, B, C, D, E, F, G, H) -> R + 'b>

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

type Repr = &'static ImmediateClosure<'static, dyn Fn(<A as ErasableGeneric>::Repr, <B as ErasableGeneric>::Repr, <C as ErasableGeneric>::Repr, <D as ErasableGeneric>::Repr, <E as ErasableGeneric>::Repr, <F as ErasableGeneric>::Repr, <G as ErasableGeneric>::Repr, <H as ErasableGeneric>::Repr) -> <R as ErasableGeneric>::Repr>

The singular concrete type that all generic variants can be transmuted on

impl<'a, 'b, A, R> ErasableGeneric for ImmediateClosure<'a, dyn FnMut(&A) -> R + 'b>

where A: ErasableGeneric, R: ErasableGeneric,

type Repr = &'static ImmediateClosure<'static, dyn FnMut(<A as ErasableGeneric>::Repr) -> <R as ErasableGeneric>::Repr>

The singular concrete type that all generic variants can be transmuted on

impl<'a, 'b, R> ErasableGeneric for ImmediateClosure<'a, dyn FnMut() -> R + 'b>

where R: ErasableGeneric,

type Repr = &'static ImmediateClosure<'static, dyn FnMut() -> <R as ErasableGeneric>::Repr>

The singular concrete type that all generic variants can be transmuted on

impl<'a, 'b, A, R> ErasableGeneric for ImmediateClosure<'a, dyn FnMut(A) -> R + 'b>

where A: ErasableGeneric, R: ErasableGeneric,

type Repr = &'static ImmediateClosure<'static, dyn FnMut(<A as ErasableGeneric>::Repr) -> <R as ErasableGeneric>::Repr>

The singular concrete type that all generic variants can be transmuted on

impl<'a, 'b, A, B, R> ErasableGeneric for ImmediateClosure<'a, dyn FnMut(A, B) -> R + 'b>

where A: ErasableGeneric, B: ErasableGeneric, R: ErasableGeneric,

type Repr = &'static ImmediateClosure<'static, dyn FnMut(<A as ErasableGeneric>::Repr, <B as ErasableGeneric>::Repr) -> <R as ErasableGeneric>::Repr>

The singular concrete type that all generic variants can be transmuted on

impl<'a, 'b, A, B, C, R> ErasableGeneric for ImmediateClosure<'a, dyn FnMut(A, B, C) -> R + 'b>

where A: ErasableGeneric, B: ErasableGeneric, C: ErasableGeneric, R: ErasableGeneric,

type Repr = &'static ImmediateClosure<'static, dyn FnMut(<A as ErasableGeneric>::Repr, <B as ErasableGeneric>::Repr, <C as ErasableGeneric>::Repr) -> <R as ErasableGeneric>::Repr>

The singular concrete type that all generic variants can be transmuted on

impl<'a, 'b, A, B, C, D, R> ErasableGeneric for ImmediateClosure<'a, dyn FnMut(A, B, C, D) -> R + 'b>

where A: ErasableGeneric, B: ErasableGeneric, C: ErasableGeneric, D: ErasableGeneric, R: ErasableGeneric,

type Repr = &'static ImmediateClosure<'static, dyn FnMut(<A as ErasableGeneric>::Repr, <B as ErasableGeneric>::Repr, <C as ErasableGeneric>::Repr, <D as ErasableGeneric>::Repr) -> <R as ErasableGeneric>::Repr>

The singular concrete type that all generic variants can be transmuted on

impl<'a, 'b, A, B, C, D, E, R> ErasableGeneric for ImmediateClosure<'a, dyn FnMut(A, B, C, D, E) -> R + 'b>

where A: ErasableGeneric, B: ErasableGeneric, C: ErasableGeneric, D: ErasableGeneric, E: ErasableGeneric, R: ErasableGeneric,

type Repr = &'static ImmediateClosure<'static, dyn FnMut(<A as ErasableGeneric>::Repr, <B as ErasableGeneric>::Repr, <C as ErasableGeneric>::Repr, <D as ErasableGeneric>::Repr, <E as ErasableGeneric>::Repr) -> <R as ErasableGeneric>::Repr>

The singular concrete type that all generic variants can be transmuted on

impl<'a, 'b, A, B, C, D, E, F, R> ErasableGeneric for ImmediateClosure<'a, dyn FnMut(A, B, C, D, E, F) -> R + 'b>

where A: ErasableGeneric, B: ErasableGeneric, C: ErasableGeneric, D: ErasableGeneric, E: ErasableGeneric, F: ErasableGeneric, R: ErasableGeneric,

type Repr = &'static ImmediateClosure<'static, dyn FnMut(<A as ErasableGeneric>::Repr, <B as ErasableGeneric>::Repr, <C as ErasableGeneric>::Repr, <D as ErasableGeneric>::Repr, <E as ErasableGeneric>::Repr, <F as ErasableGeneric>::Repr) -> <R as ErasableGeneric>::Repr>

The singular concrete type that all generic variants can be transmuted on

impl<'a, 'b, A, B, C, D, E, F, G, R> ErasableGeneric for ImmediateClosure<'a, dyn FnMut(A, B, C, D, E, F, G) -> R + 'b>

where A: ErasableGeneric, B: ErasableGeneric, C: ErasableGeneric, D: ErasableGeneric, E: ErasableGeneric, F: ErasableGeneric, G: ErasableGeneric, R: ErasableGeneric,

type Repr = &'static ImmediateClosure<'static, dyn FnMut(<A as ErasableGeneric>::Repr, <B as ErasableGeneric>::Repr, <C as ErasableGeneric>::Repr, <D as ErasableGeneric>::Repr, <E as ErasableGeneric>::Repr, <F as ErasableGeneric>::Repr, <G as ErasableGeneric>::Repr) -> <R as ErasableGeneric>::Repr>

The singular concrete type that all generic variants can be transmuted on

impl<'a, 'b, A, B, C, D, E, F, G, H, R> ErasableGeneric for ImmediateClosure<'a, dyn FnMut(A, B, C, D, E, F, G, H) -> R + 'b>

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

type Repr = &'static ImmediateClosure<'static, dyn FnMut(<A as ErasableGeneric>::Repr, <B as ErasableGeneric>::Repr, <C as ErasableGeneric>::Repr, <D as ErasableGeneric>::Repr, <E as ErasableGeneric>::Repr, <F as ErasableGeneric>::Repr, <G as ErasableGeneric>::Repr, <H as ErasableGeneric>::Repr) -> <R as ErasableGeneric>::Repr>

The singular concrete type that all generic variants can be transmuted on

impl<T> IntoWasmAbi for &ImmediateClosure<'_, T>

where T: WasmClosure + ?Sized,

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> OptionIntoWasmAbi for &ImmediateClosure<'_, T>

where T: WasmClosure + ?Sized,

fn none() -> WasmSlice

Returns an ABI instance indicating “none”, which JS will interpret as the None branch of this option.

impl<'a, 'b, T1, T2> UpcastFrom<ImmediateClosure<'a, T1>> for ImmediateClosure<'b, T2>

where T1: ?Sized + WasmClosure, T2: ?Sized + WasmClosure + UpcastFrom<T1>,