Struct DynObservable 

pub struct DynObservable<T> { /* private fields */ }

A type-erased, cheaply-cloneable Observable.

Use this where a concrete observable type cannot appear — struct fields, collections of heterogeneous reactive inputs, or component APIs that accept “a reactive T” regardless of whether the caller has a Signal, Memo, Thunk, or a constant.

Examples

use adaptite::{DynObservable, Observable, signal};

struct Label {
    text: DynObservable<String>,
}

let static_label = Label {
    text: DynObservable::constant(String::from("fixed")),
};
let dynamic = signal(String::from("live"));
let dynamic_label = Label {
    text: dynamic.clone().into_dyn(),
};

assert_eq!(static_label.text.get(), "fixed");
assert_eq!(dynamic_label.text.get(), "live");
dynamic.set(String::from("updated"));
assert_eq!(dynamic_label.text.get(), "updated");

Implementations

impl<T: 'static> DynObservable<T>

pub fn constant(value: T) -> Self

Wraps a plain value as an observable that never changes and records no dependencies.

Useful for APIs that accept DynObservable<T> when the caller has a static value.

Trait Implementations

impl<T> Clone for DynObservable<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> Debug for DynObservable<T>

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

Formats the value using the given formatter.

impl<T: 'static> Observable for DynObservable<T>

type Item = T

The type of value this observable holds.

fn into_dyn(self) -> DynObservable<T>

Erases this observable’s concrete type behind a cheaply-cloneable handle.

fn reactor(&self) -> Option<Reactor>

Returns the reactor this observable’s node belongs to, when it has one.

fn with<R>(&self, f: impl FnOnce(&T) -> R) -> R

Runs f with a shared reference to the current value, recording a dependency for the currently running observer.

fn with_peek<R>(&self, f: impl FnOnce(&T) -> R) -> R

Runs f with a shared reference to the current value without recording a dependency.

fn get(&self) -> Self::Item

where Self::Item: Clone,

Clones and returns the current value, recording a dependency.

fn peek(&self) -> Self::Item

where Self::Item: Clone,

Clones and returns the current value without recording a dependency.

fn map<U, F>(&self, f: F) -> Memo<U>

where Self: Clone + Sized + 'static, U: PartialEq + 'static, F: Fn(&Self::Item) -> U + 'static,

Derives a memo from this observable, cloning the receiver’s handle internally.