Trait dioxus_core::Properties

pub trait Properties: Sized {
    type Builder;

    const IS_STATIC: bool;

    // Required methods
    fn builder() -> Self::Builder;
    unsafe fn memoize(&self, other: &Self) -> bool;
}

Every “Props” used for a component must implement the Properties trait. This trait gives some hints to Dioxus on how to memoize the props and some additional optimizations that can be made. We strongly encourage using the derive macro to implement the Properties trait automatically as guarantee that your memoization strategy is safe.

If your props are ’static, then Dioxus will require that they also be PartialEq for the derived memoize strategy. However, if your props borrow data, then the memoization strategy will simply default to “false” and the PartialEq will be ignored. This tends to be useful when props borrow something that simply cannot be compared (IE a reference to a closure);

By default, the memoization strategy is very conservative, but can be tuned to be more aggressive manually. However, this is only safe if the props are ’static - otherwise you might borrow references after-free.

We strongly suggest that any changes to memoization be done at the “PartialEq” level for ’static props. Additionally, we advise the use of smart pointers in cases where memoization is important.

Example

For props that are ’static:

#[derive(Props, PartialEq)]
struct MyProps {
    data: String
}

For props that borrow:

#[derive(Props)]
struct MyProps<'a >{
    data: &'a str
}

Required Associated Types

type Builder

The type of the builder for this component. Used to create “in-progress” versions of the props.

Required Associated Constants

const IS_STATIC: bool

An indication if these props are can be memoized automatically.

Required Methods

fn builder() -> Self::Builder

Create a builder for this component.

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

Memoization can only happen if the props are valid for the ’static lifetime

Safety

The user must know if their props are static, but if they make a mistake, UB happens Therefore it’s unsafe to memoize.

Implementations on Foreign Types

impl Properties for ()

type Builder = EmptyBuilder

const IS_STATIC: bool = true

fn builder() -> Self::Builder

unsafe fn memoize(&self, _other: &Self) -> bool

Implementors