Struct Computed 

pub struct Computed<T>(/* private fields */);

A wrapper around a boxed implementation of the ComputedImpl trait.

This type represents a computation that can be evaluated to produce a result of type T. The computation is stored as a boxed trait object, allowing for dynamic dispatch.

Implementations

impl<T> Computed<T>

pub fn new<C>(value: C) -> Computed<T>

where C: Signal<Output = T> + Clone + 'static,

Creates a new Computed<T> from a value that implements Compute<Output = T>.

The provided value is boxed and stored internally.

impl<T> Computed<T>

where T: 'static + Clone,

pub fn constant(value: T) -> Computed<T>

Creates a new constant computation with the provided value.

This is a convenience wrapper around Computed::new(constant(value)).

Trait Implementations

impl<T, C2> Add<C2> for Computed<T>

where C2: Signal, T: Add<<C2 as Signal>::Output> + Clone + 'static, <C2 as Signal>::Output: Clone,

type Output = Map<Zip<Computed<T>, C2>, fn((T, <C2 as Signal>::Output)) -> <T as Add<<C2 as Signal>::Output>>::Output, <T as Add<<C2 as Signal>::Output>>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: C2) -> <Computed<T> as Add<C2>>::Output

Performs the + operation.

impl<T> Clone for Computed<T>

where T: 'static,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Computed<T>

Implements Debug for Computed<T>.

This just outputs the type name rather than any internal details.

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

Formats the value using the given formatter.

impl<T> Default for Computed<T>

where T: 'static + Clone + Default,

Implements Default for Computed<T> when T implements Default.

This creates a constant computation with the default value of T.

fn default() -> Computed<T>

Returns the “default value” for a type.

impl<T> From<Binding<T>> for Computed<T>

fn from(val: Binding<T>) -> Computed<T>

Converts to this type from the input type.

impl<T> Signal for Computed<T>

where T: 'static,

Implements Compute for Computed<T>.

This delegates to the internal boxed implementation.

type Output = T

The type of value produced by this computation.

type Guard = Box<dyn WatcherGuard>

The guard type returned by the watch method that manages watcher lifecycle.

fn get(&self) -> <Computed<T> as Signal>::Output

Execute the computation and return the current value.

fn watch( &self, watcher: impl Fn(Context<<Computed<T> as Signal>::Output>) + 'static, ) -> <Computed<T> as Signal>::Guard

Register a watcher to be notified when the computed value changes.

impl<V: View> View for Computed<V>

where Self: 'static,

fn body(self, _env: &Environment) -> impl View

Build this view and return the content.