Struct leptos::MaybeProp

pub struct MaybeProp<T>(/* private fields */)
where
    T: 'static;

A wrapping type for an optional component prop, which can either be a signal or a non-reactive value, and which may or may not have a value. In other words, this is an Option<MaybeSignal<Option<T>>> that automatically flattens its getters.

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

Core Trait Implementations

• .get() (or calling the signal as a function) clones the current value of the signal. If you call it within an effect, it will cause that effect to subscribe to the signal, and to re-run whenever the value of the signal changes.
  • .get_untracked() clones the value of the signal without reactively tracking it.
• .with() allows you to reactively access the signal’s value without cloning by applying a callback function.
  • .with_untracked() allows you to access the signal’s value without reactively tracking it.
• .to_stream() converts the signal to an async stream of values.

Examples

let (count, set_count) = create_signal(Some(2));
let double = |n| n * 2;
let double_count = MaybeProp::derive(move || count.get().map(double));
let memoized_double_count = create_memo(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>

Examples

let (name, set_name) = create_signal("Alice".to_string());
let (maybe_name, set_maybe_name) = create_signal(None);
let name_upper =
    MaybeProp::derive(move || Some(name.with(|n| n.to_uppercase())));
let memoized_lower = create_memo(move |_| name.with(|n| n.to_lowercase()));
let static_value: MaybeProp<String> = "Bob".to_string().into();

// this function takes any kind of wrapped signal
fn current_len_inefficient(arg: &MaybeProp<String>) -> usize {
    // ❌ unnecessarily clones the string
    arg.get().map(|n| n.len()).unwrap_or(0)
}

fn current_len(arg: &MaybeProp<String>) -> usize {
    // ✅ gets the length without cloning the `String`
    arg.with(|value| value.len()).unwrap_or(0)
}

assert_eq!(current_len(&None::<String>.into()), 0);
assert_eq!(current_len(&maybe_name.into()), 0);
assert_eq!(current_len(&name_upper), 5);
assert_eq!(current_len(&memoized_lower.into()), 5);
assert_eq!(current_len(&static_value), 3);

// Normal signals/memos return T
assert_eq!(name.get(), "Alice".to_string());
assert_eq!(memoized_lower.get(), "alice".to_string());

// MaybeProp::get() returns Option<T>
assert_eq!(name_upper.get(), Some("ALICE".to_string()));
assert_eq!(static_value.get(), Some("Bob".to_string()));

pub fn with<O>(&self, f: impl FnOnce(&T) -> O) -> Option<O>

Applies a function to the current value, returning the result.

pub fn try_with<O>(&self, f: impl FnOnce(&T) -> O) -> Option<O>

Applies a function to the current value, returning the result. Returns None if the value has already been disposed.

pub fn with_untracked<O>(&self, f: impl FnOnce(&T) -> O) -> Option<O>

Applies a function to the current value, returning the result, without causing the current reactive scope to track changes.

pub fn try_with_untracked<O>(&self, f: impl FnOnce(&T) -> O) -> Option<O>

Applies a function to the current value, returning the result, without causing the current reactive scope to track changes. Returns None if the value has already been disposed.

impl<T> MaybeProp<T>

where T: 'static,

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

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

let (count, set_count) = create_signal(2);
let double_count = MaybeProp::derive(move || Some(count.get() * 2));

// this function takes any kind of wrapped signal
fn above_3(arg: &MaybeProp<i32>) -> bool {
    arg.get().unwrap_or(0) > 3
}

assert_eq!(above_3(&count.into()), false);
assert_eq!(above_3(&double_count.into()), true);
assert_eq!(above_3(&2.into()), false);

Trait Implementations

impl<T> Clone for MaybeProp<T>

where T: Clone + 'static,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for MaybeProp<T>

where T: Debug + 'static,

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

Formats the value using the given formatter.

impl<T> Default for MaybeProp<T>

fn default() -> MaybeProp<T>

Returns the “default value” for a type.

impl From<&str> for MaybeProp<String>

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

Converts to this type from the input type.

impl From<&'static str> for MaybeProp<TextProp>

fn from(s: &'static str) -> MaybeProp<TextProp>

Converts to this type from the input type.

impl From<Box<str>> for MaybeProp<TextProp>

fn from(s: Box<str>) -> MaybeProp<TextProp>

Converts to this type from the input type.

impl From<Cow<'static, str>> for MaybeProp<TextProp>

fn from(s: Cow<'static, str>) -> MaybeProp<TextProp>

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

where T: Clone,

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

Converts to this type from the input type.

impl<T> From<Option<MaybeSignal<Option<T>>>> for MaybeProp<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>

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

Converts to this type from the input type.

impl From<Rc<str>> for MaybeProp<TextProp>

fn from(s: Rc<str>) -> MaybeProp<TextProp>

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

where T: Clone,

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

where T: Clone,

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

where T: Clone,

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

Converts to this type from the input type.

impl From<String> for MaybeProp<TextProp>

fn from(s: String) -> MaybeProp<TextProp>

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<T> IntoAttribute for MaybeProp<T>

where T: IntoAttribute + Clone,

fn into_attribute(self) -> Attribute

Converts the object into an Attribute.

fn into_attribute_boxed(self: Box<MaybeProp<T>>) -> Attribute

Helper function for dealing with Box<dyn IntoAttribute>.

impl IntoClass for MaybeProp<bool>

fn into_class(self) -> Class

Converts the object into a Class.

fn into_class_boxed(self: Box<MaybeProp<bool>>) -> Class

Helper function for dealing with Box<dyn IntoClass>.

impl<T> IntoProperty for MaybeProp<T>

where T: Clone, Option<T>: Into<JsValue>,

fn into_property(self) -> Property

Converts the object into a Property.

fn into_property_boxed(self: Box<MaybeProp<T>>) -> Property

Helper function for dealing with Box<dyn IntoProperty>.

impl<T> IntoStyle for MaybeProp<T>

where T: Clone, Option<T>: IntoStyle,

fn into_style(self) -> Style

Converts the object into a Style.

fn into_style_boxed(self: Box<MaybeProp<T>>) -> Style

Helper function for dealing with Box<dyn IntoStyle>.

impl<T> IntoView for MaybeProp<T>

where T: IntoView + Clone,

fn into_view(self) -> View

Converts the value into View.

impl<T> PartialEq for MaybeProp<T>

where T: PartialEq + 'static,

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T> Serialize for MaybeProp<T>

where T: Serialize,

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> SignalGet for MaybeProp<T>

where T: Clone,

Examples

let (count, set_count) = create_signal(Some(2));
let double = |n| n * 2;
let double_count = MaybeProp::derive(move || count.get().map(double));
let memoized_double_count = create_memo(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);

type Value = Option<T>

The value held by the signal.

fn get(&self) -> Option<T>

Clones and returns the current value of the signal, and subscribes the running effect to this signal.

fn try_get(&self) -> Option<Option<T>>

Clones and returns the signal value, returning Some if the signal is still alive, and None otherwise.

impl<T> SignalGetUntracked for MaybeProp<T>

where T: Clone,

type Value = Option<T>

The value held by the signal.

fn get_untracked(&self) -> Option<T>

Gets the signal’s value without creating a dependency on the current scope.

fn try_get_untracked(&self) -> Option<Option<T>>

Gets the signal’s value without creating a dependency on the current scope. Returns [Some(T)] if the signal is still valid, None otherwise.

impl<T> SignalStream<Option<T>> for MaybeProp<T>

where T: Clone,

fn to_stream(&self) -> Pin<Box<dyn Stream<Item = Option<T>>>>

Generates a Stream that emits the new value of the signal whenever it changes.

impl<T> Copy for MaybeProp<T>

where T: Copy,

impl<T> Eq for MaybeProp<T>

where T: Eq + 'static,

impl<T> StructuralPartialEq for MaybeProp<T>

where T: 'static,