Struct anchors::expert::Anchor

pub struct Anchor<O, E: Engine + ?Sized> { /* fields omitted */ }

The main struct of the Anchors library. Represents a single value on the recomputation graph.

This doesn’t contain the particular Anchor implementation directly, but instead contains an engine-specific AnchorHandle which allows the recalculation engine to identify which internal recomputation graph node this corresponds to. You should rarely create Anchors yourself; instead use one of the built-in functions like Var::new to create one, or create derivative Anchors with one of the AnchorExt methods.

Implementations

impl<E: Engine, K: Ord + Clone + PartialEq + 'static, V: Clone + PartialEq + 'static> Anchor<Dict<K, V>, E>

pub fn filter<F: FnMut(&K, &V) -> bool + 'static>(
    &self,
    f: F
) -> Anchor<Dict<K, V>, E>

pub fn map<F: FnMut(&K, &V) -> T + 'static, T: Clone + PartialEq + 'static>(
    &self,
    f: F
) -> Anchor<Dict<K, T>, E>

pub fn filter_map<F: FnMut(&K, &V) -> Option<T> + 'static, T: Clone + PartialEq + 'static>(
    &self,
    f: F
) -> Anchor<Dict<K, T>, E>

pub fn unordered_fold<T: PartialEq + Clone + 'static, F: for<'a> FnMut(&mut T, DiffItem<'a, K, V>) -> bool + 'static>(
    &self,
    initial_state: T,
    f: F
) -> Anchor<T, E>

impl<O, E: Engine> Anchor<O, E>

pub fn new(data: E::AnchorHandle) -> Self

pub fn token(&self) -> <E::AnchorHandle as AnchorHandle>::Token

Returns the immutable, copyable, hashable, comparable engine-specific ID for this Anchor.

Trait Implementations

impl<O1, E> AnchorExt<E> for &Anchor<O1, E> where
    O1: 'static,
    E: Engine, 

type Target = (Anchor<O1, E>,)

fn map<F, Out>(self, f: F) -> Anchor<Out, E> where
    Out: 'static,
    F: 'static,
    Map<Self::Target, F, Out>: AnchorInner<E, Output = Out>, 

Creates an Anchor that maps a number of incremental input values to some output value. The function f accepts inputs as references, and must return an owned value. f will always be recalled any time any input value changes. For example, you can add two numbers together with map:

fn map_mut<F, Out>(self, initial: Out, f: F) -> Anchor<Out, E> where
    Out: 'static,
    F: 'static,
    MapMut<Self::Target, F, Out>: AnchorInner<E, Output = Out>, 

fn then<F, Out>(self, f: F) -> Anchor<Out, E> where
    F: 'static,
    Out: 'static,
    Then<Self::Target, Out, F, E>: AnchorInner<E, Output = Out>, 

Creates an Anchor that maps a number of incremental input values to some output Anchor. With then, your computation graph can dynamically select an Anchor to recalculate based on some other incremental computation.. The function f accepts inputs as references, and must return an owned Anchor. f will always be recalled any time any input value changes.

fn refmap<F, Out>(self, f: F) -> Anchor<Out, E> where
    Out: 'static,
    F: 'static,
    RefMap<Self::Target, F>: AnchorInner<E, Output = Out>, 

Creates an Anchor that maps some input reference to some output reference. Performance is critical here: f will always be recalled any time any downstream node requests the value of this Anchor, not just when an input value changes. It’s also critical to note that due to constraints with Rust’s lifetime system, these output references can not be owned values, and must live exactly as long as the input reference. For example, you can lookup a particular value inside a tuple without cloning:

fn cutoff<F, Out>(self, f: F) -> Anchor<Out, E> where
    Out: 'static,
    F: 'static,
    Cutoff<Self::Target, F>: AnchorInner<E, Output = Out>, 

Creates an Anchor that outputs its input. However, even if a value changes you may not want to recompute downstream nodes unless the value changes substantially. The function f accepts inputs as references, and must return true if Anchors that derive values from this cutoff should recalculate, or false if derivative Anchors should not recalculate. If this is the first calculation, f will be called, but return values of false will be ignored. f will always be recalled any time the input value changes. For example, you can only perform an addition if an input changes by more than 10:

impl<O0, E> AnchorSplit<E> for Anchor<(O0,), E> where
    O0: Clone + PartialEq + 'static,
    E: Engine, 

type Target = (Anchor<O0, E>,)

fn split(&self) -> Self::Target

impl<O0, O1, E> AnchorSplit<E> for Anchor<(O0, O1), E> where
    O0: Clone + PartialEq + 'static,
    O1: Clone + PartialEq + 'static,
    E: Engine, 

type Target = (Anchor<O0, E>, Anchor<O1, E>)

fn split(&self) -> Self::Target

impl<O0, O1, O2, E> AnchorSplit<E> for Anchor<(O0, O1, O2), E> where
    O0: Clone + PartialEq + 'static,
    O1: Clone + PartialEq + 'static,
    O2: Clone + PartialEq + 'static,
    E: Engine, 

type Target = (Anchor<O0, E>, Anchor<O1, E>, Anchor<O2, E>)

fn split(&self) -> Self::Target

impl<O0, O1, O2, O3, E> AnchorSplit<E> for Anchor<(O0, O1, O2, O3), E> where
    O0: Clone + PartialEq + 'static,
    O1: Clone + PartialEq + 'static,
    O2: Clone + PartialEq + 'static,
    O3: Clone + PartialEq + 'static,
    E: Engine, 

type Target = (Anchor<O0, E>, Anchor<O1, E>, Anchor<O2, E>, Anchor<O3, E>)

fn split(&self) -> Self::Target

impl<O0, O1, O2, O3, O4, E> AnchorSplit<E> for Anchor<(O0, O1, O2, O3, O4), E> where
    O0: Clone + PartialEq + 'static,
    O1: Clone + PartialEq + 'static,
    O2: Clone + PartialEq + 'static,
    O3: Clone + PartialEq + 'static,
    O4: Clone + PartialEq + 'static,
    E: Engine, 

type Target = (Anchor<O0, E>, Anchor<O1, E>, Anchor<O2, E>, Anchor<O3, E>, Anchor<O4, E>)

fn split(&self) -> Self::Target

impl<O0, O1, O2, O3, O4, O5, E> AnchorSplit<E> for Anchor<(O0, O1, O2, O3, O4, O5), E> where
    O0: Clone + PartialEq + 'static,
    O1: Clone + PartialEq + 'static,
    O2: Clone + PartialEq + 'static,
    O3: Clone + PartialEq + 'static,
    O4: Clone + PartialEq + 'static,
    O5: Clone + PartialEq + 'static,
    E: Engine, 

type Target = (Anchor<O0, E>, Anchor<O1, E>, Anchor<O2, E>, Anchor<O3, E>, Anchor<O4, E>, Anchor<O5, E>)

fn split(&self) -> Self::Target

impl<O0, O1, O2, O3, O4, O5, O6, E> AnchorSplit<E> for Anchor<(O0, O1, O2, O3, O4, O5, O6), E> where
    O0: Clone + PartialEq + 'static,
    O1: Clone + PartialEq + 'static,
    O2: Clone + PartialEq + 'static,
    O3: Clone + PartialEq + 'static,
    O4: Clone + PartialEq + 'static,
    O5: Clone + PartialEq + 'static,
    O6: Clone + PartialEq + 'static,
    E: Engine, 

type Target = (Anchor<O0, E>, Anchor<O1, E>, Anchor<O2, E>, Anchor<O3, E>, Anchor<O4, E>, Anchor<O5, E>, Anchor<O6, E>)

fn split(&self) -> Self::Target

impl<O0, O1, O2, O3, O4, O5, O6, O7, E> AnchorSplit<E> for Anchor<(O0, O1, O2, O3, O4, O5, O6, O7), E> where
    O0: Clone + PartialEq + 'static,
    O1: Clone + PartialEq + 'static,
    O2: Clone + PartialEq + 'static,
    O3: Clone + PartialEq + 'static,
    O4: Clone + PartialEq + 'static,
    O5: Clone + PartialEq + 'static,
    O6: Clone + PartialEq + 'static,
    O7: Clone + PartialEq + 'static,
    E: Engine, 

type Target = (Anchor<O0, E>, Anchor<O1, E>, Anchor<O2, E>, Anchor<O3, E>, Anchor<O4, E>, Anchor<O5, E>, Anchor<O6, E>, Anchor<O7, E>)

fn split(&self) -> Self::Target

impl<O0, O1, O2, O3, O4, O5, O6, O7, O8, E> AnchorSplit<E> for Anchor<(O0, O1, O2, O3, O4, O5, O6, O7, O8), E> where
    O0: Clone + PartialEq + 'static,
    O1: Clone + PartialEq + 'static,
    O2: Clone + PartialEq + 'static,
    O3: Clone + PartialEq + 'static,
    O4: Clone + PartialEq + 'static,
    O5: Clone + PartialEq + 'static,
    O6: Clone + PartialEq + 'static,
    O7: Clone + PartialEq + 'static,
    O8: Clone + PartialEq + 'static,
    E: Engine, 

type Target = (Anchor<O0, E>, Anchor<O1, E>, Anchor<O2, E>, Anchor<O3, E>, Anchor<O4, E>, Anchor<O5, E>, Anchor<O6, E>, Anchor<O7, E>, Anchor<O8, E>)

fn split(&self) -> Self::Target

impl<O, E: Engine> Clone for Anchor<O, E>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<O, E: Engine> Eq for Anchor<O, E>

impl<O, E: Engine> PartialEq<Anchor<O, E>> for Anchor<O, E>

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

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.