Operators

A mapping step returns exactly one output element per input; a predicate filter returns zero or one, dropping the rest; a running accumulator emits a value derived from every element seen so far, so it carries state between elements.

Building the chain runs ordinary code. The expressions handed to each step are evaluated as the chain is described, so a log line or a computed value written there fires once at assembly, not on each later run of the pipeline.

It depends on the joining rule. Lockstep pairing ends as soon as a completed source's queue is empty, discarding whatever is buffered elsewhere. Latest-value combination keeps going on the completed source's last value until all sources complete. A source that emits nothing leaves the output empty.

Sequential concatenation keeps one call in flight: results arrive in queue order, throughput is capped at one call per call-latency. Bounded merging runs several at once, trading that ordering for throughput and putting the bound's worth of load on the dependency.

A flattening step subscribes to each inner source the mapping produced and re-emits their elements onto one outer sequence. Its strategy also fixes the ordering of results, how many inner calls run at once, and whether superseded ones are cancelled.

A quiet-period debounce fits the dial: it emits one settled value once the turning stops. Periodic sampling fits the drifting reading: it emits whatever is current on each tick, because that source never falls quiet.

Replace the baked-in value with a factory the pipeline calls when a run starts: a step that accepts a function returning a source defers construction to execution, so each run computes its own date instead of reusing the one captured during assembly.

The write becomes invisible in the chain and repeats with the run — once per element per subscription, again on resubscription, and a mid-stream failure leaves earlier writes applied. Keep the transform computing only and declare the effect separately.

Each pipeline step returns a new source that wraps the old one; it never modifies the source it was applied to. Discarding that returned value throws the filtering step away and leaves the original, unfiltered chain in the variable.

Each subscription is an independent run of the chain. State created once when the chain was built is shared by every subscriber, so one run's totals leak into another; state created per subscription starts from the seed and stays private to that run.

A positional take counts what passes, so after the nth element it knows nothing further is needed: it cancels upstream and completes downstream. A predicate filter judges each element alone, never learns it is finished, and leaves the source producing.

A count-only group holds values until the count is reached, so when the source slows the partial group waits indefinitely and its oldest value goes stale. An elapsed-time trigger closes the group on age as well, bounding that wait.

All three are subscribed at once; the moment one responds, the selection cancels the other two and delivers only the winner's values. Cancellation is a request the losing sources must honour, so work already in flight, and any side effect it has, may still complete.

Every later pair is shifted by one: each scan is combined with the next item's weight. Pairing matches by position in arrival order, not by identity, so the results stay well formed and no failure is signalled — the terminal validates each item against its neighbour's weight forever.

Four routes, priced differently: drop to sequential concatenation and lose throughput; use an order-preserving concurrent flatten that holds results and releases them in subscription order; attach a sequence number and resequence downstream; or narrow the requirement to per-key ordering.

Merging leaves every earlier load in flight, so whichever finishes last wins the pane: a stale load can overwrite the highlighted item's data. Switch-to-newest cancels the in-flight load on each highlight change, leaving at most one alive.

Every arrival restarts the quiet timer, so while the gap between values stays below the window the timer is cancelled before it ever fires. The stage is starved, not slow: it emits only once the source finally falls quiet.

Size it from the dependency's safe concurrency rather than each pipeline's appetite: divide one fleet-wide budget across callers with headroom, check it against arrival rate times call latency, and keep bounds per pipeline so a single backfill cannot consume the service.

Decide from measured gap distributions and the consumer's freshness need, not from taste. Classify feeds into bursty and continuous, give each class a default reduction, and publish a staleness bound as the contract so the operator choice can change later.

Only after the first source completes. Appending buys a strict ordering guarantee and pays for it with a gap: a second source that is already running loses everything it produced during that window, a first source that never completes starves it, and a first source that fails prevents it from running at all.

The statements that declared the chain ran during assembly and their frames returned long before anything executed. At failure the stack holds only the machinery currently delivering values and the bodies it invoked, so the declaring line is nowhere on it.

A per-gap bound restarts on every value, so a slow but steady source never trips it and it fires only during silence. A whole-sequence bound fires at a fixed age regardless of progress, even while values are still flowing.