Skip to main content Link Search Menu Expand Document (external link)
effect

Sink.ts overview

Since v2.0.0

Exports Grouped by Category

constructors

collectAll

A sink that collects all elements into a Chunk.

Signature

declare const collectAll: <In>() => Sink<Chunk.Chunk<In>, In>

Source

Since v2.0.0

collectAllN

A sink that collects first n elements into a chunk.

Signature

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

Source

Since v2.0.0

collectAllToMap

A sink that collects all of its inputs into a map. The keys are extracted from inputs using the keying function key; if multiple inputs use the same key, they are merged using the merge function.

Signature

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

Source

Since v2.0.0

collectAllToMapN

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>

Source

Since v2.0.0

collectAllToSet

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

Signature

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

Source

Since v2.0.0

collectAllToSetN

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

Signature

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

Source

Since v2.0.0

collectAllUntil

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>

Source

Since v2.0.0

collectAllUntilEffect

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>

Source

Since v2.0.0

collectAllWhile

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

Signature

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

Source

Since v2.0.0

collectAllWhileEffect

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>

Source

Since v2.0.0

context

Accesses the whole context of the sink.

Signature

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

Source

Since v2.0.0

contextWith

Accesses the context of the sink.

Signature

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

Source

Since v2.0.0

contextWithEffect

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>

Source

Since v2.0.0

contextWithSink

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>

Source

Since v2.0.0

count

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

Signature

declare const count: Sink<number, unknown, never, never, never>

Source

Since v2.0.0

die

Creates a sink halting with the specified defect.

Signature

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

Source

Since v2.0.0

dieMessage

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

Signature

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

Source

Since v2.0.0

dieSync

Creates a sink halting with the specified defect.

Signature

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

Source

Since v2.0.0

drain

A sink that ignores its inputs.

Signature

declare const drain: Sink<void, unknown, never, never, never>

Source

Since v2.0.0

drop

Creates a sink that drops n elements.

Signature

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

Source

Since v2.0.0

dropUntil

Drops incoming elements until the predicate is satisfied.

Signature

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

Source

Since v2.0.0

dropUntilEffect

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>

Source

Since v2.0.0

dropWhile

Drops incoming elements as long as the predicate is satisfied.

Signature

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

Source

Since v2.0.0

dropWhileEffect

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>

Source

Since v2.0.0

every

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

Signature

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

Source

Since v2.0.0

fail

A sink that always fails with the specified error.

Signature

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

Source

Since v2.0.0

failCause

Creates a sink halting with a specified Cause.

Signature

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

Source

Since v2.0.0

failCauseSync

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>

Source

Since v2.0.0

failSync

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

Signature

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

Source

Since v2.0.0

foldChunks

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>

Source

Since v2.0.0

foldChunksEffect

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>

Source

Since v2.0.0

foldEffect

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>

Source

Since v2.0.0

foldLeft

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>

Source

Since v2.0.0

foldLeftChunks

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>

Source

Since v2.0.0

foldLeftChunksEffect

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>

Source

Since v2.0.0

foldLeftEffect

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>

Source

Since v2.0.0

foldUntil

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>

Source

Since v2.0.0

foldUntilEffect

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>

Source

Since v2.0.0

foldWeighted

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 initial: S
  readonly maxCost: number
  readonly cost: (s: S, input: In) => number
  readonly body: (s: S, input: In) => S
}) => Sink<S, In, In>

Source

Since v2.0.0

foldWeightedDecompose

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:

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
)

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 initial: S
  readonly maxCost: number
  readonly cost: (s: S, input: In) => number
  readonly decompose: (input: In) => Chunk.Chunk<In>
  readonly body: (s: S, input: In) => S
}) => Sink<S, In, In>

Source

Since v2.0.0

foldWeightedDecomposeEffect

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 initial: S
  readonly maxCost: number
  readonly cost: (s: S, input: In) => Effect.Effect<number, E, R>
  readonly decompose: (input: In) => Effect.Effect<Chunk.Chunk<In>, E2, R2>
  readonly body: (s: S, input: In) => Effect.Effect<S, E3, R3>
}) => Sink<S, In, In, E | E2 | E3, R | R2 | R3>

Source

Since v2.0.0

foldWeightedEffect

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 initial: S
  readonly maxCost: number
  readonly cost: (s: S, input: In) => Effect.Effect<number, E, R>
  readonly body: (s: S, input: In) => Effect.Effect<S, E2, R2>
}) => Sink<S, In, In, E | E2, R | R2>

Source

Since v2.0.0

forEach

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>

Source

Since v2.0.0

forEachChunk

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>

Source

Since v2.0.0

forEachChunkWhile

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>

Source

Since v2.0.0

forEachWhile

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>

Source

Since v2.0.0

fromChannel

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>

Source

Since v2.0.0

fromEffect

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>

Source

Since v2.0.0

fromPubSub

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 | undefined }
) => Sink<void, In>

Source

Since v2.0.0

fromPush

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

Source

Since v2.0.0

fromQueue

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 | undefined }
) => Sink<void, In>

Source

Since v2.0.0

Creates a sink containing the first value.

Signature

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

Source

Since v2.0.0

last

Creates a sink containing the last value.

Signature

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

Source

Since v2.0.0

leftover

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>

Source

Since v2.0.0

mkString

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

Signature

declare const mkString: Sink<string, unknown, never, never, never>

Source

Since v2.0.0

never

Creates a sink which never terminates.

Signature

declare const never: Sink<never, unknown, never, never, never>

Source

Since v2.0.0

some

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

Signature

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

Source

Since v2.0.0

succeed

A sink that immediately ends with the specified value.

Signature

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

Source

Since v2.0.0

sum

A sink that sums incoming numeric values.

Signature

declare const sum: Sink<number, number, never, never, never>

Source

Since v2.0.0

suspend

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>

Source

Since v2.0.0

sync

A sink that immediately ends with the specified lazy value.

Signature

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

Source

Since v2.0.0

take

A sink that takes the specified number of values.

Signature

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

Source

Since v2.0.0

timed

Signature

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

Source

Since v2.0.0

toChannel

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>

Source

Since v2.0.0

unwrap

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>

Source

Since v2.0.0

unwrapScoped

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

Source

Since v2.0.0

unwrapScopedWith

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>

Source

Since v3.11.0

context

provideContext

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

Signature

declare const provideContext: {
  <R>(context: 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.Context<R>): Sink<A, In, L, E, never>
}

Source

Since v2.0.0

elements

findEffect

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

Signature

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

Source

Since v2.0.0

error handling

orElse

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>
}

Source

Since v2.0.0

refineOrDie

Signature

declare const refineOrDie: {
  <E, E2>(pf: (error: E) => Option.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.Option<E2>): Sink<A, In, L, E2, R>
}

Source

Since v2.0.0

refineOrDieWith

Signature

declare const refineOrDieWith: {
  <E, E2>(
    pf: (error: E) => Option.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.Option<E2>,
    f: (error: E) => unknown
  ): Sink<A, In, L, E2, R>
}

Source

Since v2.0.0

filtering

filterInput

Filters the sink’s input with the given predicate.

Signature

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

Source

Since v2.0.0

filterInputEffect

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

Signature

declare const filterInputEffect: {
  <In, In1 extends In, E2, R2>(
    f: (input: In1) => Effect.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 extends In, E2, R2>(
    self: Sink<A, In, L, E, R>,
    f: (input: In1) => Effect.Effect<boolean, E2, R2>
  ): Sink<A, In1, L, E | E2, R | R2>
}

Source

Since v2.0.0

finalization

ensuring

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.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.Effect<X, never, R2>): Sink<A, In, L, E, R | R2>
}

Source

Since v2.0.0

ensuringWith

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.Exit<A, E>) => Effect.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.Exit<A, E>) => Effect.Effect<X, never, R2>
  ): Sink<A, In, L, E, R | R2>
}

Source

Since v2.0.0

folding

fold

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>

Source

Since v2.0.0

foldSink

Folds over the result of the sink

Signature

declare const foldSink: {
  <E, A1, In, In1 extends In, L1, E1, R1, A, A2, In2 extends In, 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 extends In, L1, E1, R1, A2, In2 extends In, 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>
}

Source

Since v2.0.0

mapping

as

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>
}

Source

Since v2.0.0

dimap

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

Signature

declare const dimap: {
  <In0, In, A, A2>(options: {
    readonly onInput: (input: In0) => In
    readonly onDone: (a: A) => A2
  }): <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 onInput: (input: In0) => In; readonly onDone: (a: A) => A2 }
  ): Sink<A2, In0, L, E, R>
}

Source

Since v2.0.0

dimapChunks

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

Signature

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

Source

Since v2.0.0

dimapChunksEffect

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 onInput: (chunk: Chunk.Chunk<In0>) => Effect.Effect<Chunk.Chunk<In>, E2, R2>
    readonly onDone: (a: A) => Effect.Effect<A2, E3, R3>
  }): <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 onInput: (chunk: Chunk.Chunk<In0>) => Effect.Effect<Chunk.Chunk<In>, E2, R2>
      readonly onDone: (a: A) => Effect.Effect<A2, E3, R3>
    }
  ): Sink<A2, In0, L, E | E2 | E3, R | R2 | R3>
}

Source

Since v2.0.0

dimapEffect

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 onInput: (input: In0) => Effect.Effect<In, E2, R2>
    readonly onDone: (a: A) => Effect.Effect<A2, E3, R3>
  }): <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 onInput: (input: In0) => Effect.Effect<In, E2, R2>
      readonly onDone: (a: A) => Effect.Effect<A2, E3, R3>
    }
  ): Sink<A2, In0, L, E | E2 | E3, R | R2 | R3>
}

Source

Since v2.0.0

map

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>
}

Source

Since v2.0.0

mapEffect

Effectfully transforms this sink’s result.

Signature

declare const mapEffect: {
  <A, A2, E2, R2>(
    f: (a: A) => Effect.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.Effect<A2, E2, R2>
  ): Sink<A2, In, L, E | E2, R | R2>
}

Source

Since v2.0.0

mapError

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>
}

Source

Since v2.0.0

mapInput

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>
}

Source

Since v2.0.0

mapInputChunks

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

Signature

declare const mapInputChunks: {
  <In0, In>(
    f: (chunk: Chunk.Chunk<In0>) => Chunk.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.Chunk<In0>) => Chunk.Chunk<In>
  ): Sink<A, In0, L, E, R>
}

Source

Since v2.0.0

mapInputChunksEffect

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

Signature

declare const mapInputChunksEffect: {
  <In0, In, E2, R2>(
    f: (chunk: Chunk.Chunk<In0>) => Effect.Effect<Chunk.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.Chunk<In0>) => Effect.Effect<Chunk.Chunk<In>, E2, R2>
  ): Sink<A, In0, L, E | E2, R | R2>
}

Source

Since v2.0.0

mapInputEffect

Effectfully transforms this sink’s input elements.

Signature

declare const mapInputEffect: {
  <In0, In, E2, R2>(
    f: (input: In0) => Effect.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.Effect<In, E2, R2>
  ): Sink<A, In0, L, E | E2, R | R2>
}

Source

Since v2.0.0

mapLeftover

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>
}

Source

Since v2.0.0

models

Sink (interface)

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

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

Source

Since v2.0.0

SinkUnify (interface)

Signature

export interface SinkUnify<A extends { [Unify.typeSymbol]?: any }> extends Effect.EffectUnify<A> {
  Sink?: () => A[Unify.typeSymbol] extends Sink<infer A, infer In, infer L, infer E, infer R> | infer _
    ? Sink<A, In, L, E, R>
    : never
}

Source

Since v2.0.0

SinkUnifyIgnore (interface)

Signature

export interface SinkUnifyIgnore extends Effect.EffectUnifyIgnore {
  Sink?: true
}

Source

Since v2.0.0

sequencing

flatMap

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 extends In, 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 extends In, 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>
}

Source

Since v2.0.0

symbols

SinkTypeId

Signature

declare const SinkTypeId: unique symbol

Source

Since v2.0.0

SinkTypeId (type alias)

Signature

type SinkTypeId = typeof SinkTypeId

Source

Since v2.0.0

utils

Sink (namespace)

Source

Since v2.0.0

Variance (interface)

Signature

export interface Variance<out A, in In, out L, out E, out R> {
  readonly [SinkTypeId]: VarianceStruct<A, In, L, E, R>
}

Source

Since v2.0.0

VarianceStruct (interface)

Signature

export interface VarianceStruct<out A, in In, out L, out E, out R> {
  _A: Types.Covariant<A>
  _In: Types.Contravariant<In>
  _L: Types.Covariant<L>
  _E: Types.Covariant<E>
  _R: Types.Covariant<R>
}

Source

Since v2.0.0

collectAllFrom

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>

Source

Since v2.0.0

collectAllWhileWith

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 initial: S
    readonly while: Predicate<A>
    readonly body: (s: S, a: A) => S
  }): <In, L extends In, E, R>(self: Sink<A, In, L, E, R>) => Sink<S, In, L, E, R>
  <A, In, L extends In, E, R, S>(
    self: Sink<A, In, L, E, R>,
    options: { readonly initial: S; readonly while: Predicate<A>; readonly body: (s: S, a: A) => S }
  ): Sink<S, In, L, E, R>
}

Source

Since v2.0.0

collectLeftover

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>

Source

Since v2.0.0

ignoreLeftover

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>

Source

Since v2.0.0

race

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>
}

Source

Since v2.0.0

raceBoth

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 | undefined } | undefined
  ): <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<Either.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 | undefined } | undefined
  ): Sink<Either.Either<A1, A>, In & In1, L | L1, E | E1, R | R1>
}

Source

Since v2.0.0

raceWith

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 other: Sink<A2, In2, L2, E2, R2>
    readonly onSelfDone: (exit: Exit.Exit<A, E>) => MergeDecision.MergeDecision<R2, E2, A2, E2 | E, A3>
    readonly onOtherDone: (exit: Exit.Exit<A2, E2>) => MergeDecision.MergeDecision<R2, E, A, E2 | E, A4>
    readonly capacity?: number | undefined
  }): <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 other: Sink<A2, In2, L2, E2, R2>
      readonly onSelfDone: (exit: Exit.Exit<A, E>) => MergeDecision.MergeDecision<R2, E2, A2, E | E2, A3>
      readonly onOtherDone: (exit: Exit.Exit<A2, E2>) => MergeDecision.MergeDecision<R2, E, A, E | E2, A4>
      readonly capacity?: number | undefined
    }
  ): Sink<A3 | A4, In & In2, L | L2, E | E2, R | R2>
}

Source

Since v2.0.0

splitWhere

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 extends In, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, In, E, R>
  <A, In, L extends In, E, R>(self: Sink<A, In, L, E, R>, f: Predicate<In>): Sink<A, In, In, E, R>
}

Source

Since v2.0.0

summarized

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.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.Effect<A2, E2, R2>,
    f: (start: A2, end: A2) => A3
  ): Sink<[A, A3], In, L, E | E2, R | R2>
}

Source

Since v2.0.0

withDuration

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>

Source

Since v2.0.0

zipping

zip

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 extends In, L2, E2, R2>(
    that: Sink<A2, In2, L2, E2, R2>,
    options?: { readonly concurrent?: boolean | undefined } | undefined
  ): <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 extends In, L2, E2, R2>(
    self: Sink<A, In, L, E, R>,
    that: Sink<A2, In2, L2, E2, R2>,
    options?: { readonly concurrent?: boolean | undefined } | undefined
  ): Sink<[A, A2], In & In2, L | L2, E | E2, R | R2>
}

Source

Since v2.0.0

zipLeft

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

Signature

declare const zipLeft: {
  <A2, In, In2 extends In, L2, E2, R2>(
    that: Sink<A2, In2, L2, E2, R2>,
    options?: { readonly concurrent?: boolean | undefined } | undefined
  ): <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 extends In, L2, E2, R2>(
    self: Sink<A, In, L, E, R>,
    that: Sink<A2, In2, L2, E2, R2>,
    options?: { readonly concurrent?: boolean | undefined } | undefined
  ): Sink<A, In & In2, L | L2, E | E2, R | R2>
}

Source

Since v2.0.0

zipRight

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

Signature

declare const zipRight: {
  <A2, In, In2 extends In, L2, E2, R2>(
    that: Sink<A2, In2, L2, E2, R2>,
    options?: { readonly concurrent?: boolean | undefined } | undefined
  ): <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 extends In, L2, E2, R2>(
    self: Sink<A, In, L, E, R>,
    that: Sink<A2, In2, L2, E2, R2>,
    options?: { readonly concurrent?: boolean | undefined } | undefined
  ): Sink<A2, In & In2, L | L2, E | E2, R | R2>
}

Source

Since v2.0.0

zipWith

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 extends In, L2, E2, R2, A, A3>(
    that: Sink<A2, In2, L2, E2, R2>,
    f: (a: A, a2: A2) => A3,
    options?: { readonly concurrent?: boolean | undefined } | undefined
  ): <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 extends In, 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 | undefined } | undefined
  ): Sink<A3, In & In2, L | L2, E | E2, R | R2>
}

Source

Since v2.0.0