@typed/fx

Stateful scan over a RefSubject / Computed, producing a Computed of the accumulated state.

Fx subscriptions follow Fx.scan semantics (emit initial, then fold each source value). Effect sampling accumulates across source versions via a private state ref (do not mix heavy subscribe + sample on the same scan if you need a single shared accumulator).

Effectful stateful scan over a RefSubject / Computed, producing a Computed of the accumulated state.

Get the absolute value of the current state of a RefBigDecimal.

Add a BigDecimal to the current state of a RefBigDecimal.

Calculate the ceiling of the current state of a RefBigDecimal.

Divide the current state of a RefBigDecimal by a BigDecimal.

Check if the current state of a RefBigDecimal equals a BigDecimal.

Calculate the floor of the current state of a RefBigDecimal.

Multiply the current state of a RefBigDecimal by a BigDecimal.

Negate the current state of a RefBigDecimal.

Round the current state of a RefBigDecimal.

Subtract a BigDecimal from the current state of a RefBigDecimal.

Truncate the current state of a RefBigDecimal.

Get the absolute value of the current state of a RefBigInt.

Add a BigInt to the current state of a RefBigInt.

Divide the current state of a RefBigInt by a BigInt.

Check if the current state of a RefBigInt equals a BigInt.

Get the remainder of dividing the current state of a RefBigInt by a BigInt.

Multiply the current state of a RefBigInt by a BigInt.

Negate the current state of a RefBigInt.

Subtract a BigInt from the current state of a RefBigInt.

Add a Duration to the current state of a RefDuration.

Divide the current state of a RefDuration by a number.

Multiply the current state of a RefDuration by a number.

Subtract a Duration from the current state of a RefDuration.

A bidirectional value that is both a Sink<A, E, R> and an Fx<B, E2, R2>.

Calling onSuccess or onFailure sends exactly one input notification to the wrapped Sink. The returned Effect is the acknowledgment: a producer that runs and awaits it waits for the consumer callback to finish. Push adds no queue, buffering, replay, or demand protocol of its own.

Running the Fx side preserves that Fx’s cardinality and ordering. Input values are not automatically forwarded to the output; any relationship between the two sides belongs to the supplied Sink and Fx (for example, a shared Subject).

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.

Transform a Versioned’s output value as both an Fx and Effect.

Transform a Versioned’s output value as both an Fx and Effect using an Effect.

Transforms a Versioned value into another Versioned value.

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.

Collects all values into an array. Pass a Ref<ReadonlyArray<A>> (e.g. Ref.make([])); after running, read the result with Ref.get(ref).

Keeps only the first value. Pass a Ref<Option.Option<A>> (e.g. Ref.make(Option.none())); after running, read the result with Ref.get(ref).

Keeps only the last value. Pass a Ref<Option.Option<A>> (e.g. Ref.make(Option.none())); after running, read the result with Ref.get(ref).

Reduces values into a single result using a pure function. Pass a Ref<B> (e.g. from Ref.make(initial)); after running, read the result with Ref.get(ref).

Reduces values into a single result using an effectful function. Pass a Ref<B>; after running, read the result with Ref.get(ref). If the reducer effect fails, the ref is left unchanged (Sink onSuccess is typed as never failing).

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.

Runs one inner Fx at a time and retains only the latest value received while busy.

A value while idle starts immediately. While its inner runs, newer outer values replace a single pending slot. f(value) is evaluated and an inner Fx is constructed before every replacement; a superseded pending Fx is never run. After completion, only the latest pending Fx starts. Accepted inners preserve their own order and all values. The input Sink is unchanged.

Runs one mapped Effect at a time and retains only the latest value received while busy.

Each accepted Effect can emit one result. While it runs, one pending Effect is repeatedly overwritten; after completion only the latest pending Effect starts. The mapping callback still runs and constructs an Effect for every value before replacement; superseded Effects are not run. The input side is unchanged.

Runs at most one inner Fx and ignores outer values while it is active.

The first value seen while idle starts an inner; every value arriving before that inner completes is dropped. f(value) is still evaluated and its inner Fx is constructed before the busy check; dropping means the returned Fx is not run. Accepted inners preserve their own order and all values. Input is unchanged.

Runs at most one mapped Effect and ignores values while it is active.

The first value while idle starts one Effect and can emit one result; all values received before it completes are dropped. The mapping callback is still invoked and constructs an Effect for every value before the busy check; dropped Effects are not run. The input side is unchanged.

Transforms each output value into an inner Fx and merges all inners concurrently.

Every outer value starts one inner. All inner values are emitted; order within each inner is preserved, but values from different inners may interleave. The outer stream waits for all inners before normal completion. The input Sink is unchanged.

Transforms every output value into an Effect and merges their results concurrently.

One Effect starts per outer value and can emit one result. All successful results are emitted, but concurrent completion order may differ from input order. The input side is unchanged.

Transforms each output value into an inner Fx, observing only the latest one.

A new outer value interrupts the previous inner fiber before starting the next. Output cardinality is the cardinality of the successive active inners; values from an interrupted inner stop. Outer order determines replacement order, while each active inner preserves its own order. The input Sink is unchanged.

Transforms each output value into an Effect, keeping only the latest Effect.

Each new outer value interrupts the previous Effect before starting its own. Every Effect can emit at most one value; interrupted Effects emit none. The input side is unchanged.

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.

Defines the ref subject options state contract.

Creates a new RefArray from an array, Effect, or Fx.

Creates a new RefBigDecimal from a BigDecimal, Effect, or Fx.

Creates a new RefBigInt from a BigInt, Effect, or Fx.

Creates a new RefBoolean from a boolean, Effect, or Fx.

Creates a new RefCause from a Cause, Effect, or Fx.

Creates a new RefChunk from a Chunk, Effect, or Fx.

Creates a new RefDateTime from a DateTime, Effect, or Fx.

Creates a new RefDuration from a Duration, Effect, or Fx.

Creates a new empty directed RefGraph.

Creates a new RefGraph from a Graph, Effect, or Fx.

Creates a new empty undirected RefGraph.

Creates a new RefHashMap from a HashMap, Effect, or Fx.

Creates a new empty RefHashRing.

Creates a new RefHashRing from a HashRing, Effect, or Fx.

Creates a new RefHashSet from a HashSet, Effect, or Fx.

Creates a new RefIterable from an Iterable, Effect, or Fx.

Creates a new RefOption from an Option, Effect, or Fx.

Creates a new RefRecord from a Record, Effect, or Fx.

Creates a new RefResult from a Result, Effect, or Fx.

Creates a new RefString from a string, Effect, or Fx.

Creates a new RefStruct from a struct, Effect, or Fx.

Creates a new RefSubject from a value, Effect, or Fx.

Creates a new RefTrie from a Trie, Effect, or Fx.

Creates a new RefTuple from a tuple, Effect, or Fx.

Creates a Versioned value from its components.

Creates a Versioned value from a constant.

Consumes pushed successes and failures through effectful callbacks.

Add a Duration to the current state of a RefDateTime.

Add a Duration to the current state of a RefDateTime.

Subtract a Duration from the current state of a RefDateTime.

Subtract a Duration from the current state of a RefDateTime.

Get the epoch milliseconds of the current state of a RefDateTime.

Format the current state of a RefDateTime.

Filter the values of a RefArray using a predicate creating a Computed value.

Group the values of a RefArray by a key.

Get the current length of a RefArray.

Map the values with their indexes of a RefArray.

Partition the values of a RefArray using a predicate.

Reduce the values of a RefArray to a single value.

Reduce the values of a RefArray to a single value in reverse order.

Get the sign of the current state of a RefBigDecimal.

Apply AND operation with a boolean to the current state of a RefBoolean.

Apply EQV (XNOR) operation with a boolean to the current state of a RefBoolean.

Apply implication operation with a boolean to the current state of a RefBoolean.

Apply NAND operation with a boolean to the current state of a RefBoolean.

Apply NOR operation with a boolean to the current state of a RefBoolean.

Apply NOT operation to the current state of a RefBoolean.

Apply OR operation with a boolean to the current state of a RefBoolean.

Apply XOR operation with a boolean to the current state of a RefBoolean.

Get the reasons array of the current state of a RefCause.

Get the size (number of failures) of the current state of a RefCause.

Filter the values of a RefChunk creating a Computed value.

Map the values of a RefChunk to a different type.

Partition the values of a RefChunk using a predicate.

Reduce the values of a RefChunk to a single value.

Reduce the values of a RefChunk in reverse order.

Get the current size of a RefChunk.

Get connected components (undirected only).

Get the edge count.

Get neighbors of a node.

Get directed neighbors of a node.

Get the node count.

Get strongly connected components.

Get all entries from the RefHashMap.

Filter and map values.

Filter entries creating a Computed value.

Get all keys from the RefHashMap.

Map values to a different type.

Reduce the entries to a single value.

Get the current size of the RefHashMap.

Get all values from the RefHashMap.

Get the node which should handle a given input string as a Computed. Returns undefined if the ring is empty.

Get shard distribution across nodes.

Get the number of nodes in the HashRing.

Get all nodes as an array.

Filter values creating a Computed value.

Map values to a different type.

Reduce the values to a single value.

Get the current size of the RefHashSet.

Get all values as an array.

Count elements satisfying a predicate.

Filter the values of a RefIterable creating a Computed value.

Group the values of a RefIterable by a key.

Map the values of a RefIterable to a different type.

Reduce the values of a RefIterable to a single value.

Get the current size of a RefIterable.

Convert to array.

Filter the value inside the Option of a RefOption.

FlatMap the value inside the Option of a RefOption.

Get the value from the Option or use a fallback value.

Map the value inside the Option of a RefOption.

Get all entries from the Record.

Filter and map values.

Filter entries creating a Computed value.

Get all keys from the Record.

Map entries to new key-value pairs.

Map keys to different keys.

Map values to a different type.

Partition entries.

Reduce the entries to a single value.

Get the current size of the Record.

Get all values from the Record.

FlatMap the success value of a RefResult.

Map the success value of a RefResult.

Map the error value of a RefResult.

Match on the Result value.

Concatenate a string to the current state of a RefString.

Check if the current state of a RefString ends with a substring.

Check if the current state of a RefString includes a substring.

Get the length of the current state of a RefString.

Replace the first occurrence of a substring or pattern in the current state of a RefString.

Replace all occurrences of a substring or pattern in the current state of a RefString.

Extract a section of the current state of a RefString.

Check if the current state of a RefString starts with a substring.

Convert the current state of a RefString to lowercase.

Convert the current state of a RefString to uppercase.

Trim whitespace from both ends of the current state of a RefString.

Trim whitespace from the end of the current state of a RefString.

Trim whitespace from the start of the current state of a RefString.

Get the entries of the current state of a RefStruct.

Get a property value from the current state of a RefStruct.

Get the keys of the current state of a RefStruct.

Omit properties from the current state of a RefStruct.

Pick properties from the current state of a RefStruct.

Get the size (number of properties) of the current state of a RefStruct.

Get the values of the current state of a RefStruct.

Builds a read-only Computed projection from a Versioned source.

Transforms a RefSubject, Computed, or Filtered using a pure function.

Transforms a RefSubject, Computed, or Filtered using an Effectful function.

Extract all values from an object using a Proxy. Allows accessing nested properties of a Computed or Filtered object/array as individual computed values.

Compact Option values.

Get all entries from the Trie.

Get all entries with a given prefix.

Get all keys from the Trie.

Get all keys with a given prefix.

Get the longest prefix of a key that exists in the Trie.

Map values to a different type.

Reduce the entries to a single value.

Get the current size of the Trie.

Get all values from the Trie.

Get all values with a given prefix.

Append an element to the end of the current state of a RefTuple.

Projects one statically valid tuple index as Computed state.

Get the length of the current state of a RefTuple.

Omit elements at specific indices from the current state of a RefTuple.

Pick elements at specific indices from the current state of a RefTuple.

Prepend an element to the beginning of the current state of a RefTuple.

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.

Materializes both sink channels as successful Effect Exit values.

Exchanges a sink’s typed success and failure channels.

Maps the error channel of a sink using the provided function. Failures are mapped via Cause.map; defects and interrupts are preserved.

Suppresses failure causes made entirely of interruption reasons.

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.

Creates a named hydrated RefSubject using a string-encoded Schema codec.

Combines hydrated refs into one serialization and restoration boundary.

Canonical data attribute for the versioned envelope of unnamed hydrated refs.

Defines the hydrate options state contract.

Defines the hydrated ref subject state contract.

Defines the hydration attribute state contract.

Defines the hydration element state contract.

Defines the hydration ref state contract.

Runtime symbol exposing hydration metadata on a hydrated RefSubject.

Describes the any type.

Describes the hydration error type.

Describes the hydration services type.

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.

Selects whether a computed Fx observes only its current value or also follows later pushes.

Limits which pushed versions a RefSubject view observes without changing its state.

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.

Zero-based skip count and maximum take count used by slice.

Filter-maps a Versioned’s output as both an Fx and Effect; the Effect value becomes Option (Some when the predicate holds, None otherwise).

Filter-maps a Versioned’s output as both an Fx and Effect using an Effect; the Effect value becomes Option.

Get a value contained a particular index of a RefArray.

Gets the first element of a RefArray as a Filtered.

Gets the last element of a RefArray as a Filtered.

Find the first value satisfying a predicate.

Find the last value satisfying a predicate.

Get a value at a particular index of a RefChunk.

Get the first element of a RefChunk as a Filtered.

Get the last element of a RefChunk as a Filtered.

Find an edge matching a predicate.

Find a node matching a predicate.

Get an edge’s data.

Get a node’s data.

Find the first entry satisfying a predicate.

Get the value at a key as a Filtered.

Get the node which should handle a given input string as a Filtered. Fails if the ring is empty.

Find the first value satisfying a predicate.

Find the last value satisfying a predicate.

Get the first element of a RefIterable as a Filtered.

Get the value from the Option as a Filtered (fails if None).

Find the first entry satisfying a predicate.

Get the value at a key as a Filtered.

Pop a value at a key as a Filtered.

Get the failure value from the Result as a Filtered (fails if Success).

Get the success value from the Result as a Filtered (fails if Failure).

Converts a Computed or Filtered of Option<A> into a Filtered<A>, filtering out None values.

Filters and transforms a RefSubject, Computed, or Filtered using a pure function that returns an Option.

Filters and transforms a RefSubject, Computed, or Filtered using an Effectful function that returns an Option.

Returns a Computed that yields the value inside the Option, or the fallback when None. Works with Computed<Option<A>> (e.g. from fromOption / fromNullable) and with Filtered<A>.

Builds a Filtered view from the three channels of a Versioned source.

Get the value at a key as a Filtered.

Transforms the output (Fx) error channel of a Push using the provided function.

Failures (Cause) are mapped via Cause.map, so only the typed failure (Fail) is transformed; defects and interrupts are preserved unchanged.

Mirrors Effect.mapError on the Fx side. Cardinality, value order, input callbacks, and output service requirements are unchanged.

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.

A multicast boundary that is both an Fx of its publications and a Sink that accepts them. Successes and failures are pushed to every subscriber present when that publication begins.

Couples a Sink input with an independent Fx output.

The result forwards each input callback directly to sink and delegates every output subscription to fx. It does not connect the two values, change output cardinality or ordering, buffer inputs, or start either side eagerly.

Constructable static type produced by Push.Service.

The static and Effect service surface returned by Push.Service.

Service lookup supplies the same bidirectional value to run, onSuccess, and onFailure. The Self service appears in both required-service channels; the installed Push itself has those requirements captured by its Layer.

Defines a named Effect service whose value is a Push.

The returned class exposes onSuccess, onFailure, and run as Effects that first resolve the service from Context. make captures the Sink construction context and combines it with each output subscriber’s context; it does not start the Fx or send an input while building the Layer.

A Computed is a read-only view of a value that can change over time. It is an Fx that emits the current value and subsequent updates. It is also an Effect that samples the current value.

A Filtered is a Computed that may not always have a value. It is essentially a Computed<Option<A>> with helper methods.

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.

Keeps successful inputs that satisfy f and discards the rest.

Calling onSuccess runs the predicate immediately. A match constructs one Sink callback Effect; a non-match immediately returns an empty acknowledgment. Predicate allocation and throws therefore occur before the returned Effect is run. The producer controls call order and concurrency; output is preserved.

Effectfully decides whether each successful input reaches the Sink.

Calling onSuccess(value) invokes f(value) immediately to construct the predicate Effect; allocation and throws happen before an acknowledgment is returned. Running the acknowledgment later executes that Effect in the caller’s fiber. true forwards one value, false none, and failure sends its Cause to the Sink failure callback. Calls are not serialized; the producer controls order and concurrency. Output behavior is unchanged.

Transforms an input and forwards it only when f returns Some.

Calling onSuccess evaluates f immediately. Some(a) constructs one Sink callback Effect; None immediately returns an empty acknowledgment. Mapping allocation and throws therefore happen before the returned Effect runs. Calls are not serialized, so ordering follows the producer. Output is unchanged.

Effectfully transforms an input and forwards only a resulting Some value.

Calling onSuccess(value) invokes f(value) immediately to construct an Effect; allocation and throws happen before an acknowledgment is returned. Running that acknowledgment later executes the constructed Effect in the caller’s fiber. Some(a) produces one Sink callback, None none, and failure sends its full Cause to the Sink failure callback. Concurrent calls are not serialized.

Forwards Some values and discards None values.

Filters values before they reach the sink using a predicate function.

Runs an effectful predicate and forwards inputs for which it succeeds with true.

Filters and transforms values before they reach the sink using a function that returns an Option.

Runs an Effect for each input and forwards its optional successful value.

Keeps Fx output values that satisfy f.

The upstream Sink invokes the predicate synchronously for each output value, before the returned downstream callback Effect runs. Predicate allocation and throws therefore occur at upstream callback invocation. Matches preserve their relative order; non-matches produce no output. No buffer is added and every input callback is unchanged.

Effectfully decides which Fx output values are emitted.

Each upstream value runs one predicate. true emits that value, false emits none, and predicate failures join the output error channel. For a sequential source the predicate is acknowledged before the next delivery, preserving order; the input side is unchanged.

Maps each Fx output and emits only resulting Some values.

The upstream Sink evaluates f synchronously for each value, before its returned downstream callback Effect runs. Mapping allocation and throws occur at that callback invocation. Some(c) emits exactly one c; None emits nothing. Relative order, errors, services, and input behavior are preserved.

Effectfully maps each Fx output and emits only resulting Some values.

One mapper Effect runs per upstream value. Some(c) emits once, None emits nothing, and failures join the output error channel. Sequential sources retain order; the input Sink remains unchanged.

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.

Defines the class state contract.

Defines the service state contract.

Creates a Context-backed RefSubject service facade and Layer constructors.

Lifts an Effect-provided Computed into a Computed facade.

Defers retrieval of a Filtered value from Effect Context while preserving Filtered behavior.

Creates a Context-backed Versioned service facade and Layer constructor.

Defines the class state contract.

Defines the service state contract.

Provides context to a Versioned value.

Holds the latest value of a Versioned stream.

Multicasts a Versioned stream.

Replays the last bufferSize values of a Versioned stream.

The concrete lazy Fx returned by share.

Shares an Fx and immediately replays its latest success or failure to each new subscriber.

Multicasts an Fx without replaying values that arrived before a subscriber joined.

Shares an Fx and replays up to the last capacity successes or failures to new subscribers.

Shares one active execution of an Fx among subscribers through the supplied Subject.

Creates a Sink from success and failure callbacks.

Defines a class-shaped Effect Context service for a Sink.

Constructor-shaped Context service returned by Sink.Service.

Describes a Sink available through an Effect Context service.

Creates a RefSubject from an Effect.

Creates a RefSubject from an Fx, tracking the latest emitted value.

Creates Option-valued RefSubject state from a nullable input.

Creates a RefSubject from an Option value.

Creates a RefSubject that tracks the latest value emitted by an Effect Stream.

Combines multiple RefSubject, Computed, or Filtered instances into a single struct.

Combines multiple RefSubject, Computed, or Filtered instances into a single tuple.

Combines multiple Versioned values into a single struct.

Combines multiple Versioned values into a single tuple.

A RefArray is a RefSubject that is specialized over an array of values.

A RefBigDecimal is a RefSubject specialized over a BigDecimal value.

A RefBigInt is a RefSubject specialized over a BigInt value.

A RefBoolean is a RefSubject specialized over a boolean value.

A RefCause is a RefSubject specialized over a Cause value.

A RefChunk is a RefSubject specialized over a Chunk of values.

A RefDateTime is a RefSubject specialized over a DateTime value.

A RefDuration is a RefSubject specialized over a Duration value.

A RefGraph is a RefSubject specialized over a Graph.

A RefHashMap is a RefSubject specialized over a HashMap.

A RefHashRing is a RefSubject specialized over a HashRing.

A RefHashSet is a RefSubject specialized over a HashSet.

A RefIterable is a RefSubject specialized over an Iterable of values.

A RefOption is a RefSubject specialized over an Option value.

A RefRecord is a RefSubject specialized over a Record.

A RefResult is a RefSubject specialized over a Result value.

A RefString is a RefSubject specialized over a string value.

A RefStruct is a RefSubject specialized over a struct value.

A RefTrie is a RefSubject specialized over a Trie.

A RefTuple is a RefSubject specialized over a tuple value.

Check to see if a RefArray is empty.

Check to see if a RefArray is non-empty.

Check if the current state of a RefBigDecimal is greater than a BigDecimal.

Check if the current state of a RefBigDecimal is an integer.

Check if the current state of a RefBigDecimal is less than a BigDecimal.

Check if the current state of a RefBigDecimal is negative.

Check if the current state of a RefBigDecimal is positive.

Check if the current state of a RefBigDecimal is zero.

Check if the current state of a RefBigInt is greater than a BigInt.

Check if the current state of a RefBigInt is less than a BigInt.

Check if the current state of a RefBigInt is negative.

Check if the current state of a RefBigInt is positive.

Check if the current state of a RefBigInt is zero.

Check if the current state of a RefBoolean is false.

Check if the current state of a RefBoolean is true.

Check if the current state of a RefCause has a Die.

Check if the current state of a RefCause has a Fail.

Check if the current state of a RefCause has an Interrupt.

Check if the current state of a RefCause is empty.

Check if a RefChunk contains a value.

Check if all values satisfy a predicate.

Check if a RefChunk is empty.

Check if a RefChunk is non-empty.

Check if any value satisfies a predicate.

Check if the current state of a RefDateTime is after another DateTime.

Check if the current state of a RefDateTime is before another DateTime.

Check if the current state of a RefDateTime equals another DateTime.

Check if the current state of a RefDuration is greater than a Duration.

Check if the current state of a RefDuration is less than a Duration.

Check if the current state of a RefDuration is zero.

Check if an edge exists.

Check if a node exists.

Check if the graph is acyclic.

Check if the graph is bipartite (undirected only).

Check if all entries satisfy a predicate.

Check if a key exists in the RefHashMap.

Check if the RefHashMap is empty.

Check if the RefHashMap is non-empty.

Check if any entry satisfies a predicate.

Check if a node exists in the HashRing.

Check if the HashRing is empty.

Check if all values satisfy a predicate.

Check if a value exists in the RefHashSet.

Check if the RefHashSet is empty.

Check if the RefHashSet is non-empty.

Check if this set is a subset of another.

Check if any value satisfies a predicate.

Check if a RefIterable contains a value.

Check if a RefIterable is empty.

Check if any value satisfies a predicate.

Check if the current state of a RefOption contains a value.

Check if the value inside the Option satisfies a predicate.

Check if the current state of a RefOption is None.

Check if the current state of a RefOption is Some.

Check if all entries satisfy a predicate.

Check if a key exists in the Record.

Check if the Record is empty.

Check if the Record is non-empty.

Check if any entry satisfies a predicate.

Check if the current state of a RefResult is Failure.

Check if the current state of a RefResult is Success.

Check if the current state of a RefString is empty.

Check if the current state of a RefString is non-empty.

Check if the current state of a RefStruct has a property.

Check if a key exists in the Trie.

Check if the Trie is empty.

Check if the Trie is non-empty.

A Versioned value is a value that changes over time, and each change is associated with a version number. It combines the capabilities of an Fx (to observe changes) and an Effect (to get the current value).

Append a value to the current state of a RefArray.

Append an iterable of values to the current state of a RefArray.

Remove any duplicate values from a RefArray.

Drop the first n values from a RefArray.

Drop the last n values from a RefArray.

Drop values from a RefArray while a predicate is true.

Insert a value at a particular index of a RefArray.

Map (Endomorphic) the values of a RefArray.

Modify the value at a particular index of a RefArray.

Prepend a value to the current state of a RefArray.

Prepend an iterable of values to the current state of a RefArray.

Replace a value at a particular index of a RefArray.

Rotate the values of a RefArray by n places. Helpful for things like carousels.

Sort the values of a RefArray using a provided Order.

Take the first n values from a RefArray.

Take the last n values from a RefArray.

Take values from a RefArray while a predicate is true.

Set the current state of a RefBoolean to false.

Set the current state of a RefBoolean to true.

Toggle the current state of a RefBoolean.

Set the current state of a RefCause to a Die cause.

Set the current state of a RefCause to a Fail cause.

Set the current state of a RefCause to an Interrupt cause.

Append a value to the current state of a RefChunk.

Append an iterable of values to the current state of a RefChunk.

Remove duplicate values from a RefChunk.

Remove adjacent duplicate values from a RefChunk.

Drop the first n values from a RefChunk.

Drop the last n values from a RefChunk.

Drop values from a RefChunk while a predicate is true.

Filter the values of a RefChunk (mutating).

Map (Endomorphic) the values of a RefChunk.

Modify the value at a particular index of a RefChunk.

Prepend a value to the current state of a RefChunk.

Prepend an iterable of values to the current state of a RefChunk.

Remove a value at a particular index of a RefChunk.

Replace a value at a particular index of a RefChunk.

Reverse the values of a RefChunk.

Sort the values of a RefChunk using a provided Order.

Take the first n values from a RefChunk.

Take the last n values from a RefChunk.

Take values from a RefChunk while a predicate is true.

Add an edge to the graph.

Add a node to the graph.

Filter edges.

Filter nodes.

Map all edge data.

Map all node data.

Remove an edge from the graph.

Remove a node from the graph.

Reverse all edge directions.

Update an edge’s data.

Update a node’s data.

Clear all entries from the RefHashMap.

Filter entries in place.

Map values in place (endomorphic).

Modify the value at a key if it exists.

Modify the value at a key using an Option-based update function.

Remove a key from the RefHashMap.

Remove multiple keys from the RefHashMap.

Set a key-value pair in the RefHashMap.

Set multiple key-value pairs in the RefHashMap.

Merge another HashMap into this one.

Add a node to the HashRing.

Add multiple nodes to the HashRing.

Remove a node from the HashRing.

Add a value to the RefHashSet.

Clear all values from the RefHashSet.

Compute the difference with another HashSet.

Filter values in place.

Compute the intersection with another HashSet.

Map values in place (endomorphic).

Remove a value from the RefHashSet.

Compute the union with another HashSet.

Append a value to the current state of a RefIterable.

Append an iterable of values to the current state of a RefIterable.

Remove adjacent duplicate values from a RefIterable.

Drop the first n values from a RefIterable.

Filter the values of a RefIterable (mutating).

Filter and map values in place.

FlatMap (endomorphic).

Extract Some values from Option iterable.

Intersperse a separator between elements.

Map (Endomorphic) the values of a RefIterable.

Prepend a value to the current state of a RefIterable.

Prepend an iterable of values to the current state of a RefIterable.

Repeat the iterable n times.

Take the first n values from a RefIterable.

Take values from a RefIterable while a predicate is true.

Set the current state of a RefOption to None.

Set the current state of a RefOption to Some(value).

Clear all entries from the Record.

Difference with another record.

Filter entries in place.

Intersection with another record.

Map values in place (endomorphic).

Modify the value at a key if it exists.

Remove a key from the Record.

Replace the value at a key if it exists.

Set a key-value pair in the Record.

Union with another record.

Set the current state of a RefResult to Failure(error).

Set the current state of a RefResult to Success(value).

Merge another struct into the current state of a RefStruct.

Set a property value in the current state of a RefStruct.

Update a property value in the current state of a RefStruct using a function.

Decrements a numeric RefSubject by 1.

Resets a RefSubject to its initial value, returning the previous value if it existed.

Increments a numeric RefSubject by 1.

Resets a RefSubject to its initial value, returning the previous value if it existed.

Sets the value of a RefSubject.

Updates a RefSubject using a pure function.

Updates a RefSubject using an Effectful function.

Clear all entries from the Trie.

Filter entries into a read-only derived trie.

Filter and map entries into a read-only derived trie.

Insert a key-value pair into the Trie.

Insert multiple key-value pairs into the Trie.

Map values into a read-only derived trie.

Modify the value at a key if it exists.

Remove a key from the Trie.

Remove multiple keys from the Trie.

Set the value at a specific index in the current state of a RefTuple.

Update the value at a specific index in the current state of a RefTuple using a function.

An early-exit sink with a mutable Effect Ref for consumer-local state.

An early-exit sink with serialized effectful access to consumer-local state.

Threads pure state through successes and optionally forwards a derived value.

Threads state through an effectful success transition and optionally forwards its value.

Threads pure state through successful inputs and forwards one derived value per input.

Threads state through an effectful success transformation and forwards one value on success.

Runs a callback with an early-exit sink and a private Effect Ref initialized to state.

Runs a callback with private state whose effectful reads and writes are serialized.

Threads pure state through failures and optionally forwards a transformed cause.

Threads state through an effectful failure transition and optionally forwards a cause.

Threads pure state through failure causes and forwards one transformed cause per failure.

Threads state through an effectful failure transformation.

Maps over the output (Fx) side of a Push with an accumulator: for each emitted value b, applies f(state, b) to get [nextState, emitted] and emits the second element. The first element is the initial state; subsequent states are updated by each step. It emits exactly one C per upstream value, in order. Accumulator state is private to each output subscription; the input Sink is unchanged.

Maps over the output (Fx) side of a Push with an effectful accumulator: for each emitted value b, runs f(state, b) to get [nextState, emitted] and emits the second element. The adapter does not serialize callbacks. Calling onSuccess invokes f immediately with the current seed and constructs its Effect; overlapping calls can therefore observe the same seed. Successful completion commits the returned seed and emits in completion order, so later completion may overwrite newer state. Reducer failure is sent to the output Sink, emits nothing, restores that call’s previous seed, and completes normally so a continuing producer can send later values. The input Sink is unchanged.

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.

A sink that can ask its producer callback to stop early.

Runs a producer callback until the first matching value has been forwarded.

Runs a producer callback through a bounded view of a sink.

Runs a producer-style callback with a sink that can complete the surrounding Effect early.

Adapts an Effect Stream to a push-based Fx.

Adapts a push-based Fx to an Effect Stream.

Acquires a Subject whose subscribers and replay state are released with the current Scope.

Immediately allocates a Subject with the requested replay capacity and manual ownership.

Defines an Effect context service that is simultaneously a Subject, Fx, and Sink facade.

A constructible service facade whose static side is also the contextual Subject.

The service-shaped form of a Subject created by Subject.Service.

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.

Interface for basic RefSubject operations: get, set, delete.

Modifies a RefSubject using a pure function that returns both a result and a new value.

Modifies a RefSubject using an Effectful function that returns both a result and a new value.

Runs an effect that can modify a RefSubject transactionally, with optional interrupt handling.

Synchronously transforms each successful input before sending it to the Sink.

One input maps to exactly one downstream input. Calling onSuccess evaluates f immediately, before the returned downstream Effect is run; allocation and thrown exceptions therefore occur at callback invocation (and become defects only when that invocation itself occurs inside Effect evaluation). The Sink callback Effect remains the acknowledgment. Calls are not serialized; execution order and concurrency follow the producer. The Fx output is unchanged.

Effectfully transforms each successful input before sending it to the Sink.

Calling onSuccess(value) invokes f(value) immediately to construct an Effect. Allocation and thrown exceptions therefore occur before an acknowledgment Effect is returned. Running that returned Effect later executes the constructed Effect in the caller’s fiber. On success its single A reaches the Sink; typed failure, defect, or interruption sends its full Cause to the Sink failure callback. Calls are not serialized, so the producer controls order and concurrency. Output values and order are unchanged.

Transforms values before they reach the sink using a pure function.

Runs an Effect for each input and forwards its successful value to the sink.

Alias for map, named for the input-side direction of the transformation.

Alias for mapEffect, named for the input-side direction of the effectful transformation.

Runs an effectful observation before forwarding each successful input unchanged.

Synchronously transforms every value emitted by the Fx output side.

It emits exactly one C for every upstream B, preserving order and the complete input Sink. The mapping does not buffer or introduce concurrency.

Transforms both the output (Fx) success and error channels of a Push using the provided options.

Mirrors Effect.mapBoth on the Fx side: onSuccess maps every emitted value one-to-one and onFailure maps typed failures via Cause.map; defects and interrupts are preserved. Ordering, services, and the input side are unchanged.

Effectfully transforms each Fx output value.

The mapper runs once per upstream value and emits one result on success, in upstream order for a sequential source. Its typed failures join E2; its required services join R2. The input side is unchanged.

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.

Matches any Push when its six channel types are intentionally unknown.

Alias of Sink.Error for direct imports.

Alias of Sink.Services for direct imports.

Matches any Sink when its channels do not need to be preserved.

Extracts the typed error carried by causes consumed by a Sink.

Extracts the Effect services required by a Sink’s callbacks.

Extracts the successful input type consumed by a Sink.

Alias of Sink.Success for direct imports.

Tests whether a value carries the public Computed TypeId.

Tests whether a value carries callable hydration metadata.

Checks if a value is a RefSubject.

Runtime symbol identifying read-only Computed values.

Runtime symbol identifying conditionally available Filtered values.

Runtime symbol identifying writable RefSubject values.

Describes the any type.

Describes the error type.

Describes the any type.

Describes the identifier type.

Describes the any type.

Describes the services type.

Describes the success type.

Unifies a Versioned type.

Extracts the context required to get the version.

Extracts the error type of the version effect.

Get the days value of the current state of a RefDuration.

Get the hours value of the current state of a RefDuration.

Get the milliseconds value of the current state of a RefDuration.

Get the minutes value of the current state of a RefDuration.

Get the seconds value of the current state of a RefDuration.

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.

A RefSubject is a mutable reference that can be observed as an Fx. It combines the capabilities of a Ref (get/set/update) with a Subject (subscribe).

Transforms a RefSubject invariantly using bidirectional mapping functions.

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.

Public namespace exposed as Fx from @typed/fx.

Public namespace exposed as Push from @typed/fx.

Public namespace exposed as RefArray from @typed/fx.

Public namespace exposed as RefBigDecimal from @typed/fx.

Public namespace exposed as RefBigInt from @typed/fx.

Public namespace exposed as RefBoolean from @typed/fx.

Public namespace exposed as RefCause from @typed/fx.

Public namespace exposed as RefChunk from @typed/fx.

Public namespace exposed as RefDateTime from @typed/fx.

Public namespace exposed as RefDuration from @typed/fx.

Public namespace exposed as RefGraph from @typed/fx.

Public namespace exposed as RefHashMap from @typed/fx.

Public namespace exposed as RefHashRing from @typed/fx.

Public namespace exposed as RefHashSet from @typed/fx.

Public namespace exposed as RefIterable from @typed/fx.

Public namespace exposed as RefOption from @typed/fx.

Public namespace exposed as RefRecord from @typed/fx.

Public namespace exposed as RefResult from @typed/fx.

Public namespace exposed as RefString from @typed/fx.

Public namespace exposed as RefStruct from @typed/fx.

Public namespace exposed as RefSubject from @typed/fx.

Public namespace exposed as RefTrie from @typed/fx.

Public namespace exposed as RefTuple from @typed/fx.

Public namespace exposed as Sink from @typed/fx.

Public namespace exposed as Subject from @typed/fx.

Public namespace exposed as Versioned from @typed/fx.