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, Ret> Callback<Args, Ret>

where Args: 'static, Ret: 'static,

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

where MaybeAsync: SpawnIfAsync<Marker, Ret>,

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) -> Callback<Args, Ret>

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) + 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) -> Callback<Args, Ret>

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<(), Error>

Formats the value using the given formatter.

impl<T, Ret> Default for Callback<T, Ret>

where T: 'static, Ret: Default + 'static,

fn default() -> Callback<T, Ret>

Returns the “default value” for a type.

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

where Args: 'static, Ret: 'static,

type Target = dyn Fn(Args) -> Ret

The resulting type after dereferencing.

fn deref(&self) -> &<Callback<Args, Ret> as Deref>::Target

Dereferences the value.

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

where Args: 'static, Ret: 'static,

fn eq(&self, _: &Callback<Args, Ret>) -> 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>