Supertrait

Fields

• label: Optional human-readable name for debugging and introspection
• id: The unique identifier for this cell
• changed_at: When this cell's value last actually changed
• verified_at: When this cell was last confirmed up-to-date
• durability: How often this cell is expected to change
• dependencies: Cell IDs this cell depends on (empty for signals)

Example

match memo.get_result() {
  Ok(value) => println("Got: " + value.to_string())
  Err(err) => {
    println("Cycle at cell " + err.cell().to_string())
    println(err.format_path())
  }
}

Levels

• Low: Frequently changing values (user input, source text)
• Medium: Moderately stable values
• High: Rarely changing values (configuration, schemas)

Inherited Durability

• current — materialized post-drain (readable via get()/iter())
• delta — frontier for current fixpoint iteration
• staged_delta — staging buffer during fixpoint

• insert() adds to frontier delta outside fixpoint, staged delta during fixpoint
• get() reads current (the materialized post-drain map)
• iter() iterates current; records a dependency for pull verification
• delta_iter() iterates delta; used by rule bodies

• Source: Input cells (signals, relations) — no upstream deps, never collected
• Interior: Derived cells (memos, reactives) — has deps, collectible when unobserved
• Root: Terminal cells (effects) — keeps upstream alive, never collected

Key Features

• Lazy evaluation: The compute function is not called until get().
• Automatic tracking: Dependencies are discovered by intercepting get() calls.
• Memoization: Results are cached; repeated get() calls return the cached value.
• Backdating: If a recomputation produces the same value, downstream memos skip work.

Example

let rt = Runtime()
let a = Signal(rt, 10)
let b = Signal(rt, 20)
let sum = Memo(rt, () => a.get() + b.get())
let observer = sum.observe()

inspect(observer.get(), content="30")  // Computes and caches

a.set(15)
inspect(observer.get(), content="35")  // Recomputes because `a` changed
observer.dispose()

Example

let rt = Runtime()
let source = Signal(rt, 10)
let by_id = MemoMap(rt, (id : Int) => source.get() + id)

inspect(by_id.get(1), content="11")
inspect(by_id.get(1), content="11")  // cache hit for key=1
inspect(by_id.get(2), content="12")  // separate memo for key=2

1. Increments gc_root_counts for the target cell (keeps it alive during gc)
2. Provides a typed getter for reading the cell's value
3. Decrements gc_root_counts on dispose (allows gc to collect)

• Cycle — the cell transitively depends on itself.
• Disposed — the cell being read has been disposed.

• insert() adds to frontier delta outside fixpoint, and to staged delta during fixpoint
• contains() checks current (the materialized post-drain set)
• iter() iterates current; records a dependency for pull verification
• delta_iter() iterates delta; used by rule bodies

• changed_at: When this cell's value last actually changed
• verified_at: When this cell was last confirmed up-to-date

Pointer chase tradeoff

Example

let rt = Runtime()

let x = Signal(rt, 10)

let doubled = Memo(rt, () => x.get() * 2)

Disposal Order

1. Children (bottom-up, recursively)
2. Dispose hooks (empty in Layer 2; populated by Scope::observe in Layer 4)
3. Owned cells

Example

let scope = Scope::new(rt)
let local = scope.signal(42)
let derived = scope.memo(fn() { local.get() * 2 })

// Component unmounts — one cleanup call
scope.dispose()

Example

let rt = Runtime()
let count = Signal(rt, 0)
count.set(5)
inspect(count.get(), content="5")

Example

let rt = Runtime()
let cell = TrackedCell(rt, 0, label="counter")
cell.set(5)
inspect(cell.get(), content="5")

Example

let scope = Scope::new(rt)
let tracked = MyTracked::new(rt)
add_tracked(scope, tracked)
scope.dispose()  // disposes all tracked cells

Parameters

• db: Any type implementing Database
• f: The closure containing signal updates

• The memo sits between push-reactive nodes and pull-based memos
• You want push notifications to reach downstream reactives without eagerly recomputing intermediate derived values

Parameters

• db: Any type implementing Database
• f: The compute function for the hybrid memo
• label: An optional human-readable name for debugging

Returns

• Memo::new_memo for BackdateEq-based (revision) backdating
• Memo::new_no_backdate for no backdating (no trait constraint on T)

Parameters

• db: Any type implementing Database
• f: The compute function for the memo
• label: An optional human-readable name for debugging

Returns

Parameters

• db: Any type implementing Database
• f: The compute function for each key
• label: An optional label applied to each per-key memo

Returns

Parameters

• db: Any type implementing Database

Returns

Parameters

• db: Any type implementing Database
• value: The initial value of the signal
• durability: How often this signal is expected to change (default: Low)
• label: An optional human-readable name for debugging

Returns

Parameters

• db: Any type implementing Database
• value: The initial value of the TrackedCell
• durability: How often this cell is expected to change (default: Low)
• label: An optional human-readable name for debugging

Returns