Reactive

ReactiveArray

A reactive sequence of keyed elements: the shape Each iterates over.

ReactiveArrayElement

One element of a ReactiveArray: a value paired with a stable key so a view stays bound to it across inserts, removals and reorders.

ReactiveError

The error carried by a lock: a message, and optionally a flag you can set to retry.

ReactiveGettable

The readable half of a value: its current native value, and whether it is locked (not ready).

ReactiveLock

Marks a value as pending: loading, or failed. Its presence propagates through calculations; while it is omitted, the value is available.

ReactiveProcess

A callback plus the root scope items that give its state and emissions stable identity across runs.

ReactiveProgram

A program together with its persisted state and reverse processes: the value the runtime carries and returns each cycle.

ReactiveScopeItem

One call-site position within a run, with any named branch scopes beneath it. This is how state and emissions keep the same identity from one run to the next.

ReactiveSettable

The writable half of a value: a stable identity, and an optional reverse to run when it is Set.

ReactiveValue

A value in the reactive graph. It is made of two optional halves: a gettable (readable) and a settable (writable); which halves are present decides whether it can be read, written, or both.

Reactive.AddError

Returns a value locked with an error appended. The optional retry flag id can be Set to true to trigger a retry.

Reactive.AddErrorOptional

Note: not confirmed in the current Reactive.* surface. Left in place pending review.

Attaches an error to a value only when a message is present; otherwise returns it unchanged. Useful for errors that are themselves reactive or conditional.

Reactive.Binding

Joins a gettable value and a settable value into one that is both: a two-way value that reads forward and writes backward.

const fahrenheit = Reactive.Binding(reading, writing);

Reactive.Branches

Note: not confirmed in the current Reactive.* surface. Left in place pending review.

Opens named child scopes at the current position: the low-level basis for conditionals and iteration. If and Each are built on it.

Reactive.Loading

Creates a piece of state that starts locked (loading). Curried and typed like State: call it with a type, then with the initial value. Unlock it by Setting a ready value.

const user = Reactive.Loading(Reactive.Any)(null);

Reactive.Create

Note: not confirmed in the current Reactive.* surface. Left in place pending review.

Wraps a raw value as a constant reactive value, or returns it unchanged if it is already reactive.

Reactive.Dereference

Note: not confirmed in the current Reactive.* surface. Left in place pending review.

Recovers the value a settable id refers to: the inverse of Reference.

Reactive.Each

Iterates a ReactiveArray, running the callback once per element in its own branch scope so each row keeps its identity across inserts, removals and reorders.

Reactive.Each(items, (item) => {
  // … render item …
});

Reactive.GetObjectField

Note: not confirmed in the current Reactive.* surface. Left in place pending review.

A reactive accessor for one field of an object, optionally two-way: it reads the field with a getter, and, when the object itself is settable, writes it back with a changer.

Reactive.HasError

Whether a value is locked with an error, distinct from a plain loading state.

Reactive.HasRetryFlag

Whether a value's error carries a retry flag.

Reactive.If

Runs the callback only when the condition is truthy, in its own scope so what it describes appears and disappears cleanly.

Reactive.If(open, () => {
  // … shown only while `open` is true …
});

Reactive.IsLocked

Whether a value is locked: pending, whether loading or errored. Raw values always read as unlocked.

Reactive.Lock

Locks a value when the flag is true, marking it pending (a loading state); returns it unchanged otherwise.

Reactive.OptionalErrorMessage

The error message on a value, or undefined when the value is clear.

Reactive.OptionalRetryFlag

The retry flag carried by a value's error, or undefined. Set it to true to trigger a retry.

Reactive.Mount

The entry point. Runs a content callback and drives its output into a target, running the update loop for you. For the DOM, point the content driver at a root element.

Reactive.Mount(() => {
  const ui = Dom(() => {
    // … describe the view …
  });
  return { content: ui.content };
}, { content: { root: document.getElementById('app') } });

Reactive.Reference

Note: not confirmed in the current Reactive.* surface. Left in place pending review.

The settable's stable id: pass a settable through code (like a stored field) that would otherwise unwrap it. Reverse it with Dereference.

Reactive.Reverse

Creates a settable-only value whose callback runs when it is Set: the write-only half you join to a forward calculation to make a two-way value.

const writing = Reactive.Reverse((f) => Reactive.Set(celsius, (f - 32) * 5 / 9));

Reactive.Set

Writes to a value. State stores the value directly; a value that carries a reverse runs that reverse, cascading the change backward toward plain state.

Reactive.Set(count, count.value + 1);

Reactive.StableId

Note: not confirmed in the current Reactive.* surface. Left in place pending review.

The stable id for the current call-site position: the same value on every run, which is how state persists.

Reactive.StableKey

Note: not confirmed in the current Reactive.* surface. Left in place pending review.

A stable string key for the current position, for use in collections and contexts.

Reactive.State

Creates a piece of mutable reactive state, both readable and settable. Curried and typed: call it with a type, then with the initial value. It persists across runs by its stable position in the program.

const count = Reactive.State(Reactive.Any)(0);

Reactive.Value

Reads the native value out of a reactive value (or passes a raw value straight through). Used inside a reverse or driver callback to unwrap a reactive to its raw value.

Reactive.WithLockFrom

Returns a value carrying the lock from another: a way to propagate pending state from one value onto another by hand.