Enum MaybeSignal 

pub enum MaybeSignal<T, S = SyncStorage>
where
    T: 'static,
    S: Storage<T>,
{
    Static(T),
    Dynamic(Signal<T, S>),
}

👎Deprecated since 0.7.0-rc3: MaybeSignal<T> is deprecated in favour of Signal<T> which is Copy, now has a more efficient From<T> implementation and other benefits in 0.7.

A wrapper for a value that is either T or Signal<T>.

This allows you to create APIs that take either a reactive or a non-reactive value of the same type. This is especially useful for component properties.

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

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

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);

Variants

Static(T)

👎Deprecated since 0.7.0-rc3: MaybeSignal<T> is deprecated in favour of Signal<T> which is Copy, now has a more efficient From<T> implementation and other benefits in 0.7.

An unchanging value of type T.

Dynamic(Signal<T, S>)

👎Deprecated since 0.7.0-rc3: MaybeSignal<T> is deprecated in favour of Signal<T> which is Copy, now has a more efficient From<T> implementation and other benefits in 0.7.

A reactive signal that contains a value of type T.

Implementations

impl<T> MaybeSignal<T>

where T: Send + Sync,

pub fn derive(derived_signal: impl Fn() -> T + Send + Sync + 'static) -> Self

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

impl<T> MaybeSignal<T, LocalStorage>

pub fn derive_local(derived_signal: impl Fn() -> T + 'static) -> Self

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

Trait Implementations

impl<T: Clone, S> Clone for MaybeSignal<T, S>

where S: Storage<T>,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

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

Formats the value using the given formatter.

impl<T: Default, S> Default for MaybeSignal<T, S>

where S: Storage<T>,

fn default() -> Self

Returns the “default value” for a type.

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

where S: Storage<T>,

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<'de, T: Deserialize<'de>, St> Deserialize<'de> for MaybeSignal<T, St>

where St: Storage<T>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, S> Fn() for MaybeSignal<T, S>

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

Available on crate feature nightly only.

extern "rust-call" fn call(&self, _args: ()) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)

Performs the call operation.

impl<T, S> FnMut() for MaybeSignal<T, S>

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

Available on crate feature nightly only.

extern "rust-call" fn call_mut(&mut self, _args: ()) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)

Performs the call operation.

impl<T, S> FnOnce() for MaybeSignal<T, S>

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

Available on crate feature nightly only.

type Output = <MaybeSignal<T, S> as Get>::Value

The returned type after the call operator is used.

extern "rust-call" fn call_once(self, _args: ()) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits)

Performs the call operation.

impl<S> From<&str> for MaybeSignal<String, S>

where S: Storage<String> + Storage<Arc<RwLock<String>>>,

fn from(value: &str) -> Self

Converts to this type from the input type.

impl<T> From<ArcMemo<T>> for MaybeSignal<T>

where T: Send + Sync,

fn from(value: ArcMemo<T>) -> Self

Converts to this type from the input type.

impl<T> From<ArcReadSignal<T>> for MaybeSignal<T>

where T: Send + Sync,

fn from(value: ArcReadSignal<T>) -> Self

Converts to this type from the input type.

impl<T> From<ArcRwSignal<T>> for MaybeSignal<T>

where T: Send + Sync + 'static,

fn from(value: ArcRwSignal<T>) -> Self

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>>) -> Self

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>) -> Self

Converts to this type from the input type.

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

where T: Clone + Send + Sync + 'static,

fn from(value: MaybeSignal<T>) -> Self

Converts to this type from the input type.

impl<T> From<MaybeSignal<T>> for Signal<T>

where T: Send + Sync + 'static,

fn from(value: MaybeSignal<T>) -> Self

Converts to this type from the input type.

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

where T: Clone + Send + Sync + 'static,

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

Converts to this type from the input type.

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

where T: Send + Sync + 'static,

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

Converts to this type from the input type.

impl<T> From<Memo<T>> for MaybeSignal<T>

where T: Send + Sync,

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<T> From<ReadSignal<T>> for MaybeSignal<T>

where T: Send + Sync,

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<T> From<RwSignal<T>> for MaybeSignal<T>

where T: Send + Sync,

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<T, S> From<Signal<T, S>> for MaybeSignal<T, S>

where S: Storage<T>,

fn from(value: Signal<T, S>) -> Self

Converts to this type from the input type.

impl<T> From<T> for MaybeSignal<T, SyncStorage>

where SyncStorage: Storage<T>,

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T> FromLocal<ArcMemo<T, LocalStorage>> for MaybeSignal<T, LocalStorage>

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

Converts between the types.

impl<T> FromLocal<ArcReadSignal<T>> for MaybeSignal<T, LocalStorage>

fn from_local(value: ArcReadSignal<T>) -> Self

Converts between the types.

impl<T> FromLocal<ArcRwSignal<T>> for MaybeSignal<T, LocalStorage>

where T: 'static,

fn from_local(value: ArcRwSignal<T>) -> Self

Converts between the types.

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

where LocalStorage: Storage<T>,

fn from_local(value: T) -> Self

Converts between the types.

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

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

fn eq(&self, other: &MaybeSignal<T, S>) -> 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<T, S> ReadUntracked for MaybeSignal<T, S>

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

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

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

fn try_read_untracked(&self) -> Option<Self::Value>

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

fn custom_try_read(&self) -> Option<Option<Self::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<T, St> Serialize for MaybeSignal<T, St>

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

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

where S: Serializer,

Serialize this value into the given Serde serializer.

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

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

fn track(&self)

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

impl<T: Copy, S> Copy for MaybeSignal<T, S>

where S: Storage<T>,

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

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

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

where T: 'static, S: Storage<T>,