Struct vertigo::Computed

pub struct Computed<T: Clone> { /* private fields */ }

A reactive value that is read-only and computed by dependency graph.

Computed directly from Value

use vertigo::{Computed, Value, transaction};

let value = Value::new(5);

let comp = value.to_computed();

transaction(|context| {
    assert_eq!(comp.get(context), 5);
});

// Can't do that
// comp.set(10);

Computed from Value by provided function

use vertigo::{Computed, Value, transaction};

let value = Value::new(2);

let comp_2 = {
    let v = value.clone();
    Computed::from(move |context| v.get(context) * 2)
};

transaction(|context| {
    assert_eq!(comp_2.get(context), 4);
});

value.set(6);

transaction(|context| {
    assert_eq!(comp_2.get(context), 12);
});

Implementations

impl<T: Clone + 'static> Computed<T>

pub fn from<F: Fn(&Context) -> T + 'static>(get_value: F) -> Computed<T>

pub fn get_id(&self) -> GraphId

pub fn get(&self, context: &Context) -> T

pub fn map<K: Clone + 'static, F: 'static + Fn(T) -> K>( &self, fun: F ) -> Computed<K>

pub fn id(&self) -> GraphId

impl<T: 'static + PartialEq + Clone> Computed<T>

pub fn subscribe<R: 'static, F: Fn(T) -> R + 'static>( self, call: F ) -> DropResource

impl<T: 'static + Clone> Computed<T>

pub fn subscribe_all<R: 'static, F: Fn(T) -> R + 'static>( self, call: F ) -> DropResource

impl<T: 'static + PartialEq + Clone> Computed<T>

pub fn render_value(&self, render: impl Fn(T) -> DomNode + 'static) -> DomNode

pub fn render_value_option( &self, render: impl Fn(T) -> Option<DomNode> + 'static ) -> DomNode

impl<T: PartialEq + Clone + 'static, L: IntoIterator<Item = T> + Clone + PartialEq + 'static> Computed<L>

pub fn render_list<K: Eq + Hash>( &self, get_key: impl Fn(&T) -> K + 'static, render: impl Fn(&T) -> DomNode + 'static ) -> DomNode

Trait Implementations

impl<T: Clone + 'static> Clone for Computed<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: ToString + Clone + PartialEq + 'static> EmbedDom for &Computed<T>

fn embed(self) -> DomNode

impl<T: ToString + Clone + PartialEq + 'static> EmbedDom for Computed<T>

fn embed(self) -> DomNode

impl<T: Clone + 'static> From<&T> for Computed<T>

fn from(value: &T) -> Self

Converts to this type from the input type.

impl From<&str> for Computed<String>

fn from(value: &str) -> Self

Converts to this type from the input type.

impl<R> From<Computed<Rc<dyn Fn() -> R>>> for Callback<R>

fn from(value: Computed<Rc<dyn Fn() -> R + 'static>>) -> Self

Converts to this type from the input type.

impl<T, R> From<Computed<Rc<dyn Fn(T) -> R>>> for Callback1<T, R>

fn from(value: Computed<Rc<dyn Fn(T) -> R + 'static>>) -> Self

Converts to this type from the input type.

impl<T: Clone + 'static> From<T> for Computed<T>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: Clone + 'static> From<Value<T>> for Computed<T>

fn from(val: Value<T>) -> Self

Converts to this type from the input type.

impl<T: Clone + 'static> PartialEq for Computed<T>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Clone + 'static> ToComputed<Resource<Rc<T>>> for Computed<Resource<T>>

fn to_computed(&self) -> Computed<Resource<Rc<T>>>

impl<T: Clone + 'static> ToComputed<T> for &Computed<T>

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

impl<T: Clone + 'static> ToComputed<T> for Computed<T>

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