Trait ReactiveGraph

Source

pub trait ReactiveGraph {
    type Computed<T>: GraphNode + Copy;
    type Source<T>: GraphNode + Copy;
    type Effect: GraphNode + Copy;
    type Scope<'a>: Teardown
       where Self: 'a;

    // Required methods
    fn dispose_slot<T: 'static>(&self, handle: &Self::Computed<T>);
    fn dispose_cell<T: 'static>(&self, handle: &Self::Source<T>);
    fn dispose_effect(&self, handle: &Self::Effect);
    fn scope(&self) -> Self::Scope<'_>;
    fn batch<R>(&self, run: impl FnOnce(&Self) -> R) -> R;
    fn dependent_count(&self, node: &impl GraphNode) -> usize;
    fn dependency_count(&self, node: &impl GraphNode) -> usize;
}

Expand description

The graph operations that need no bounds on node values.

Everything here — disposal, scopes, batching, degree introspection — is about graph structure, so generic code over this trait pays for nothing it does not use. Construction and reads live in SyncReactiveGraph / AsyncReactiveGraph. Both capability traits expose the Cell-kernel vocabulary: source, get, and set.

use lazily::{Context, ReactiveGraph, SyncReactiveGraph};

// Written once, no value bounds, works for every execution model.
fn leaked_edges<G: ReactiveGraph>(graph: &G, node: &G::Source<i64>) -> usize {
    graph.dependent_count(node)
}

let ctx = Context::new();
let topic = SyncReactiveGraph::source(&ctx, 1i64);
let derived = SyncReactiveGraph::computed(&ctx, move |c| c.get(&topic) + 1);
assert_eq!(SyncReactiveGraph::get(&ctx, &derived), 2);
assert_eq!(leaked_edges(&ctx, &topic), 1);

ReactiveGraph::dispose_slot(&ctx, &derived);
assert_eq!(leaked_edges(&ctx, &topic), 0);

Required Associated Types§

Source

type Computed<T>: GraphNode + Copy

This graph’s derived-slot handle.

Bounded by GraphNode and Copy so generic code can take degrees of any handle and pass handles around freely. Every handle in the crate is an id, so both hold everywhere.

Source