@typed/fx/Sink

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).

Consumes pushed successes and failures through effectful callbacks.

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.

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

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.

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.

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.

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.

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.

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.