Struct Callback

pub struct Callback<Args = (), Ret = ()> { /* private fields */ }

The callback type generated by the rsx! macro when an on field is specified for components.

This makes it possible to pass move |evt| {} style closures into components as property fields.

Example

rsx! {
    MyComponent { onclick: move |evt| {
        tracing::debug!("clicked");
        42
    } }
}

#[derive(Props)]
struct MyProps {
    onclick: Callback<MouseEvent, i32>,
}

fn MyComponent(cx: MyProps) -> Element {
    rsx! {
        button {
            onclick: move |evt| println!("number: {}", cx.onclick.call(evt)),
        }
    }
}

Implementations

impl<Args: 'static, Ret: 'static> Callback<Args, Ret>

pub fn new<MaybeAsync: SpawnIfAsync<Marker, Ret>, Marker>( f: impl FnMut(Args) -> MaybeAsync + 'static, ) -> Self

Create a new Callback from an FnMut. The callback is owned by the current scope and will be dropped when the scope is dropped. This should not be called directly in the body of a component because it will not be dropped until the component is dropped.

pub fn leak(f: impl FnMut(Args) -> Ret + 'static) -> Self

Leak a new Callback that will not be dropped unless it is manually dropped.

pub fn call(&self, arguments: Args) -> Ret

Call this callback with the appropriate argument type

This borrows the callback using a RefCell. Recursively calling a callback will cause a panic.

pub fn into_closure(self) -> impl FnMut(Args) -> Ret + Copy + 'static

Create a impl FnMut + Copy closure from the Closure type

pub fn release(&self)

Forcibly drop the internal handler callback, releasing memory

This will force any future calls to “call” to not doing anything

pub fn replace(&mut self, callback: Box<dyn FnMut(Args) -> Ret>)

Replace the function in the callback with a new one

Trait Implementations

impl<Args, Ret> Clone for Callback<Args, Ret>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Args, Ret> Debug for Callback<Args, Ret>

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

Formats the value using the given formatter.

impl<T: 'static, Ret: Default + 'static> Default for Callback<T, Ret>

fn default() -> Self

Returns the “default value” for a type.

impl<Args: 'static, Ret: 'static> Deref for Callback<Args, Ret>

type Target = dyn Fn(Args) -> Ret

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<Args: 'static, Ret: 'static> PartialEq for Callback<Args, Ret>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Args, Ret> Copy for Callback<Args, Ret>