Struct MaybeProp 

pub struct MaybeProp<T, S = SyncStorage>(/* private fields */)
where
    T: 'static,
    S: Storage<Option<T>> + Storage<SignalTypes<Option<T>, S>>;

A wrapping type for an optional component prop.

This can either be a signal or a non-reactive value, and may or may not have a value. In other words, this is an Option<Signal<Option<T>>>, but automatically flattens its getters.

This creates an extremely flexible type for component libraries, etc.

Examples

let (count, set_count) = signal(Some(2));
let double = |n| n * 2;
let double_count = MaybeProp::derive(move || count.get().map(double));
let memoized_double_count = Memo::new(move |_| count.get().map(double));
let static_value = 5;

// this function takes either a reactive or non-reactive value
fn above_3(arg: &MaybeProp<i32>) -> bool {
    // ✅ calling the signal clones and returns the value
    //    it is a shorthand for arg.get()q
    arg.get().map(|arg| arg > 3).unwrap_or(false)
}

assert_eq!(above_3(&None::<i32>.into()), false);
assert_eq!(above_3(&static_value.into()), true);
assert_eq!(above_3(&count.into()), false);
assert_eq!(above_3(&double_count), true);
assert_eq!(above_3(&memoized_double_count.into()), true);

Implementations

impl<T> MaybeProp<T>

where T: Send + Sync,

pub fn derive( derived_signal: impl Fn() -> Option<T> + Send + Sync + 'static, ) -> MaybeProp<T>

Wraps a derived signal, i.e., any computation that accesses one or more reactive signals.

impl<T> MaybeProp<T, LocalStorage>

pub fn derive_local( derived_signal: impl Fn() -> Option<T> + 'static, ) -> MaybeProp<T, LocalStorage>

Wraps a derived signal, i.e., any computation that accesses one or more reactive signals.

Trait Implementations

impl<V, S> AddAnyAttr for MaybeProp<V, S>

where Option<V>: RenderHtml + Clone + Send + Sync + 'static, <Option<V> as Render>::State: 'static, MaybeProp<V, S>: Get<Value = Option<V>>, S: Storage<Option<V>> + Storage<SignalTypes<Option<V>, S>> + Send + Sync + 'static,

type Output<SomeNewAttr: Attribute> = MaybeProp<V, S>

The new type once the attribute has been added.

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <MaybeProp<V, S> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

Adds an attribute to the view.

impl<V, S> AttributeValue for MaybeProp<V, S>

where Option<V>: AttributeValue + Send + Sync + Clone + 'static, <Option<V> as AttributeValue>::State: 'static, MaybeProp<V, S>: Get<Value = Option<V>>, S: Storage<Option<V>> + Storage<SignalTypes<Option<V>, S>> + Send + Sync + 'static,

type AsyncOutput = MaybeProp<V, S>

The type once all async data have loaded.

type State = RenderEffect<<Option<V> as AttributeValue>::State>

The state that should be retained between building and rebuilding.

type Cloneable = MaybeProp<V, S>

A version of the value that can be cloned. This can be the same type, or a reference-counted type. Generally speaking, this does not need to refer to the same data, but should behave in the same way. So for example, making an event handler cloneable should probably make it reference-counted (so that a FnMut() continues mutating the same closure), but making a String cloneable does not necessarily need to make it an Arc<str>, as two different clones of a String will still have the same value.

type CloneableOwned = MaybeProp<V, S>

A cloneable type that is also 'static. This is used for spreading across types when the spreadable attribute needs to be owned. In some cases (&'a str to Arc<str>, etc.) the owned cloneable type has worse performance than the cloneable type, so they are separate.

fn html_len(&self) -> usize

An approximation of the actual length of this attribute in HTML.

fn to_html(self, key: &str, buf: &mut String)

Renders the attribute value to HTML.

fn to_template(_key: &str, _buf: &mut String)

Renders the attribute value to HTML for a <template>.

fn hydrate<const FROM_SERVER: bool>( self, key: &str, el: &Element, ) -> <MaybeProp<V, S> as AttributeValue>::State

Adds interactivity as necessary, given DOM nodes that were created from HTML that has either been rendered on the server, or cloned for a <template>.

fn build( self, el: &Element, key: &str, ) -> <MaybeProp<V, S> as AttributeValue>::State

Adds this attribute to the element during client-side rendering.

fn rebuild( self, key: &str, state: &mut <MaybeProp<V, S> as AttributeValue>::State, )

Applies a new value for the attribute.

fn into_cloneable(self) -> <MaybeProp<V, S> as AttributeValue>::Cloneable

Converts this attribute into an equivalent that can be cloned.

fn into_cloneable_owned( self, ) -> <MaybeProp<V, S> as AttributeValue>::CloneableOwned

Converts this attributes into an equivalent that can be cloned and is 'static.

fn dry_resolve(&mut self)

“Runs” the attribute without other side effects. For primitive types, this is a no-op. For reactive types, this can be used to gather data about reactivity or about asynchronous data that needs to be loaded.

async fn resolve(self) -> <MaybeProp<V, S> as AttributeValue>::AsyncOutput

“Resolves” this into a form that is not waiting for any asynchronous data.

impl<T, S> Clone for MaybeProp<T, S>

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

fn clone(&self) -> MaybeProp<T, S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, S> Copy for MaybeProp<T, S>

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

impl<T, S> Debug for MaybeProp<T, S>

where T: Debug + 'static, S: Debug + Storage<Option<T>> + Storage<SignalTypes<Option<T>, S>>,

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

Formats the value using the given formatter.

impl<T, S> Default for MaybeProp<T, S>

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

fn default() -> MaybeProp<T, S>

Returns the “default value” for a type.

impl<T, S> DefinedAt for MaybeProp<T, S>

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

fn defined_at(&self) -> Option<&'static Location<'static>>

Returns the location at which the signal was defined. This is usually simply None in release mode.

impl<T, S> Eq for MaybeProp<T, S>

where T: Eq + 'static, S: Eq + Storage<Option<T>> + Storage<SignalTypes<Option<T>, S>>,

impl From<&str> for MaybeProp<String>

fn from(value: &str) -> MaybeProp<String>

Converts to this type from the input type.

impl From<&str> for MaybeProp<String, LocalStorage>

fn from(value: &str) -> MaybeProp<String, LocalStorage>

Converts to this type from the input type.

impl<T> From<MaybeProp<T, LocalStorage>> for Option<Signal<Option<T>, LocalStorage>>

where T: Send + Sync + 'static,

fn from( value: MaybeProp<T, LocalStorage>, ) -> Option<Signal<Option<T>, LocalStorage>>

Converts to this type from the input type.

impl<T> From<MaybeProp<T>> for Option<Signal<Option<T>>>

where T: Send + Sync + 'static,

fn from(value: MaybeProp<T>) -> Option<Signal<Option<T>>>

Converts to this type from the input type.

impl<T> From<MaybeSignal<Option<T>, LocalStorage>> for MaybeProp<T, LocalStorage>

where T: Send + Sync,

fn from( value: MaybeSignal<Option<T>, LocalStorage>, ) -> MaybeProp<T, LocalStorage>

Converts to this type from the input type.

impl<T> From<MaybeSignal<Option<T>>> for MaybeProp<T>

where T: Send + Sync, SyncStorage: Storage<Option<T>>,

fn from(value: MaybeSignal<Option<T>>) -> MaybeProp<T>

Converts to this type from the input type.

impl<T> From<Memo<Option<T>, LocalStorage>> for MaybeProp<T, LocalStorage>

where T: Send + Sync,

fn from(value: Memo<Option<T>, LocalStorage>) -> MaybeProp<T, LocalStorage>

Converts to this type from the input type.

impl<T> From<Memo<Option<T>>> for MaybeProp<T>

where T: Send + Sync,

fn from(value: Memo<Option<T>>) -> MaybeProp<T>

Converts to this type from the input type.

impl<T> From<Memo<T, LocalStorage>> for MaybeProp<T, LocalStorage>

where T: Send + Sync + Clone,

fn from(value: Memo<T, LocalStorage>) -> MaybeProp<T, LocalStorage>

Converts to this type from the input type.

impl<T> From<Memo<T>> for MaybeProp<T>

where T: Send + Sync + Clone,

fn from(value: Memo<T>) -> MaybeProp<T>

Converts to this type from the input type.

impl<T> From<Option<MaybeSignal<Option<T>, LocalStorage>>> for MaybeProp<T, LocalStorage>

where T: Send + Sync,

fn from( value: Option<MaybeSignal<Option<T>, LocalStorage>>, ) -> MaybeProp<T, LocalStorage>

Converts to this type from the input type.

impl<T> From<Option<MaybeSignal<Option<T>>>> for MaybeProp<T>

where T: Send + Sync, SyncStorage: Storage<Option<T>>,

fn from(value: Option<MaybeSignal<Option<T>>>) -> MaybeProp<T>

Converts to this type from the input type.

impl<T> From<Option<T>> for MaybeProp<T>

where T: Send + Sync, SyncStorage: Storage<Option<T>>,

fn from(value: Option<T>) -> MaybeProp<T>

Converts to this type from the input type.

impl<T> From<ReadSignal<Option<T>, LocalStorage>> for MaybeProp<T, LocalStorage>

where T: Send + Sync,

fn from( value: ReadSignal<Option<T>, LocalStorage>, ) -> MaybeProp<T, LocalStorage>

Converts to this type from the input type.

impl<T> From<ReadSignal<Option<T>>> for MaybeProp<T>

where T: Send + Sync,

fn from(value: ReadSignal<Option<T>>) -> MaybeProp<T>

Converts to this type from the input type.

impl<T> From<ReadSignal<T, LocalStorage>> for MaybeProp<T, LocalStorage>

where T: Send + Sync + Clone,

fn from(value: ReadSignal<T, LocalStorage>) -> MaybeProp<T, LocalStorage>

Converts to this type from the input type.

impl<T> From<ReadSignal<T>> for MaybeProp<T>

where T: Send + Sync + Clone,

fn from(value: ReadSignal<T>) -> MaybeProp<T>

Converts to this type from the input type.

impl<T> From<RwSignal<Option<T>, LocalStorage>> for MaybeProp<T, LocalStorage>

where T: Send + Sync,

fn from(value: RwSignal<Option<T>, LocalStorage>) -> MaybeProp<T, LocalStorage>

Converts to this type from the input type.

impl<T> From<RwSignal<Option<T>>> for MaybeProp<T>

where T: Send + Sync,

fn from(value: RwSignal<Option<T>>) -> MaybeProp<T>

Converts to this type from the input type.

impl<T> From<RwSignal<T, LocalStorage>> for MaybeProp<T, LocalStorage>

where T: Send + Sync + Clone,

fn from(value: RwSignal<T, LocalStorage>) -> MaybeProp<T, LocalStorage>

Converts to this type from the input type.

impl<T> From<RwSignal<T>> for MaybeProp<T>

where T: Send + Sync + Clone,

fn from(value: RwSignal<T>) -> MaybeProp<T>

Converts to this type from the input type.

impl<T> From<Signal<Option<T>, LocalStorage>> for MaybeProp<T, LocalStorage>

fn from(value: Signal<Option<T>, LocalStorage>) -> MaybeProp<T, LocalStorage>

Converts to this type from the input type.

impl<T> From<Signal<Option<T>>> for MaybeProp<T>

where T: Send + Sync, SyncStorage: Storage<Option<T>>,

fn from(value: Signal<Option<T>>) -> MaybeProp<T>

Converts to this type from the input type.

impl<T> From<Signal<T, LocalStorage>> for MaybeProp<T, LocalStorage>

where T: Send + Sync + Clone,

fn from(value: Signal<T, LocalStorage>) -> MaybeProp<T, LocalStorage>

Converts to this type from the input type.

impl<T> From<Signal<T>> for MaybeProp<T>

where T: Send + Sync + Clone,

fn from(value: Signal<T>) -> MaybeProp<T>

Converts to this type from the input type.

impl<T> From<T> for MaybeProp<T>

where T: Send + Sync, SyncStorage: Storage<Option<T>>,

fn from(value: T) -> MaybeProp<T>

Converts to this type from the input type.

impl<T> FromLocal<Option<T>> for MaybeProp<T, LocalStorage>

fn from_local(value: Option<T>) -> MaybeProp<T, LocalStorage>

Converts between the types.

impl<T> FromLocal<T> for MaybeProp<T, LocalStorage>

fn from_local(value: T) -> MaybeProp<T, LocalStorage>

Converts between the types.

impl<T, S> PartialEq for MaybeProp<T, S>

where T: PartialEq + 'static, S: PartialEq + Storage<Option<T>> + Storage<SignalTypes<Option<T>, S>>,

fn eq(&self, other: &MaybeProp<T, S>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T, S> ReadUntracked for MaybeProp<T, S>

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

type Value = ReadGuard<Option<T>, SignalReadGuard<Option<T>, S>>

The guard type that will be returned, which can be dereferenced to the value.

fn try_read_untracked( &self, ) -> Option<<MaybeProp<T, S> as ReadUntracked>::Value>

Returns the guard, or None if the signal has already been disposed.

fn custom_try_read( &self, ) -> Option<Option<<MaybeProp<T, S> as ReadUntracked>::Value>>

This is a backdoor to allow overriding the Read::try_read implementation despite it being auto implemented.

fn read_untracked(&self) -> Self::Value

Returns the guard.

impl<V, S> Render for MaybeProp<V, S>

where Option<V>: Render + Clone + Send + Sync + 'static, <Option<V> as Render>::State: 'static, MaybeProp<V, S>: Get<Value = Option<V>>, S: Storage<Option<V>> + Storage<SignalTypes<Option<V>, S>> + Send + Sync + 'static,

type State = RenderEffectState<<Option<V> as Render>::State>

The “view state” for this type, which can be retained between updates.

fn build(self) -> <MaybeProp<V, S> as Render>::State

Creates the view for the first time, without hydrating from existing HTML.

fn rebuild(self, state: &mut <MaybeProp<V, S> as Render>::State)

Updates the view with new data.

impl<V, S> RenderHtml for MaybeProp<V, S>

where Option<V>: RenderHtml + Clone + Send + Sync + 'static, <Option<V> as Render>::State: 'static, MaybeProp<V, S>: Get<Value = Option<V>>, S: Storage<Option<V>> + Storage<SignalTypes<Option<V>, S>> + Send + Sync + 'static,

const MIN_LENGTH: usize = 0

The minimum length of HTML created when this view is rendered.

type AsyncOutput = MaybeProp<V, S>

The type of the view after waiting for all asynchronous data to load.

type Owned = MaybeProp<V, S>

An equivalent value that is 'static.

fn dry_resolve(&mut self)

“Runs” the view without other side effects. For primitive types, this is a no-op. For reactive types, this can be used to gather data about reactivity or about asynchronous data that needs to be loaded.

async fn resolve(self) -> <MaybeProp<V, S> as RenderHtml>::AsyncOutput

Waits for any asynchronous sections of the view to load and returns the output.

fn html_len(&self) -> usize

An estimated length for this view, when rendered to HTML.

fn to_html_with_buf( self, buf: &mut String, position: &mut Position, escape: bool, mark_branches: bool, extra_attrs: Vec<AnyAttribute>, )

Renders a view to HTML, writing it into the given buffer.

fn to_html_async_with_buf<const OUT_OF_ORDER: bool>( self, buf: &mut StreamBuilder, position: &mut Position, escape: bool, mark_branches: bool, extra_attrs: Vec<AnyAttribute>, )

where MaybeProp<V, S>: Sized,

Renders a view into a buffer of (synchronous or asynchronous) HTML chunks.

fn hydrate<const FROM_SERVER: bool>( self, cursor: &Cursor, position: &PositionState, ) -> <MaybeProp<V, S> as Render>::State

Makes a set of DOM nodes rendered from HTML interactive.

fn into_owned(self) -> <MaybeProp<V, S> as RenderHtml>::Owned

Convert into the equivalent value that is 'static.

const EXISTS: bool = true

Whether this should actually exist in the DOM, if it is the child of an element.

fn to_html(self) -> String

where Self: Sized,

Renders a view to an HTML string.

fn to_html_branching(self) -> String

where Self: Sized,

Renders a view to HTML with branch markers. This can be used to support libraries that diff HTML pages against one another, by marking sections of the view that branch to different types with marker comments.

fn to_html_stream_in_order(self) -> StreamBuilder

where Self: Sized,

Renders a view to an in-order stream of HTML.

fn to_html_stream_in_order_branching(self) -> StreamBuilder

where Self: Sized,

Renders a view to an in-order stream of HTML with branch markers. This can be used to support libraries that diff HTML pages against one another, by marking sections of the view that branch to different types with marker comments.

fn to_html_stream_out_of_order(self) -> StreamBuilder

where Self: Sized,

Renders a view to an out-of-order stream of HTML.

fn to_html_stream_out_of_order_branching(self) -> StreamBuilder

where Self: Sized,

Renders a view to an out-of-order stream of HTML with branch markers. This can be used to support libraries that diff HTML pages against one another, by marking sections of the view that branch to different types with marker comments.

fn hydrate_async( self, cursor: &Cursor, position: &PositionState, ) -> impl Future<Output = Self::State>

Asynchronously makes a set of DOM nodes rendered from HTML interactive.

fn hydrate_from<const FROM_SERVER: bool>(self, el: &Element) -> Self::State

where Self: Sized,

Hydrates using RenderHtml::hydrate, beginning at the given element.

fn hydrate_from_position<const FROM_SERVER: bool>( self, el: &Element, position: Position, ) -> Self::State

where Self: Sized,

Hydrates using RenderHtml::hydrate, beginning at the given element and position.

impl<T, St> Serialize for MaybeProp<T, St>

where T: Send + Sync + Serialize, St: Storage<SignalTypes<Option<T>, St>> + Storage<Option<T>>,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T, S> StructuralPartialEq for MaybeProp<T, S>

where T: PartialEq + 'static, S: PartialEq + Storage<Option<T>> + Storage<SignalTypes<Option<T>, S>>,

impl<T, S> Track for MaybeProp<T, S>

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

fn track(&self)

Subscribes to this signal in the current reactive scope without doing anything with its value.