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, RHS> Add<RHS> for Computed<T>

where Computed<T>: Signal<Output = T>, RHS: Signal, T: Add<<RHS as Signal>::Output> + Clone + 'static, <RHS as Signal>::Output: Clone,

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, RHS> BitAnd<RHS> for Computed<T>

where Computed<T>: Signal<Output = T>, RHS: Signal, T: BitAnd<<RHS as Signal>::Output> + Clone + 'static, <RHS as Signal>::Output: Clone,

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

The resulting type after applying the & operator.

fn bitand(self, rhs: RHS) -> <Computed<T> as BitAnd<RHS>>::Output

Performs the & operation.

impl<T, RHS> BitOr<RHS> for Computed<T>

where Computed<T>: Signal<Output = T>, RHS: Signal, T: BitOr<<RHS as Signal>::Output> + Clone + 'static, <RHS as Signal>::Output: Clone,

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

The resulting type after applying the | operator.

fn bitor(self, rhs: RHS) -> <Computed<T> as BitOr<RHS>>::Output

Performs the | operation.

impl<T, RHS> BitXor<RHS> for Computed<T>

where Computed<T>: Signal<Output = T>, RHS: Signal, T: BitXor<<RHS as Signal>::Output> + Clone + 'static, <RHS as Signal>::Output: Clone,

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

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: RHS) -> <Computed<T> as BitXor<RHS>>::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, RHS> Div<RHS> for Computed<T>

where Computed<T>: Signal<Output = T>, RHS: Signal, T: Div<<RHS as Signal>::Output> + Clone + 'static, <RHS as Signal>::Output: Clone,

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

The resulting type after applying the / operator.

fn div(self, rhs: RHS) -> <Computed<T> as Div<RHS>>::Output

Performs the / operation.

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, RHS> Mul<RHS> for Computed<T>

where Computed<T>: Signal<Output = T>, RHS: Signal, T: Mul<<RHS as Signal>::Output> + Clone + 'static, <RHS as Signal>::Output: Clone,

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

The resulting type after applying the * operator.

fn mul(self, rhs: RHS) -> <Computed<T> as Mul<RHS>>::Output

Performs the * operation.

impl<T> Neg for Computed<T>

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

type Output = Map<Computed<T>, fn(T) -> <T as Neg>::Output, <T as Neg>::Output>

The resulting type after applying the - operator.

fn neg(self) -> <Computed<T> as Neg>::Output

Performs the unary - operation.

impl<T> Not for Computed<T>

where Computed<T>: Signal<Output = bool>,

type Output = Map<Computed<T>, fn(bool) -> bool, bool>

The resulting type after applying the ! operator.

fn not(self) -> <Computed<T> as Not>::Output

Performs the unary ! operation.

impl<T, RHS> Rem<RHS> for Computed<T>

where Computed<T>: Signal<Output = T>, RHS: Signal, T: Rem<<RHS as Signal>::Output> + Clone + 'static, <RHS as Signal>::Output: Clone,

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

The resulting type after applying the % operator.

fn rem(self, rhs: RHS) -> <Computed<T> as Rem<RHS>>::Output

Performs the % operation.

impl<T, RHS> Shl<RHS> for Computed<T>

where Computed<T>: Signal<Output = T>, RHS: Signal, T: Shl<<RHS as Signal>::Output> + Clone + 'static, <RHS as Signal>::Output: Clone,

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

The resulting type after applying the << operator.

fn shl(self, rhs: RHS) -> <Computed<T> as Shl<RHS>>::Output

Performs the << operation.

impl<T, RHS> Shr<RHS> for Computed<T>

where Computed<T>: Signal<Output = T>, RHS: Signal, T: Shr<<RHS as Signal>::Output> + Clone + 'static, <RHS as Signal>::Output: Clone,

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

The resulting type after applying the >> operator.

fn shr(self, rhs: RHS) -> <Computed<T> as Shr<RHS>>::Output

Performs the >> operation.

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 identity(&self) -> Option<SignalIdentity>

Returns the stable semantic identity of this signal, when one exists.

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<T, RHS> Sub<RHS> for Computed<T>

where Computed<T>: Signal<Output = T>, RHS: Signal, T: Sub<<RHS as Signal>::Output> + Clone + 'static, <RHS as Signal>::Output: Clone,

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

The resulting type after applying the - operator.

fn sub(self, rhs: RHS) -> <Computed<T> as Sub<RHS>>::Output

Performs the - operation.