Struct reax::Var

pub struct Var<T> { /* fields omitted */ }

A mutable variable that is tracked by the reax runtime.

Today this is a wrapper around a RefCell and a Node but may be more generic in the future once GATs are stable.

Implementations

impl<T> Var<T>

pub fn new(value: T) -> Self

Creates a new interiorly mutable wrapper around the given value.

pub fn set(&self, value: T)

Sets the value of the variable, instantly marking all upstream variables as dirty. This method will panic if any reference given by a call to mutate is still alive.

let var = Var::new(1);
let double = computed! { var.get_copy() * 2 };
var.set(2);
assert!(double.node().is_dirty());

pub fn set_checked(&self, value: T) where
    T: PartialEq, 

Sets the value of the variable. Unlike set, upstream variables are not marked as dirty if the given value is equal to the current value.

pub fn mutate(&self) -> RefMut<T>

Provides a mutable reference to the variable, instantly marking all upstream variables as dirty. This method will panic if any reference given by a previous call to mutate is still alive.

let var = Var::new(1);
let double = computed! { var.get_copy() * 2 };
*var.mutate() += 1;
assert!(double.node().is_dirty());

Trait Implementations

impl<T: Debug> Debug for Var<T>

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

Formats the value using the given formatter.

impl<T> Variable for Var<T>

type Value = T

The type of this variable.

fn node(&self) -> &Node

Returns a handle to this variable's node in the reax runtime's dependency graph.

fn get(&self) -> Ref<T>

Returns the value of this variable.

fn get_non_reactive(&self) -> Ref<T>

Returns the value of this variable without alerting the reax runtime that the variable is used in the current context. See also get.

fn get_copy(&self) -> Self::Value where
    Self::Value: Copy, 

Returns the value of this variable by copy where possible. See also get.

fn map<T, F>(self, func: F) -> ComputedVar<FunctionMapped<Self, T, F>> where
    F: FnMut(&Self::Value) -> T, 

Create a new ComputedVar which depends only on this variable. The value of the returned cell is lazily computed by the given function. That is, the function will not be executed until someone retrieves the value of the cell. This can be used similarly to EagerCompute::watch if the resulting cell is checked frequently. See also ComputedVar::new.

fn map_mutate<T, F>(
    self,
    initial: T,
    func: F
) -> ComputedVar<MutatorMapped<Self, T, F>> where
    F: FnMut(&Self::Value, &mut T), 

Create a new ComputedVar which depends only on this variable. The value of the returned cell is lazily updated by the given function. That is, the function will not be executed until someone retrieves the value of the cell. This can be used similarly to EagerCompute::watch if the resulting cell is checked frequently. See also ComputedVar::new_mutate.

fn with_label(self, label: impl Display) -> Self

Provides the runtime with a variable name to use in debug outputs. This does nothing in release builds.