Follow one execution
Invoke the continuation lazily after the current run returns, then subscribe to its result.
continueWithTick 0. Cached: cached; Output: cached.
Read this diagram
Follow each lane from left to right. Events stacked vertically share a tick; the green cursor marks the current time across every lane.
- A value
The text inside the pill is the emitted value. - Work starts
The raised chevron starts an inner run (^in the source). - The run returns
The vertical bar ends this lane’s run. - A cause is delivered
The exclamation mark belongs to this lane. - Work is interrupted
The cross marks cancellation of this run. - Current time
The line and diamond move together across all lanes. - Happening now
A highlighted event is at the current tick. - Still ahead
Muted, dashed values have not happened yet. - Time continues
The lane’s arrow is not a return marker. An empty stretch can be quiet work that is still running.
Illustrated ticks start at 0. At 1×, one illustrated tick takes one second; captions specify real durations when timing matters. A cause or interruption belongs to its lane, and other work may continue. Scroll horizontally to inspect the rest of a long timeline.
Failures and service requirements from both producers remain on the public type and both failures are delivered to the same Sink. The returned Fx owns neither input. Interruption or a defect that prevents the first run Effect from returning also prevents the continuation from starting.
Import
import { continueWith } from "@typed/fx/Fx";Signatures
export declare const continueWith: {
<B, E2, R2>(f: () => Fx<B, E2, R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A | B, E | E2, R | R2>;
<A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: () => Fx<B, E2, R2>): Fx<A | B, E | E2, R | R2>;
};Why
This sequences two producer runs without converting either to a pull
collection. The thunk is lazy, so the continuation is not constructed until
the first Fx.run Effect returns.
Ordering and cardinality
All successes from fx are delivered before successes from f(). A source
failure is also delivered to the shared Sink, but delivery does not fail
Fx.run: Sink.onFailure returns an Effect whose error channel is never.
After that handler returns, the continuation still runs. The two producers
never run concurrently.
Ownership and lifetime
Failures and service requirements from both producers remain on the public type and both failures are delivered to the same Sink. The returned Fx owns neither input. Interruption or a defect that prevents the first run Effect from returning also prevents the continuation from starting.
Examples
import { Fx, Sink } from "@typed/fx"
import { Effect } from "effect"
const events: Array<string> = []
const phases = Fx.continueWith(Fx.fail("offline"), () => Fx.succeed("fallback"))
const program = phases.run(Sink.make(
() => Effect.sync(() => events.push("failure delivered")),
(value) => Effect.sync(() => events.push(value))
))
Effect.runPromise(program).then(() => console.log(events))
// ["failure delivered", "fallback"]Other public imports
These import paths expose the same declaration. Each page retains its own public name and signature.