Sink

112 exports Since v2.0.0 Source

A sink that collects first n keys into a map. The keys are calculated from inputs using the keying function key; if multiple inputs use the the same key, they are merged using the merge function.

Signature

declare const collectAllToMapN: <In, K>(n: number, key: (input: In) => K, merge: (x: In, y: In) => In) => Sink<HashMap.HashMap<K, In>, In, In>

collectAllToSet

Since v2.0.0

A sink that collects all of its inputs into a set.

Signature

declare const collectAllToSet: <In>() => Sink<HashSet.HashSet<In>, In>

collectAllToSetN

Since v2.0.0

A sink that collects first n distinct inputs into a set.

Signature

declare const collectAllToSetN: <In>(n: number) => Sink<HashSet.HashSet<In>, In, In>

collectAllUntil

Since v2.0.0

Accumulates incoming elements into a chunk until predicate p is satisfied.

Signature

declare const collectAllUntil: <In>(p: Predicate<In>) => Sink<Chunk.Chunk<In>, In, In>

collectAllUntilEffect

Since v2.0.0

Accumulates incoming elements into a chunk until effectful predicate p is satisfied.

Signature

declare const collectAllUntilEffect: <In, E, R>(p: (input: In) => Effect.Effect<boolean, E, R>) => Sink<Chunk.Chunk<In>, In, In, E, R>

collectAllWhile

Since v2.0.0

Accumulates incoming elements into a chunk as long as they verify predicate p.

Signature

declare const collectAllWhile: {
  <In, Out>(refinement: Refinement<In, Out>): Sink<Chunk<Out>, In, In>;
  <In>(predicate: Predicate<In>): Sink<Chunk<In>, In, In>;
}

collectAllWhileEffect

Since v2.0.0

Accumulates incoming elements into a chunk as long as they verify effectful predicate p.

Signature

declare const collectAllWhileEffect: <In, E, R>(predicate: (input: In) => Effect.Effect<boolean, E, R>) => Sink<Chunk.Chunk<In>, In, In, E, R>

context

Since v2.0.0

Accesses the whole context of the sink.

Signature

declare const context: <R>() => Sink<Context.Context<R>, unknown, never, never, R>

contextWith

Since v2.0.0

Accesses the context of the sink.

Signature

declare const contextWith: <R, Z>(f: (context: Context.Context<R>) => Z) => Sink<Z, unknown, never, never, R>

contextWithEffect

Since v2.0.0

Accesses the context of the sink in the context of an effect.

Signature

declare const contextWithEffect: <R0, A, E, R>(f: (context: Context.Context<R0>) => Effect.Effect<A, E, R>) => Sink<A, unknown, never, E, R0 | R>

contextWithSink

Since v2.0.0

Accesses the context of the sink in the context of a sink.

Signature

declare const contextWithSink: <R0, A, In, L, E, R>(f: (context: Context.Context<R0>) => Sink<A, In, L, E, R>) => Sink<A, In, L, E, R0 | R>

count

Since v2.0.0

A sink that counts the number of elements fed to it.

Signature

declare const count: Sink<number, unknown>

die

Since v2.0.0

Creates a sink halting with the specified defect.

Signature

declare const die: (defect: unknown) => Sink<never, unknown>

dieMessage

Since v2.0.0

Creates a sink halting with the specified message, wrapped in a RuntimeException.

Signature

declare const dieMessage: (message: string) => Sink<never, unknown>

dieSync

Since v2.0.0

Creates a sink halting with the specified defect.

Signature

declare const dieSync: (evaluate: LazyArg<unknown>) => Sink<never, unknown>

drain

Since v2.0.0

A sink that ignores its inputs.

Signature

declare const drain: Sink<void, unknown>

drop

Since v2.0.0

Creates a sink that drops n elements.

Signature

declare const drop: <In>(n: number) => Sink<unknown, In, In>

dropUntil

Since v2.0.0

Drops incoming elements until the predicate is satisfied.

Signature

declare const dropUntil: <In>(predicate: Predicate<In>) => Sink<unknown, In, In>

dropUntilEffect

Since v2.0.0

Drops incoming elements until the effectful predicate is satisfied.

Signature

declare const dropUntilEffect: <In, E, R>(predicate: (input: In) => Effect.Effect<boolean, E, R>) => Sink<unknown, In, In, E, R>

dropWhile

Since v2.0.0

Drops incoming elements as long as the predicate is satisfied.

Signature

declare const dropWhile: <In>(predicate: Predicate<In>) => Sink<unknown, In, In>

dropWhileEffect

Since v2.0.0

Drops incoming elements as long as the effectful predicate is satisfied.

Signature

declare const dropWhileEffect: <In, E, R>(predicate: (input: In) => Effect.Effect<boolean, E, R>) => Sink<unknown, In, In, E, R>

every

Since v2.0.0

A sink that returns whether all elements satisfy the specified predicate.

Signature

declare const every: <In>(predicate: Predicate<In>) => Sink<boolean, In, In>

fail

Since v2.0.0

A sink that always fails with the specified error.

Signature

declare const fail: <E>(e: E) => Sink<never, unknown, never, E>

failCause

Since v2.0.0

Creates a sink halting with a specified Cause.

Signature

declare const failCause: <E>(cause: Cause.Cause<E>) => Sink<never, unknown, never, E>

failCauseSync

Since v2.0.0

Creates a sink halting with a specified lazily evaluated Cause.

Signature

declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Sink<never, unknown, never, E>

failSync

Since v2.0.0

A sink that always fails with the specified lazily evaluated error.

Signature

declare const failSync: <E>(evaluate: LazyArg<E>) => Sink<never, unknown, never, E>

foldChunks

Since v2.0.0

A sink that folds its input chunks with the provided function, termination predicate and initial state. contFn condition is checked only for the initial value and at the end of processing of each chunk. f and contFn must preserve chunking-invariance.

Signature

declare const foldChunks: <S, In>(s: S, contFn: Predicate<S>, f: (s: S, chunk: Chunk.Chunk<In>) => S) => Sink<S, In>

foldChunksEffect

Since v2.0.0

A sink that effectfully folds its input chunks with the provided function, termination predicate and initial state. contFn condition is checked only for the initial value and at the end of processing of each chunk. f and contFn must preserve chunking-invariance.

Signature

declare const foldChunksEffect: <S, In, E, R>(s: S, contFn: Predicate<S>, f: (s: S, chunk: Chunk.Chunk<In>) => Effect.Effect<S, E, R>) => Sink<S, In, In, E, R>

foldEffect

Since v2.0.0

A sink that effectfully folds its inputs with the provided function, termination predicate and initial state.

Signature

declare const foldEffect: <S, In, E, R>(s: S, contFn: Predicate<S>, f: (s: S, input: In) => Effect.Effect<S, E, R>) => Sink<S, In, In, E, R>

foldLeft

Since v2.0.0

A sink that folds its inputs with the provided function and initial state.

Signature

declare const foldLeft: <S, In>(s: S, f: (s: S, input: In) => S) => Sink<S, In>

foldLeftChunks

Since v2.0.0

A sink that folds its input chunks with the provided function and initial state. f must preserve chunking-invariance.

Signature

declare const foldLeftChunks: <S, In>(s: S, f: (s: S, chunk: Chunk.Chunk<In>) => S) => Sink<S, In>

foldLeftChunksEffect

Since v2.0.0

A sink that effectfully folds its input chunks with the provided function and initial state. f must preserve chunking-invariance.

Signature

declare const foldLeftChunksEffect: <S, In, E, R>(s: S, f: (s: S, chunk: Chunk.Chunk<In>) => Effect.Effect<S, E, R>) => Sink<S, In, never, E, R>

foldLeftEffect

Since v2.0.0

A sink that effectfully folds its inputs with the provided function and initial state.

Signature

declare const foldLeftEffect: <S, In, E, R>(s: S, f: (s: S, input: In) => Effect.Effect<S, E, R>) => Sink<S, In, In, E, R>

foldUntil

Since v2.0.0

Creates a sink that folds elements of type In into a structure of type S until max elements have been folded.

Like Sink.foldWeighted, but with a constant cost function of 1.

Signature

declare const foldUntil: <In, S>(s: S, max: number, f: (s: S, input: In) => S) => Sink<S, In, In>

foldUntilEffect

Since v2.0.0

Creates a sink that effectfully folds elements of type In into a structure of type S until max elements have been folded.

Like Sink.foldWeightedEffect but with a constant cost function of 1.

Signature

declare const foldUntilEffect: <S, In, E, R>(s: S, max: number, f: (s: S, input: In) => Effect.Effect<S, E, R>) => Sink<S, In, In, E, R>

foldWeighted

Since v2.0.0

Creates a sink that folds elements of type In into a structure of type S, until max worth of elements (determined by the costFn) have been folded.

Note

Elements that have an individual cost larger than max will force the sink to cross the max cost. See Sink.foldWeightedDecompose for a variant that can handle these cases.

Signature

declare const foldWeighted: <S, In>(options: {
  readonly body: (s: S, input: In) => S;
  readonly cost: (s: S, input: In) => number;
  readonly initial: S;
  readonly maxCost: number;
}) => Sink<S, In, In>

foldWeightedDecompose

Since v2.0.0

Creates a sink that folds elements of type In into a structure of type S, until max worth of elements (determined by the costFn) have been folded.

The decompose function will be used for decomposing elements that cause an S aggregate to cross max into smaller elements. For example:

The stream would emit the elements Chunk(1), Chunk(4), Chunk(1, 1).

Be vigilant with this function, it has to generate "simpler" values or the fold may never end. A value is considered indivisible if decompose yields the empty chunk or a single-valued chunk. In these cases, there is no other choice than to yield a value that will cross the threshold.

Sink.foldWeightedDecomposeEffect allows the decompose function to return an effect value, and consequently it allows the sink to fail.

Signature

declare const foldWeightedDecompose: <S, In>(options: {
  readonly body: (s: S, input: In) => S;
  readonly cost: (s: S, input: In) => number;
  readonly decompose: (input: In) => Chunk.Chunk<In>;
  readonly initial: S;
  readonly maxCost: number;
}) => Sink<S, In, In>

Example

pipe(
  Stream.make(1, 5, 1),
  Stream.transduce(
    Sink.foldWeightedDecompose(
      Chunk.empty<number>(),
      4,
      (n: number) => n,
      (n: number) => Chunk.make(n - 1, 1),
      (acc, el) => pipe(acc, Chunk.append(el))
    )
  ),
  Stream.runCollect
)

foldWeightedDecomposeEffect

Since v2.0.0

Creates a sink that effectfully folds elements of type In into a structure of type S, until max worth of elements (determined by the costFn) have been folded.

The decompose function will be used for decomposing elements that cause an S aggregate to cross max into smaller elements. Be vigilant with this function, it has to generate "simpler" values or the fold may never end. A value is considered indivisible if decompose yields the empty chunk or a single-valued chunk. In these cases, there is no other choice than to yield a value that will cross the threshold.

See Sink.foldWeightedDecompose for an example.

Signature

declare const foldWeightedDecomposeEffect: <S, In, E, R, E2, R2, E3, R3>(options: {
  readonly body: (s: S, input: In) => Effect.Effect<S, E3, R3>;
  readonly cost: (s: S, input: In) => Effect.Effect<number, E, R>;
  readonly decompose: (input: In) => Effect.Effect<Chunk.Chunk<In>, E2, R2>;
  readonly initial: S;
  readonly maxCost: number;
}) => Sink<S, In, In, E | E2 | E3, R | R2 | R3>

foldWeightedEffect

Since v2.0.0

Creates a sink that effectfully folds elements of type In into a structure of type S, until max worth of elements (determined by the costFn) have been folded.

Signature

declare const foldWeightedEffect: <S, In, E, R, E2, R2>(options: {
  readonly body: (s: S, input: In) => Effect.Effect<S, E2, R2>;
  readonly cost: (s: S, input: In) => Effect.Effect<number, E, R>;
  readonly initial: S;
  readonly maxCost: number;
}) => Sink<S, In, In, E | E2, R | R2>

forEach

Since v2.0.0

A sink that executes the provided effectful function for every element fed to it.

Signature

declare const forEach: <In, X, E, R>(f: (input: In) => Effect.Effect<X, E, R>) => Sink<void, In, never, E, R>

forEachChunk

Since v2.0.0

A sink that executes the provided effectful function for every chunk fed to it.

Signature

declare const forEachChunk: <In, X, E, R>(f: (input: Chunk.Chunk<In>) => Effect.Effect<X, E, R>) => Sink<void, In, never, E, R>

forEachChunkWhile

Since v2.0.0

A sink that executes the provided effectful function for every chunk fed to it until f evaluates to false.

Signature

declare const forEachChunkWhile: <In, E, R>(f: (input: Chunk.Chunk<In>) => Effect.Effect<boolean, E, R>) => Sink<void, In, In, E, R>

forEachWhile

Since v2.0.0

A sink that executes the provided effectful function for every element fed to it until f evaluates to false.

Signature

declare const forEachWhile: <In, E, R>(f: (input: In) => Effect.Effect<boolean, E, R>) => Sink<void, In, In, E, R>

fromChannel

Since v2.0.0

Creates a sink from a Channel.

Signature

declare const fromChannel: <L, In, E, A, R>(channel: Channel.Channel<Chunk.Chunk<L>, Chunk.Chunk<In>, E, never, A, unknown, R>) => Sink<A, In, L, E, R>

fromEffect

Since v2.0.0

Creates a single-value sink produced from an effect.

Signature

declare const fromEffect: <A, E, R>(effect: Effect.Effect<A, E, R>) => Sink<A, unknown, never, E, R>

fromPubSub

Since v2.0.0

Create a sink which publishes each element to the specified PubSub.

If the shutdown parameter is true, the PubSub will be shutdown after the sink is evaluated (defaults to false).

Signature

declare const fromPubSub: <In>(pubsub: PubSub.PubSub<In>, options?: {
  readonly shutdown?: boolean;
}) => Sink<void, In>

fromPush

Since v2.0.0

Creates a sink from a chunk processing function.

Signature

declare const fromPush: <In, L0, R0, L, R>(push: Effect.Effect<(_: Option.Option<Chunk.Chunk<In>>) => Effect.Effect<void, readonly [Either.Either<R0, L0>, Chunk.Chunk<L>], R>, never, R>) => Sink<R0, In, L, L0, Exclude<R, Scope.Scope>>

fromQueue

Since v2.0.0

Create a sink which enqueues each element into the specified queue.

If the shutdown parameter is true, the queue will be shutdown after the sink is evaluated (defaults to false).

Signature

declare const fromQueue: <In>(queue: Queue.Enqueue<In>, options?: {
  readonly shutdown?: boolean;
}) => Sink<void, In>

head

Since v2.0.0

Creates a sink containing the first value.

Signature

declare const head: <In>() => Sink<Option.Option<In>, In, In>

last

Since v2.0.0

Creates a sink containing the last value.

Signature

declare const last: <In>() => Sink<Option.Option<In>, In, In>

leftover

Since v2.0.0

Creates a sink that does not consume any input but provides the given chunk as its leftovers

Signature

declare const leftover: <L>(chunk: Chunk.Chunk<L>) => Sink<void, unknown, L>

mkString

Since v2.0.0

Creates a sink which transforms it's inputs into a string.

Signature

declare const mkString: Sink<string, unknown>

never

Since v2.0.0

Creates a sink which never terminates.

Signature

declare const never: Sink<never, unknown>

some

Since v2.0.0

A sink that returns whether an element satisfies the specified predicate.

Signature

declare const some: <In>(predicate: Predicate<In>) => Sink<boolean, In, In>

succeed

Since v2.0.0

A sink that immediately ends with the specified value.

Signature

declare const succeed: <A>(a: A) => Sink<A, unknown>

sum

Since v2.0.0

A sink that sums incoming numeric values.

Signature

declare const sum: Sink<number, number>

suspend

Since v2.0.0

Returns a lazily constructed sink that may require effects for its creation.

Signature

declare const suspend: <A, In, L, E, R>(evaluate: LazyArg<Sink<A, In, L, E, R>>) => Sink<A, In, L, E, R>

sync

Since v2.0.0

A sink that immediately ends with the specified lazy value.

Signature

declare const sync: <A>(evaluate: LazyArg<A>) => Sink<A, unknown>

take

Since v2.0.0

A sink that takes the specified number of values.

Signature

declare const take: <In>(n: number) => Sink<Chunk.Chunk<In>, In, In>

timed

Since v2.0.0

Signature

declare const timed: Sink<Duration.Duration, unknown>

toChannel

Since v2.0.0

Creates a Channel from a Sink.

Signature

declare const toChannel: <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Channel.Channel<Chunk.Chunk<L>, Chunk.Chunk<In>, E, never, A, unknown, R>

unwrap

Since v2.0.0

Creates a sink produced from an effect.

Signature

declare const unwrap: <A, In, L, E2, R2, E, R>(effect: Effect.Effect<Sink<A, In, L, E2, R2>, E, R>) => Sink<A, In, L, E2 | E, R2 | R>

unwrapScoped

Since v2.0.0

Creates a sink produced from a scoped effect.

Signature

declare const unwrapScoped: <A, In, L, E, R>(effect: Effect.Effect<Sink<A, In, L, E, R>, E, R>) => Sink<A, In, L, E, Exclude<R, Scope.Scope>>

unwrapScopedWith

Since v3.11.0

Constructs a Sink from a function which receives a Scope and returns an effect that will result in a Sink if successful.

Signature

declare const unwrapScopedWith: <A, In, L, E, R>(f: (scope: Scope.Scope) => Effect.Effect<Sink<A, In, L, E, R>, E, R>) => Sink<A, In, L, E, R>

Context

provideContext

Since v2.0.0

Provides the sink with its required context, which eliminates its dependency on R.

Signature

declare const provideContext: {
  <R>(context: Context<R>): <A, In, L, E>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, never>;
  <A, In, L, E, R>(self: Sink<A, In, L, E, R>, context: Context<R>): Sink<A, In, L, E, never>;
}

Elements

findEffect

Since v2.0.0

Creates a sink that produces values until one verifies the predicate f.

Signature

declare const findEffect: {
  <A, E2, R2>(f: (a: A) => Effect<boolean, E2, R2>): <In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<Option<A>, In, L, E2 | E, R2 | R>;
  <A, In, L, E, R, E2, R2>(self: Sink<A, In, L, E, R>, f: (a: A) => Effect<boolean, E2, R2>): Sink<Option<A>, In, L, E | E2, R | R2>;
}

Error Handling

orElse

Since v2.0.0

Switch to another sink in case of failure

Signature

declare const orElse: {
  <A2, In2, L2, E2, R2>(that: LazyArg<Sink<A2, In2, L2, E2, R2>>): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2 | A, In & In2, L2 | L, E2 | E, R2 | R>;
  <A, In, L, E, R, A2, In2, L2, E2, R2>(self: Sink<A, In, L, E, R>, that: LazyArg<Sink<A2, In2, L2, E2, R2>>): Sink<A | A2, In & In2, L | L2, E | E2, R | R2>;
}

refineOrDie

Since v2.0.0

Signature

declare const refineOrDie: {
  <E, E2>(pf: (error: E) => Option<E2>): <A, In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E2, R>;
  <A, In, L, E, R, E2>(self: Sink<A, In, L, E, R>, pf: (error: E) => Option<E2>): Sink<A, In, L, E2, R>;
}

refineOrDieWith

Since v2.0.0

Signature

declare const refineOrDieWith: {
  <E, E2>(pf: (error: E) => Option<E2>, f: (error: E) => unknown): <A, In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E2, R>;
  <A, In, L, E, R, E2>(self: Sink<A, In, L, E, R>, pf: (error: E) => Option<E2>, f: (error: E) => unknown): Sink<A, In, L, E2, R>;
}

Filtering

filterInput

Since v2.0.0

Filters the sink's input with the given predicate.

Signature

declare const filterInput: {
  <In, In1, In2>(f: Refinement<In1, In2>): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In2, L, E, R>;
  <In, In1>(f: Predicate<In1>): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In1, L, E, R>;
}

filterInputEffect

Since v2.0.0

Effectfully filter the input of this sink using the specified predicate.

Signature

declare const filterInputEffect: {
  <In, In1, E2, R2>(f: (input: In1) => Effect<boolean, E2, R2>): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In1, L, E2 | E, R2 | R>;
  <A, In, L, E, R, In1, E2, R2>(self: Sink<A, In, L, E, R>, f: (input: In1) => Effect<boolean, E2, R2>): Sink<A, In1, L, E | E2, R | R2>;
}

Finalization

ensuring

Since v2.0.0

Returns a new sink with an attached finalizer. The finalizer is guaranteed to be executed so long as the sink begins execution (and regardless of whether or not it completes).

Signature

declare const ensuring: {
  <X, R2>(finalizer: Effect<X, never, R2>): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, R2 | R>;
  <A, In, L, E, R, X, R2>(self: Sink<A, In, L, E, R>, finalizer: Effect<X, never, R2>): Sink<A, In, L, E, R | R2>;
}

ensuringWith

Since v2.0.0

Returns a new sink with an attached finalizer. The finalizer is guaranteed to be executed so long as the sink begins execution (and regardless of whether or not it completes).

Signature

declare const ensuringWith: {
  <A, E, X, R2>(finalizer: (exit: Exit<A, E>) => Effect<X, never, R2>): <In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E, R2 | R>;
  <A, In, L, E, R, X, R2>(self: Sink<A, In, L, E, R>, finalizer: (exit: Exit<A, E>) => Effect<X, never, R2>): Sink<A, In, L, E, R | R2>;
}

Folding

fold

Since v2.0.0

A sink that folds its inputs with the provided function, termination predicate and initial state.

Signature

declare const fold: <S, In>(s: S, contFn: Predicate<S>, f: (s: S, input: In) => S) => Sink<S, In, In>

foldSink

Since v2.0.0

Folds over the result of the sink

Signature

declare const foldSink: {
  <E, A1, In, In1, L1, E1, R1, A, A2, In2, L2, E2, R2>(options: {
    readonly onFailure: (err: E) => Sink<A1, In1, L1, E1, R1>;
    readonly onSuccess: (a: A) => Sink<A2, In2, L2, E2, R2>;
  }): <L, R>(self: Sink<A, In, L, E, R>) => Sink<A1 | A2, In1 & In2, L1 | L2, E1 | E2, R1 | R2 | R>;
  <A, In, L, E, R, A1, In1, L1, E1, R1, A2, In2, L2, E2, R2>(self: Sink<A, In, L, E, R>, options: {
    readonly onFailure: (err: E) => Sink<A1, In1, L1, E1, R1>;
    readonly onSuccess: (a: A) => Sink<A2, In2, L2, E2, R2>;
  }): Sink<A1 | A2, In1 & In2, L1 | L2, E1 | E2, R | R1 | R2>;
}

Mapping

as

Since v2.0.0

Replaces this sink's result with the provided value.

Signature

declare const as: {
  <A2>(a: A2): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In, L, E, R>;
  <A, In, L, E, R, A2>(self: Sink<A, In, L, E, R>, a: A2): Sink<A2, In, L, E, R>;
}

dimap

Since v2.0.0

Transforms both inputs and result of this sink using the provided functions.

Signature

declare const dimap: {
  <In0, In, A, A2>(options: {
    readonly onDone: (a: A) => A2;
    readonly onInput: (input: In0) => In;
  }): <L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In0, L, E, R>;
  <A, In, L, E, R, In0, A2>(self: Sink<A, In, L, E, R>, options: {
    readonly onDone: (a: A) => A2;
    readonly onInput: (input: In0) => In;
  }): Sink<A2, In0, L, E, R>;
}

dimapChunks

Since v2.0.0

Transforms both input chunks and result of this sink using the provided functions.

Signature

declare const dimapChunks: {
  <In0, In, A, A2>(options: {
    readonly onDone: (a: A) => A2;
    readonly onInput: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>;
  }): <L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In0, L, E, R>;
  <A, In, L, E, R, In0, A2>(self: Sink<A, In, L, E, R>, options: {
    readonly onDone: (a: A) => A2;
    readonly onInput: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>;
  }): Sink<A2, In0, L, E, R>;
}

dimapChunksEffect

Since v2.0.0

Effectfully transforms both input chunks and result of this sink using the provided functions. f and g must preserve chunking-invariance.

Signature

declare const dimapChunksEffect: {
  <In0, In, E2, R2, A, A2, E3, R3>(options: {
    readonly onDone: (a: A) => Effect.Effect<A2, E3, R3>;
    readonly onInput: (chunk: Chunk.Chunk<In0>) => Effect.Effect<Chunk.Chunk<In>, E2, R2>;
  }): <L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In0, L, E2 | E3 | E, R2 | R3 | R>;
  <A, In, L, E, R, In0, E2, R2, A2, E3, R3>(self: Sink<A, In, L, E, R>, options: {
    readonly onDone: (a: A) => Effect.Effect<A2, E3, R3>;
    readonly onInput: (chunk: Chunk.Chunk<In0>) => Effect.Effect<Chunk.Chunk<In>, E2, R2>;
  }): Sink<A2, In0, L, E | E2 | E3, R | R2 | R3>;
}

dimapEffect

Since v2.0.0

Effectfully transforms both inputs and result of this sink using the provided functions.

Signature

declare const dimapEffect: {
  <In0, In, E2, R2, A, A2, E3, R3>(options: {
    readonly onDone: (a: A) => Effect.Effect<A2, E3, R3>;
    readonly onInput: (input: In0) => Effect.Effect<In, E2, R2>;
  }): <L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In0, L, E2 | E3 | E, R2 | R3 | R>;
  <A, In, L, E, R, In0, E2, R2, A2, E3, R3>(self: Sink<A, In, L, E, R>, options: {
    readonly onDone: (a: A) => Effect.Effect<A2, E3, R3>;
    readonly onInput: (input: In0) => Effect.Effect<In, E2, R2>;
  }): Sink<A2, In0, L, E | E2 | E3, R | R2 | R3>;
}

map

Since v2.0.0

Transforms this sink's result.

Signature

declare const map: {
  <A, A2>(f: (a: A) => A2): <In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In, L, E, R>;
  <A, In, L, E, R, A2>(self: Sink<A, In, L, E, R>, f: (a: A) => A2): Sink<A2, In, L, E, R>;
}

mapEffect

Since v2.0.0

Effectfully transforms this sink's result.

Signature

declare const mapEffect: {
  <A, A2, E2, R2>(f: (a: A) => Effect<A2, E2, R2>): <In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In, L, E2 | E, R2 | R>;
  <A, In, L, E, R, A2, E2, R2>(self: Sink<A, In, L, E, R>, f: (a: A) => Effect<A2, E2, R2>): Sink<A2, In, L, E | E2, R | R2>;
}

mapError

Since v2.0.0

Transforms the errors emitted by this sink using f.

Signature

declare const mapError: {
  <E, E2>(f: (error: E) => E2): <A, In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L, E2, R>;
  <A, In, L, E, R, E2>(self: Sink<A, In, L, E, R>, f: (error: E) => E2): Sink<A, In, L, E2, R>;
}

mapInput

Since v2.0.0

Transforms this sink's input elements.

Signature

declare const mapInput: {
  <In0, In>(f: (input: In0) => In): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In0, L, E, R>;
  <A, In, L, E, R, In0>(self: Sink<A, In, L, E, R>, f: (input: In0) => In): Sink<A, In0, L, E, R>;
}

mapInputChunks

Since v2.0.0

Transforms this sink's input chunks. f must preserve chunking-invariance.

Signature

declare const mapInputChunks: {
  <In0, In>(f: (chunk: Chunk<In0>) => Chunk<In>): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In0, L, E, R>;
  <A, In, L, E, R, In0>(self: Sink<A, In, L, E, R>, f: (chunk: Chunk<In0>) => Chunk<In>): Sink<A, In0, L, E, R>;
}

mapInputChunksEffect

Since v2.0.0

Effectfully transforms this sink's input chunks. f must preserve chunking-invariance.

Signature

declare const mapInputChunksEffect: {
  <In0, In, E2, R2>(f: (chunk: Chunk<In0>) => Effect<Chunk<In>, E2, R2>): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In0, L, E2 | E, R2 | R>;
  <A, In, L, E, R, In0, E2, R2>(self: Sink<A, In, L, E, R>, f: (chunk: Chunk<In0>) => Effect<Chunk<In>, E2, R2>): Sink<A, In0, L, E | E2, R | R2>;
}

mapInputEffect

Since v2.0.0

Effectfully transforms this sink's input elements.

Signature

declare const mapInputEffect: {
  <In0, In, E2, R2>(f: (input: In0) => Effect<In, E2, R2>): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In0, L, E2 | E, R2 | R>;
  <A, In, L, E, R, In0, E2, R2>(self: Sink<A, In, L, E, R>, f: (input: In0) => Effect<In, E2, R2>): Sink<A, In0, L, E | E2, R | R2>;
}

mapLeftover

Since v2.0.0

Transforms the leftovers emitted by this sink using f.

Signature

declare const mapLeftover: {
  <L, L2>(f: (leftover: L) => L2): <A, In, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, L2, E, R>;
  <A, In, L, E, R, L2>(self: Sink<A, In, L, E, R>, f: (leftover: L) => L2): Sink<A, In, L2, E, R>;
}

Models

Sink

interface

Since v2.0.0

A Sink<A, In, L, E, R> is used to consume elements produced by a Stream. You can think of a sink as a function that will consume a variable amount of In elements (could be 0, 1, or many), might fail with an error of type E, and will eventually yield a value of type A together with a remainder of type L (i.e. any leftovers).

Signature

interface Sink<out A, in In = unknown, out L = never, out E = never, out R = never> extends Variance<A, In, L, E, R>, Pipeable {}

SinkUnify

interface

Since v2.0.0

Signature

interface SinkUnify<A extends {
  [typeSymbol]?: any;
}> extends EffectUnify<A> {
  Sink?: () => A[typeof typeSymbol] extends Sink<A, In, L, E, R> | _ ? Sink<A, In, L, E, R> : never;
}

SinkUnifyIgnore

interface

Since v2.0.0

Signature

interface SinkUnifyIgnore extends EffectUnifyIgnore {
  Sink?: true;
}

Other

Sink

Since v2.0.0

Sequencing

flatMap

Since v2.0.0

Runs this sink until it yields a result, then uses that result to create another sink from the provided function which will continue to run until it yields a result.

This function essentially runs sinks in sequence.

Signature

declare const flatMap: {
  <A, A1, In, In1, L1, E1, R1>(f: (a: A) => Sink<A1, In1, L1, E1, R1>): <L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A1, In & In1, L1 | L, E1 | E, R1 | R>;
  <A, In, L, E, R, A1, In1, L1, E1, R1>(self: Sink<A, In, L, E, R>, f: (a: A) => Sink<A1, In1, L1, E1, R1>): Sink<A1, In & In1, L | L1, E | E1, R | R1>;
}

Symbols

SinkTypeId

Since v2.0.0

Signature

declare const SinkTypeId: unique symbol

SinkTypeId

type

Since v2.0.0

Signature

type SinkTypeId = typeof SinkTypeId

Utils

collectAllFrom

Since v2.0.0

Repeatedly runs the sink and accumulates its results into a Chunk.

Signature

declare const collectAllFrom: <A, In, L extends In, E, R>(self: Sink<A, In, L, E, R>) => Sink<Chunk.Chunk<A>, In, L, E, R>

collectAllWhileWith

Since v2.0.0

Repeatedly runs the sink for as long as its results satisfy the predicate p. The sink's results will be accumulated using the stepping function f.

Signature

declare const collectAllWhileWith: {
  <A, S>(options: {
    readonly body: (s: S, a: A) => S;
    readonly initial: S;
    readonly while: Predicate<A>;
  }): <In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<S, In, L, E, R>;
  <A, In, L, E, R, S>(self: Sink<A, In, L, E, R>, options: {
    readonly body: (s: S, a: A) => S;
    readonly initial: S;
    readonly while: Predicate<A>;
  }): Sink<S, In, L, E, R>;
}

collectLeftover

Since v2.0.0

Collects the leftovers from the stream when the sink succeeds and returns them as part of the sink's result.

Signature

declare const collectLeftover: <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<[A, Chunk.Chunk<L>], In, never, E, R>

ignoreLeftover

Since v2.0.0

Drains the remaining elements from the stream after the sink finishes

Signature

declare const ignoreLeftover: <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, never, E, R>

race

Since v2.0.0

Runs both sinks in parallel on the input, , returning the result or the error from the one that finishes first.

Signature

declare const race: {
  <R1, E1, In1, L1, A1>(that: Sink<A1, In1, L1, E1, R1>): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A1 | A, In & In1, L1 | L, E1 | E, R1 | R>;
  <A, In, L, E, R, A1, In1, L1, E1, R1>(self: Sink<A, In, L, E, R>, that: Sink<A1, In1, L1, E1, R1>): Sink<A | A1, In & In1, L | L1, E | E1, R | R1>;
}

raceBoth

Since v2.0.0

Runs both sinks in parallel on the input, returning the result or the error from the one that finishes first.

Signature

declare const raceBoth: {
  <A1, In1, L1, E1, R1>(that: Sink<A1, In1, L1, E1, R1>, options?: {
    readonly capacity?: number;
  }): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<Either<A1, A>, In & In1, L1 | L, E1 | E, R1 | R>;
  <A, In, L, E, R, A1, In1, L1, E1, R1>(self: Sink<A, In, L, E, R>, that: Sink<A1, In1, L1, E1, R1>, options?: {
    readonly capacity?: number;
  }): Sink<Either<A1, A>, In & In1, L | L1, E | E1, R | R1>;
}

raceWith

Since v2.0.0

Runs both sinks in parallel on the input, using the specified merge function as soon as one result or the other has been computed.

Signature

declare const raceWith: {
  <A2, In2, L2, E2, R2, A, E, A3, A4>(options: {
    readonly capacity?: number;
    readonly onOtherDone: (exit: Exit.Exit<A2, E2>) => MergeDecision.MergeDecision<R2, E, A, E2 | E, A4>;
    readonly onSelfDone: (exit: Exit.Exit<A, E>) => MergeDecision.MergeDecision<R2, E2, A2, E2 | E, A3>;
    readonly other: Sink<A2, In2, L2, E2, R2>;
  }): <In, L, R>(self: Sink<A, In, L, E, R>) => Sink<A3 | A4, In & In2, L2 | L, E2 | E, R2 | R>;
  <A, In, L, E, R, A2, In2, L2, E2, R2, A3, A4>(self: Sink<A, In, L, E, R>, options: {
    readonly capacity?: number;
    readonly onOtherDone: (exit: Exit.Exit<A2, E2>) => MergeDecision.MergeDecision<R2, E, A, E | E2, A4>;
    readonly onSelfDone: (exit: Exit.Exit<A, E>) => MergeDecision.MergeDecision<R2, E2, A2, E | E2, A3>;
    readonly other: Sink<A2, In2, L2, E2, R2>;
  }): Sink<A3 | A4, In & In2, L | L2, E | E2, R | R2>;
}

splitWhere

Since v2.0.0

Splits the sink on the specified predicate, returning a new sink that consumes elements until an element after the first satisfies the specified predicate.

Signature

declare const splitWhere: {
  <In>(f: Predicate<In>): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, In, E, R>;
  <A, In, L, E, R>(self: Sink<A, In, L, E, R>, f: Predicate<In>): Sink<A, In, In, E, R>;
}

summarized

Since v2.0.0

Summarize a sink by running an effect when the sink starts and again when it completes.

Signature

declare const summarized: {
  <A2, E2, R2, A3>(summary: Effect<A2, E2, R2>, f: (start: A2, end: A2) => A3): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<[A, A3], In, L, E2 | E, R2 | R>;
  <A, In, L, E, R, A2, E2, R2, A3>(self: Sink<A, In, L, E, R>, summary: Effect<A2, E2, R2>, f: (start: A2, end: A2) => A3): Sink<[A, A3], In, L, E | E2, R | R2>;
}

withDuration

Since v2.0.0

Returns the sink that executes this one and times its execution.

Signature

declare const withDuration: <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<[A, Duration.Duration], In, L, E, R>

Zipping

zip

Since v2.0.0

Feeds inputs to this sink until it yields a result, then switches over to the provided sink until it yields a result, finally combining the two results into a tuple.

Signature

declare const zip: {
  <A2, In, In2, L2, E2, R2>(that: Sink<A2, In2, L2, E2, R2>, options?: {
    readonly concurrent?: boolean;
  }): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<[A, A2], In & In2, L2 | L, E2 | E, R2 | R>;
  <A, In, L, E, R, A2, In2, L2, E2, R2>(self: Sink<A, In, L, E, R>, that: Sink<A2, In2, L2, E2, R2>, options?: {
    readonly concurrent?: boolean;
  }): Sink<[A, A2], In & In2, L | L2, E | E2, R | R2>;
}

zipLeft

Since v2.0.0

Like Sink.zip but keeps only the result from this sink.

Signature

declare const zipLeft: {
  <A2, In, In2, L2, E2, R2>(that: Sink<A2, In2, L2, E2, R2>, options?: {
    readonly concurrent?: boolean;
  }): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In & In2, L2 | L, E2 | E, R2 | R>;
  <A, In, L, E, R, A2, In2, L2, E2, R2>(self: Sink<A, In, L, E, R>, that: Sink<A2, In2, L2, E2, R2>, options?: {
    readonly concurrent?: boolean;
  }): Sink<A, In & In2, L | L2, E | E2, R | R2>;
}

zipRight

Since v2.0.0

Like Sink.zip but keeps only the result from that sink.

Signature

declare const zipRight: {
  <A2, In, In2, L2, E2, R2>(that: Sink<A2, In2, L2, E2, R2>, options?: {
    readonly concurrent?: boolean;
  }): <A, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A2, In & In2, L2 | L, E2 | E, R2 | R>;
  <A, In, L, E, R, A2, In2, L2, E2, R2>(self: Sink<A, In, L, E, R>, that: Sink<A2, In2, L2, E2, R2>, options?: {
    readonly concurrent?: boolean;
  }): Sink<A2, In & In2, L | L2, E | E2, R | R2>;
}

zipWith

Since v2.0.0

Feeds inputs to this sink until it yields a result, then switches over to the provided sink until it yields a result, finally combining the two results with f.

Signature

declare const zipWith: {
  <A2, In, In2, L2, E2, R2, A, A3>(that: Sink<A2, In2, L2, E2, R2>, f: (a: A, a2: A2) => A3, options?: {
    readonly concurrent?: boolean;
  }): <L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A3, In & In2, L2 | L, E2 | E, R2 | R>;
  <A, In, L, E, R, A2, In2, L2, E2, R2, A3>(self: Sink<A, In, L, E, R>, that: Sink<A2, In2, L2, E2, R2>, f: (a: A, a2: A2) => A3, options?: {
    readonly concurrent?: boolean;
  }): Sink<A3, In & In2, L | L2, E | E2, R | R2>;
}