Trait SignalExt 

pub trait SignalExt: Sized + Signal {
    // Provided methods
    fn map<F, Output>(self, f: F) -> Map<Self, F, Output>
       where F: 'static + Clone + Fn(Self::Output) -> Output,
             Output: 'static,
             Self: 'static { ... }
    fn zip<B>(self, b: B) -> Zip<Self, B>
       where B: Signal,
             Self::Output: Clone,
             <B as Signal>::Output: Clone { ... }
    fn cached(self) -> Cached<Self>
       where Self::Output: Clone { ... }
    fn computed(self) -> Computed<Self::Output>
       where Self: 'static { ... }
    fn with<T>(self, metadata: T) -> WithMetadata<Self, T> { ... }
    fn debounce(self, duration: Duration) -> Debounce<Self, DefaultExecutor>
       where Self::Output: Clone { ... }
    fn throttle(self, duration: Duration) -> Throttle<Self, DefaultExecutor>
       where Self::Output: Clone { ... }
}

Extension trait providing convenient methods for all Signal types.

This trait adds utility methods to any type implementing Signal, allowing for easy chaining of operations like mapping, zipping, and caching.

Provided Methods

fn map<F, Output>(self, f: F) -> Map<Self, F, Output>

where F: 'static + Clone + Fn(Self::Output) -> Output, Output: 'static, Self: 'static,

Transforms the output of this signal using the provided function.

fn zip<B>(self, b: B) -> Zip<Self, B>

where B: Signal, Self::Output: Clone, <B as Signal>::Output: Clone,

Combines this signal with another signal into a tuple.

fn cached(self) -> Cached<Self>

where Self::Output: Clone,

Wraps this signal with caching to avoid redundant computations.

fn computed(self) -> Computed<Self::Output>

where Self: 'static,

Converts this signal into a type-erased Computed container.

fn with<T>(self, metadata: T) -> WithMetadata<Self, T>

Attaches metadata to this signal’s watcher notifications.

fn debounce(self, duration: Duration) -> Debounce<Self, DefaultExecutor>

where Self::Output: Clone,

Creates a debounced version of this signal.

The debounced signal will only emit values after the specified duration has passed without receiving new values.

fn throttle(self, duration: Duration) -> Throttle<Self, DefaultExecutor>

where Self::Output: Clone,

Creates a throttled version of this signal.

The throttled signal will emit values at most once every specified duration, ignoring any additional values received during that period.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<C> SignalExt for C

where C: Signal,