@typed/fx/Fx

Operations supplied to a callback producer for emitting values or ending its run.

Creates an Fx from a callback-based source.

Creates an Fx from a function that provides values to a Sink.

This is the lowest-level constructor for Fx, giving you full control over the stream’s behavior.

Collects all values emitted by an Fx into an array.

Forks the collection of all values from an Fx.

Collects the first n values emitted by an Fx into an array.

Forks the collection of up to n values from an Fx.

Returns the first value emitted by the Fx wrapped in an Option. If the Fx is empty, returns None.

Appends a value to the end of an Fx.

Concatenates two Fx streams: runs the first to completion, then runs the second. Emits all values from the first stream in order, then all values from the second stream in order.

Completion: The concatenated stream completes when the second stream completes (the first must complete before the second starts).

Failures: A source Cause is delivered to the Sink. Because Fx.run is infallible, delivery alone does not suppress the continuation: the right source is run after the left run returns.

Continues an Fx with a lazily created Fx after the first run returns.

Wraps an Fx with a start and end value.

Merges two Fx streams into a single Fx that emits values from both streams concurrently. Order of emission is non-deterministic.

Completion: The merged stream completes when both input streams have completed.

Failures: Every failure Cause is delivered to the downstream Sink. Delivery does not make Fx.run fail, so merge does not itself cancel the sibling; a terminal observer may choose to.

Merges multiple Fx streams into a single Fx that emits values from all input streams concurrently.

Merges two Fx streams and emits only values from the left stream. Both streams run concurrently; completion when both complete.

Runs multiple Fx streams concurrently while draining their values in argument order.

Merges two Fx streams and emits only values from the right stream. Both streams run concurrently; completion when both complete.

Prepends a value to the beginning of an Fx.

Combines a record of Fx streams into a single Fx that emits a record of the latest values. Similar to tuple, but for objects.

Combines multiple Fx streams into a single Fx that emits a tuple of the latest values from each stream. The resulting Fx waits for all input streams to emit at least once before emitting the first tuple. Afterwards, it emits a new tuple whenever any input stream emits a new value.

Emits [source, latest] whenever the source emits, using the latest value from that. Source values are dropped until that has emitted at least once.

Unlike {@link zipLatest}, this does not emit when that updates.

Completion: Completes when the source completes. Errors: The first failure from either stream fails the result.

Like {@link withLatestFrom}, but combines the pair with f.

Zips two Fx streams in strict lockstep: emits a pair [a, b] only when both streams have produced their next value. Emits the i-th pair when both have produced at least i values.

Completion: The zipped stream completes when the first of the two streams completes (no further pairs are emitted). The other stream is interrupted.

Errors: The first failure from either stream fails the zipped stream.

Zips two Fx streams by latest values: waits for both to emit at least once, then emits [left, right] whenever either stream emits (using the latest value from the other). No strict pairing; output count is the sum of emissions from both after the first pair.

Completion: Completes when both streams have completed. Errors: The first failure from either stream fails the result.

Zips two Fx streams by latest values and combines each pair with a function. Waits for both to emit at least once, then emits f(left, right) whenever either stream emits.

Completion: Completes when both streams have completed. Errors: The first failure from either stream fails the result.

Zips two Fx streams in strict lockstep and emits only the left value. Completes when the first of the two streams completes.

Zips two Fx streams in strict lockstep and emits only the right value. Completes when the first of the two streams completes.

Zips two Fx streams in strict lockstep and combines each pair with a function. Emits f(a, b) when both streams have produced their next value.

Completion: Completes when the first of the two streams completes. Errors: The first failure from either stream fails the result.

Maps each element to an inner Fx and concatenates the results sequentially.

Maps each element to an Effect and concatenates the results sequentially.

Maps each element to an inner Fx, running one now and retaining only the latest waiting value.

Maps each element to an Effect, running one now and retaining only the latest waiting value.

Maps each element of an Fx to a new Fx, ignoring new elements until the current inner Fx completes.

Maps each element of an Fx to an Effect, ignoring new elements until the current effect completes.

Maps each source value to an inner Fx and merges every inner concurrently.

Maps each element of an Fx to a new Fx, running them concurrently with a limit.

Maps each element of an Fx to an Effect, running them concurrently with a limit.

Maps each element of an Fx to an Effect, and merges the results.

Runs two streams concurrently until one emits, then mirrors the winner and interrupts the other.

A failure or completion from one side before the other emits does not win unless every side ends without emitting. After a winner is chosen, that stream’s later failures are propagated.

Races many streams: the first to emit wins and the rest are interrupted.

Maps each element of an Fx to a new Fx, and switches to the latest inner Fx.

When a new element is emitted, the previous inner Fx is cancelled.

Maps each element of an Fx to an Effect, and switches to the latest effect.

When a new element is emitted, the previous effect is cancelled.

Conditionally runs one of two Fx streams based on the boolean value emitted by the condition stream.

Conditionally emits one of two values based on the boolean value emitted by the condition stream.

Creates an Fx from an Effect.

If the Effect succeeds, the Fx emits the value and completes. If the Effect fails, the Fx fails with the same error.

Recovers from the first typed failure of an Fx by running a fallback Fx.

Uses the Effect-style catchAll name for {@link catch}.

Recovers from any failure cause by running a fallback Fx.

Recovers a failure cause only when a predicate accepts the complete cause.

Recovers a typed failure only when a predicate accepts it.

Recovers selected tagged typed failures by running a fallback Fx.

Recovers several tagged typed-error variants with one handler table.

Recovers from the first typed failure of an Fx by running a fallback Fx.

Emits the source’s terminal failure cause and discards every successful value.

Materializes every success and the terminal failure as infallible Exit values.

Emits typed failures as values and fails with the first successful value.

Transforms both the success and error channels of an Fx using the provided options.

Mirrors Effect.mapBoth: onSuccess maps emitted values, onFailure maps the typed failure (via Cause.map); defects and interrupts are preserved.

Transforms typed failures while preserving defects and interruption.

Materializes success and failure of an Fx as Result values.

• Success: each emitted value is wrapped as Result.succeed(value).
• Failure: any failure (including typed error, defect, and interrupt) is materialized as Result.fail(cause). The output error type is Cause<E>, so defects and interrupts are explicitly represented in the Result and the resulting Fx has error type never.

The resulting Fx never fails at the stream level; all outcomes are emitted as Result<A, Cause<E>>. Consumers can use Result.match or Result.isSuccess / Result.isFailure to handle success vs failure (including defect/interrupt).

Retries the entire stream when its Cause contains a typed Fail accepted by schedule.

The schedule is reset as soon as the first element of an attempt is emitted, matching Effect Stream.retry.

Creates an Fx that immediately terminates with a defect (unexpected error).

Creates an Fx that immediately fails with the specified error.

Creates an Fx that immediately terminates with the specified Cause.

Creates an Fx from a collection of failures (errors).

Creates an Fx that immediately interrupts.

Callable contracts implemented by fn.

Builds an Fx by yielding Effects and returning the Fx to run afterward.

Builds an Fx with a subscription-owned Scope shared by setup and streaming.

Unwraps an Effect that produces an Fx into a single Fx.

Unwraps an Effect that produces an Fx into a single Fx, managing the scope of the effect.

The scope of the effect is closed when the Fx completes or is interrupted.

Efficiently transforms a list of values into a list of Fx streams, using keys to track identity.

This is crucial for performance when rendering lists or managing collections of stateful entities. When the input list changes:

• New keys cause onValue to be called.
• Existing keys have their RefSubject updated with the new value.
• Removed keys close the supplied child Scope and clean resources registered through it; the onValue run fiber remains owned by the outer parent Scope.

Runs cleanup after the source reports a failure cause.

Traces the whole subscription and each success or failure delivery.

Defines the bounds for slicing an Fx stream.

Effect Stream mapping options used while delivering elements to an Fx sink.

Configuration options for the keyed combinator.

Options for {@link throttle}. A duration-only call is leading-edge ({ leading: true, trailing: false }).

Buffering and callback options accepted while adapting an Fx to an Effect Stream.

An Fx whose implementation is obtained from an Effect service.

Defines an Effect service whose value is also a directly runnable Fx.

Builds a Layer for each subscription and provides it to the entire Fx run.

Provides an already-built Effect Context to the entire Fx run.

Provides one existing service value to the entire Fx run.

Acquires one service with an Effect before running the Fx.

Runs a finalizer with no typed error after the Fx run ends for any reason.

Observes the Fx’s final success or failure with an Effect finalizer.

Runs a finalizer when the Fx reports or externally receives interruption.

Runs an Fx stream to completion, discarding all values. Useful when the side effects of the stream are all that matter.

Runs an Fx stream as a Layer. The stream is forked in the background when the layer is acquired.

Forks the execution of an Fx into a background fiber. The stream will run until it completes or the fiber is interrupted.

Observes the values of an Fx stream using a callback function. The callback can return void or an Effect which will be executed for each value.

Observes the values of an Fx stream using a callback function and returns a Layer. The callback can return void or an Effect which will be executed for each value.

Runs an Fx in a new fiber, using the standard Effect.runFork. This is useful for integrating with the top-level Effect runtime.

Runs an Fx stream to completion and returns a Promise. Rejects if the stream fails.

Runs an Fx stream to completion and returns a Promise of the Exit.

Runtime symbol carried by every Fx implementation.

Checks whether a value carries the FxTypeId protocol property.

Drops consecutive elements that are considered equal by an effectful predicate. When the effect returns true, the element is skipped; when false, it is emitted.

This is the effectful variant of skipRepeatsWith: instead of a pure Equivalence<A>, you supply (prev, next) => Effect<boolean> where true means “equal” (skip) and false means “changed” (emit).

Compacts an Fx of Options, discarding None values and unwrapping Some values.

Drops elements from an Fx after a predicate returns true. The element that satisfies the predicate is included in the output.

Drops elements from an Fx until a predicate returns true. Emits from the first element for which the predicate returns true (including that element) and all following elements.

Drops elements from an Fx until an effectful predicate returns true. Emits from the first element for which the predicate effect succeeds with true (including that element) and all following elements.

Alias of skipWhile for Effect parity (dropWhile naming).

Alias of skipWhileEffect for Effect parity (dropWhileEffect naming).

Filters elements of an Fx using a predicate function.

Filters elements of an Fx using an effectful predicate function.

Maps and filters elements of an Fx in a single operation.

Maps and filters elements of an Fx using an effectful function.

Skips the first n elements of an Fx.

Skips the first n elements where n is produced by an Effect.

Drops elements that are equal to the previous element using standard equality.

Drops elements that are equal to the previous element using a custom equivalence function.

Skips elements from an Fx while a predicate returns true. Emits from the first element for which the predicate returns false (including that element) and all following elements.

Skips elements from an Fx while an effectful predicate returns true. Emits from the first element for which the predicate effect succeeds with false (including that element) and all following elements.

Slices an Fx by skipping a number of elements and then taking a number of elements.

Slices an Fx with bounds produced by an Effect.

Takes the first n elements from an Fx and then completes.

Takes the first n elements where n is produced by an Effect.

Takes elements from an Fx until a predicate returns true. The element that satisfies the predicate is not included in the output.

Takes elements from an Fx until an effectful predicate returns true. The element that satisfies the predicate is not included in the output.

Takes elements from an Fx while a predicate returns true. Stops at the first element for which the predicate returns false; that element is not included.

Takes elements from an Fx while an effectful predicate returns true. Stops at the first element for which the predicate effect succeeds with false; that element is not included.

Loops over an Fx with an accumulator, producing an optional new value for each element. If the function returns None, the element is filtered out.

Loops over the failure causes of an Fx with an accumulator, potentially transforming or filtering them. This allows for complex error handling logic that maintains state across failures.

Effectfully loops over the failure causes of an Fx with an accumulator.

Effectfully loops over an Fx with an accumulator, producing an optional new value.

Partitions the stream into non-empty arrays of size n. The final array may be smaller if there are leftover elements. The size must be a positive safe integer. A group can retain up to n values, so callers own the memory policy for valid sizes. Invalid sizes fail with Cause.IllegalArgumentError.

Matches Effect Stream.grouped.

Loops over an Fx with an accumulator, producing a new value for each element and updating the accumulator.

Loops over the failure causes of an Fx with an accumulator.

Effectfully loops over the failure causes of an Fx with an accumulator.

Effectfully loops over an Fx with an accumulator, producing a new value for each element.

Emits consecutive pairs [previous, current]. The first value is not emitted until a second value arrives.

Equivalent to RxJS pairwise and Effect Stream.sliding(2) for pairs.

Scans the stream with a pure function, emitting the accumulated state after each element. Emits the initial value first, then for each input a emits f(state, a) and updates state.

Semantics align with Effect Stream’s scan: output is initial, f(initial, a1), f(..., a2), …

Scans the stream with an effectful function, emitting the accumulated state after each element. Emits the initial value first, then for each input a runs f(state, a) and emits the resulting state.

Adapts an Effect Stream to a push-based Fx.

Adapts a push-based Fx to an Effect Stream.

Creates an Fx that emits a single value after a specified delay.

Emits a value only after no newer source value arrives for duration.

Sleeps for duration before forwarding each successful source delivery.

Forwards events only between a start signal and that signal’s first stop event.

Creates an Fx that emits values according to a Schedule. The Fx emits void each time the schedule fires.

Partitions the stream into arrays, emitting when n is reached or duration elapses after the first element of the current group. The size must be a positive safe integer. A group can retain up to n values, so callers own the memory policy for valid sizes. Invalid sizes fail with Cause.IllegalArgumentError.

Matches Effect Stream.groupedWithin.

Creates an Fx that emits a void value periodically.

Repeats the entire stream according to schedule after each successful completion. Failures are not repeated.

Schedule.recurs(n) runs the stream n + 1 times (the original plus n repeats), matching Effect Stream.repeat.

Emits the latest source value whenever sampler emits. Source values that arrive between sampler ticks are not forwarded until the next tick.

Completion: Completes when the source completes. Errors: The first failure from either stream fails the result.

Drops events until signal emits, then forwards the rest.

Limits emissions to configured leading and trailing edges of fixed windows.

Pass { duration, leading, trailing } for trailing or both-edge behavior. A duration alone defaults to { leading: true, trailing: false }.

Completes the stream if it does not produce a value (or complete) within duration of the previous event. Matches Effect Stream.timeout.

The timeout is reset after each emission. An infinite duration is a no-op; a zero duration completes immediately.

Switches to fallback if the source does not produce a value within duration of the previous event. Matches Effect Stream.timeoutOrElse and RxJS timeoutTo.

Forwards events until signal emits, then interrupts events.

Replaces all emitted values from the Fx with the provided value b.

Transforms the elements of an Fx using a provided function.

Transforms the elements of an Fx using a provided Effectful function.

Performs an effect for each element of the Fx, without changing the elements.

Alias of Fx.Error for extracting an Fx error channel.

Describes a dual flattening operator whose callback returns an Effect.

Describes a dual flattening operator whose callback returns an Fx.

Fx is a reactive stream of values that supports concurrency, error handling, and context management, fully integrated with the Effect ecosystem.

Conceptually, an Fx<A, E, R> is a push-based stream that:

• Emits values of type A
• Can fail with an error of type E
• Requires a context/environment of type R

Unlike a standard Effect which produces a single value, Fx can produce 0, 1, or many values over time. It is similar to RxJS Observables or AsyncIterables, but built on top of Effect’s fiber-based concurrency model.

Extracts the typed error from an Fx.

Extracts the services required to run an Fx.

Extracts the emitted value type from an Fx.

Alias of Fx.Services for extracting an Fx service channel.

Alias of Fx.Success for extracting an Fx value channel.

Contract for functions whose body yields Effects and returns an Fx.

Contract for functions whose body returns an Fx directly.

An Fx that emits no values and completes immediately.

Creates an Fx from an Iterable. Emits each value from the iterable in order and then completes.

An Fx that waits forever without emitting a value.

An Fx that emits null exactly once and then completes.

Creates an Fx that emits a single value and then completes.

An Fx that emits null exactly once and then completes.

An Fx that emits undefined exactly once and then completes.

An Fx that emits void exactly once and then completes.

Defers creation of an Fx until each run begins.

Lazily evaluates a synchronous function once for each Fx run.

An Fx that emits undefined exactly once and then completes.

An Fx that emits void exactly once and then completes.

Matches any Fx regardless of its value, error, or service channels.

The constructible service class returned by Fx.Service.

Describes how an Fx varies in its value, error, and service channels.