Sink overview
Added in v2.0.0
Table of contents
- constructors
- collectAll
- collectAllN
- collectAllToMap
- collectAllToMapN
- collectAllToSet
- collectAllToSetN
- collectAllUntil
- collectAllUntilEffect
- collectAllWhile
- collectAllWhileEffect
- context
- contextWith
- contextWithEffect
- contextWithSink
- count
- die
- dieMessage
- dieSync
- drain
- drop
- dropUntil
- dropUntilEffect
- dropWhile
- dropWhileEffect
- every
- fail
- failCause
- failCauseSync
- failSync
- foldChunks
- foldChunksEffect
- foldEffect
- foldLeft
- foldLeftChunks
- foldLeftChunksEffect
- foldLeftEffect
- foldUntil
- foldUntilEffect
- foldWeighted
- foldWeightedDecompose
- foldWeightedDecomposeEffect
- foldWeightedEffect
- forEach
- forEachChunk
- forEachChunkWhile
- forEachWhile
- fromChannel
- fromEffect
- fromPubSub
- fromPush
- fromQueue
- head
- last
- leftover
- mkString
- never
- some
- succeed
- sum
- suspend
- sync
- take
- timed
- toChannel
- unwrap
- unwrapScoped
- unwrapScopedWith
- context
- elements
- error handling
- filtering
- finalization
- folding
- mapping
- models
- sequencing
- symbols
- utils
- zipping
constructors
collectAll
A sink that collects all elements into a Chunk
.
Signature
export declare const collectAll: <In>() => Sink<Chunk.Chunk<In>, In>
Added in v2.0.0
collectAllN
A sink that collects first n
elements into a chunk.
Signature
export declare const collectAllN: <In>(n: number) => Sink<Chunk.Chunk<In>, In, In>
Added in 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
export declare const collectAllToMap: <In, K>(
key: (input: In) => K,
merge: (x: In, y: In) => In
) => Sink<HashMap.HashMap<K, In>, In>
Added in 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
export declare const collectAllToMapN: <In, K>(
n: number,
key: (input: In) => K,
merge: (x: In, y: In) => In
) => Sink<HashMap.HashMap<K, In>, In, In>
Added in v2.0.0
collectAllToSet
A sink that collects all of its inputs into a set.
Signature
export declare const collectAllToSet: <In>() => Sink<HashSet.HashSet<In>, In>
Added in v2.0.0
collectAllToSetN
A sink that collects first n
distinct inputs into a set.
Signature
export declare const collectAllToSetN: <In>(n: number) => Sink<HashSet.HashSet<In>, In, In>
Added in v2.0.0
collectAllUntil
Accumulates incoming elements into a chunk until predicate p
is satisfied.
Signature
export declare const collectAllUntil: <In>(p: Predicate<In>) => Sink<Chunk.Chunk<In>, In, In>
Added in v2.0.0
collectAllUntilEffect
Accumulates incoming elements into a chunk until effectful predicate p
is satisfied.
Signature
export declare const collectAllUntilEffect: <In, E, R>(
p: (input: In) => Effect.Effect<boolean, E, R>
) => Sink<Chunk.Chunk<In>, In, In, E, R>
Added in v2.0.0
collectAllWhile
Accumulates incoming elements into a chunk as long as they verify predicate p
.
Signature
export 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>
}
Added in v2.0.0
collectAllWhileEffect
Accumulates incoming elements into a chunk as long as they verify effectful predicate p
.
Signature
export declare const collectAllWhileEffect: <In, E, R>(
predicate: (input: In) => Effect.Effect<boolean, E, R>
) => Sink<Chunk.Chunk<In>, In, In, E, R>
Added in v2.0.0
context
Accesses the whole context of the sink.
Signature
export declare const context: <R>() => Sink<Context.Context<R>, unknown, never, never, R>
Added in v2.0.0
contextWith
Accesses the context of the sink.
Signature
export declare const contextWith: <R, Z>(f: (context: Context.Context<R>) => Z) => Sink<Z, unknown, never, never, R>
Added in v2.0.0
contextWithEffect
Accesses the context of the sink in the context of an effect.
Signature
export declare const contextWithEffect: <R0, A, E, R>(
f: (context: Context.Context<R0>) => Effect.Effect<A, E, R>
) => Sink<A, unknown, never, E, R0 | R>
Added in v2.0.0
contextWithSink
Accesses the context of the sink in the context of a sink.
Signature
export 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>
Added in v2.0.0
count
A sink that counts the number of elements fed to it.
Signature
export declare const count: Sink<number, unknown, never, never, never>
Added in v2.0.0
die
Creates a sink halting with the specified defect.
Signature
export declare const die: (defect: unknown) => Sink<never, unknown>
Added in v2.0.0
dieMessage
Creates a sink halting with the specified message, wrapped in a RuntimeException
.
Signature
export declare const dieMessage: (message: string) => Sink<never, unknown>
Added in v2.0.0
dieSync
Creates a sink halting with the specified defect.
Signature
export declare const dieSync: (evaluate: LazyArg<unknown>) => Sink<never, unknown>
Added in v2.0.0
drain
A sink that ignores its inputs.
Signature
export declare const drain: Sink<void, unknown, never, never, never>
Added in v2.0.0
drop
Creates a sink that drops n
elements.
Signature
export declare const drop: <In>(n: number) => Sink<unknown, In, In>
Added in v2.0.0
dropUntil
Drops incoming elements until the predicate is satisfied.
Signature
export declare const dropUntil: <In>(predicate: Predicate<In>) => Sink<unknown, In, In>
Added in v2.0.0
dropUntilEffect
Drops incoming elements until the effectful predicate is satisfied.
Signature
export declare const dropUntilEffect: <In, E, R>(
predicate: (input: In) => Effect.Effect<boolean, E, R>
) => Sink<unknown, In, In, E, R>
Added in v2.0.0
dropWhile
Drops incoming elements as long as the predicate is satisfied.
Signature
export declare const dropWhile: <In>(predicate: Predicate<In>) => Sink<unknown, In, In>
Added in v2.0.0
dropWhileEffect
Drops incoming elements as long as the effectful predicate is satisfied.
Signature
export declare const dropWhileEffect: <In, E, R>(
predicate: (input: In) => Effect.Effect<boolean, E, R>
) => Sink<unknown, In, In, E, R>
Added in v2.0.0
every
A sink that returns whether all elements satisfy the specified predicate.
Signature
export declare const every: <In>(predicate: Predicate<In>) => Sink<boolean, In, In>
Added in v2.0.0
fail
A sink that always fails with the specified error.
Signature
export declare const fail: <E>(e: E) => Sink<never, unknown, never, E>
Added in v2.0.0
failCause
Creates a sink halting with a specified Cause
.
Signature
export declare const failCause: <E>(cause: Cause.Cause<E>) => Sink<never, unknown, never, E>
Added in v2.0.0
failCauseSync
Creates a sink halting with a specified lazily evaluated Cause
.
Signature
export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Sink<never, unknown, never, E>
Added in v2.0.0
failSync
A sink that always fails with the specified lazily evaluated error.
Signature
export declare const failSync: <E>(evaluate: LazyArg<E>) => Sink<never, unknown, never, E>
Added in 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
export declare const foldChunks: <S, In>(
s: S,
contFn: Predicate<S>,
f: (s: S, chunk: Chunk.Chunk<In>) => S
) => Sink<S, In>
Added in 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
export 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>
Added in v2.0.0
foldEffect
A sink that effectfully folds its inputs with the provided function, termination predicate and initial state.
Signature
export 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>
Added in v2.0.0
foldLeft
A sink that folds its inputs with the provided function and initial state.
Signature
export declare const foldLeft: <S, In>(s: S, f: (s: S, input: In) => S) => Sink<S, In>
Added in v2.0.0
foldLeftChunks
A sink that folds its input chunks with the provided function and initial state. f
must preserve chunking-invariance.
Signature
export declare const foldLeftChunks: <S, In>(s: S, f: (s: S, chunk: Chunk.Chunk<In>) => S) => Sink<S, In>
Added in 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
export 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>
Added in v2.0.0
foldLeftEffect
A sink that effectfully folds its inputs with the provided function and initial state.
Signature
export 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>
Added in 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
export declare const foldUntil: <In, S>(s: S, max: number, f: (s: S, input: In) => S) => Sink<S, In, In>
Added in 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
export 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>
Added in 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.
Signature
export 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>
Added in 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
export 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>
Added in 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
export 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>
Added in 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
export 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>
Added in v2.0.0
forEach
A sink that executes the provided effectful function for every element fed to it.
Signature
export declare const forEach: <In, X, E, R>(f: (input: In) => Effect.Effect<X, E, R>) => Sink<void, In, never, E, R>
Added in v2.0.0
forEachChunk
A sink that executes the provided effectful function for every chunk fed to it.
Signature
export declare const forEachChunk: <In, X, E, R>(
f: (input: Chunk.Chunk<In>) => Effect.Effect<X, E, R>
) => Sink<void, In, never, E, R>
Added in v2.0.0
forEachChunkWhile
A sink that executes the provided effectful function for every chunk fed to it until f
evaluates to false
.
Signature
export declare const forEachChunkWhile: <In, E, R>(
f: (input: Chunk.Chunk<In>) => Effect.Effect<boolean, E, R>
) => Sink<void, In, In, E, R>
Added in v2.0.0
forEachWhile
A sink that executes the provided effectful function for every element fed to it until f
evaluates to false
.
Signature
export declare const forEachWhile: <In, E, R>(
f: (input: In) => Effect.Effect<boolean, E, R>
) => Sink<void, In, In, E, R>
Added in v2.0.0
fromChannel
Creates a sink from a Channel
.
Signature
export 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>
Added in v2.0.0
fromEffect
Creates a single-value sink produced from an effect.
Signature
export declare const fromEffect: <A, E, R>(effect: Effect.Effect<A, E, R>) => Sink<A, unknown, never, E, R>
Added in v2.0.0
fromPubSub
Create a sink which publishes each element to the specified PubSub
.
Signature
export declare const fromPubSub: <In>(
pubsub: PubSub.PubSub<In>,
options?: { readonly shutdown?: boolean | undefined }
) => Sink<void, In>
Added in v2.0.0
fromPush
Creates a sink from a chunk processing function.
Signature
export 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>>
Added in v2.0.0
fromQueue
Create a sink which enqueues each element into the specified queue.
Signature
export declare const fromQueue: <In>(
queue: Queue.Enqueue<In>,
options?: { readonly shutdown?: boolean | undefined }
) => Sink<void, In>
Added in v2.0.0
head
Creates a sink containing the first value.
Signature
export declare const head: <In>() => Sink<Option.Option<In>, In, In>
Added in v2.0.0
last
Creates a sink containing the last value.
Signature
export declare const last: <In>() => Sink<Option.Option<In>, In, In>
Added in v2.0.0
leftover
Creates a sink that does not consume any input but provides the given chunk as its leftovers
Signature
export declare const leftover: <L>(chunk: Chunk.Chunk<L>) => Sink<void, unknown, L>
Added in v2.0.0
mkString
Creates a sink which transforms it’s inputs into a string.
Signature
export declare const mkString: Sink<string, unknown, never, never, never>
Added in v2.0.0
never
Creates a sink which never terminates.
Signature
export declare const never: Sink<never, unknown, never, never, never>
Added in v2.0.0
some
A sink that returns whether an element satisfies the specified predicate.
Signature
export declare const some: <In>(predicate: Predicate<In>) => Sink<boolean, In, In>
Added in v2.0.0
succeed
A sink that immediately ends with the specified value.
Signature
export declare const succeed: <A>(a: A) => Sink<A, unknown>
Added in v2.0.0
sum
A sink that sums incoming numeric values.
Signature
export declare const sum: Sink<number, number, never, never, never>
Added in v2.0.0
suspend
Returns a lazily constructed sink that may require effects for its creation.
Signature
export declare const suspend: <A, In, L, E, R>(evaluate: LazyArg<Sink<A, In, L, E, R>>) => Sink<A, In, L, E, R>
Added in v2.0.0
sync
A sink that immediately ends with the specified lazy value.
Signature
export declare const sync: <A>(evaluate: LazyArg<A>) => Sink<A, unknown>
Added in v2.0.0
take
A sink that takes the specified number of values.
Signature
export declare const take: <In>(n: number) => Sink<Chunk.Chunk<In>, In, In>
Added in v2.0.0
timed
Signature
export declare const timed: Sink<Duration.Duration, unknown, never, never, never>
Added in v2.0.0
toChannel
Creates a Channel
from a Sink.
Signature
export 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>
Added in v2.0.0
unwrap
Creates a sink produced from an effect.
Signature
export 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>
Added in v2.0.0
unwrapScoped
Creates a sink produced from a scoped effect.
Signature
export 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>>
Added in 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
export 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>
Added in v3.11.0
context
provideContext
Provides the sink with its required context, which eliminates its dependency on R
.
Signature
export 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>
}
Added in v2.0.0
elements
findEffect
Creates a sink that produces values until one verifies the predicate f
.
Signature
export 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>
}
Added in v2.0.0
error handling
orElse
Switch to another sink in case of failure
Signature
export 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>
}
Added in v2.0.0
refineOrDie
Signature
export 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>
}
Added in v2.0.0
refineOrDieWith
Signature
export 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>
}
Added in v2.0.0
filtering
filterInput
Filters the sink’s input with the given predicate.
Signature
export 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>
}
Added in v2.0.0
filterInputEffect
Effectfully filter the input of this sink using the specified predicate.
Signature
export 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>
}
Added in 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
export 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>
}
Added in 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
export 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>
}
Added in v2.0.0
folding
fold
A sink that folds its inputs with the provided function, termination predicate and initial state.
Signature
export declare const fold: <S, In>(s: S, contFn: Predicate<S>, f: (s: S, input: In) => S) => Sink<S, In, In>
Added in v2.0.0
foldSink
Folds over the result of the sink
Signature
export 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>
}
Added in v2.0.0
mapping
as
Replaces this sink’s result with the provided value.
Signature
export 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>
}
Added in v2.0.0
dimap
Transforms both inputs and result of this sink using the provided functions.
Signature
export 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>
}
Added in v2.0.0
dimapChunks
Transforms both input chunks and result of this sink using the provided functions.
Signature
export 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>
}
Added in 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
export 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>
}
Added in v2.0.0
dimapEffect
Effectfully transforms both inputs and result of this sink using the provided functions.
Signature
export 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>
}
Added in v2.0.0
map
Transforms this sink’s result.
Signature
export 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>
}
Added in v2.0.0
mapEffect
Effectfully transforms this sink’s result.
Signature
export 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>
}
Added in v2.0.0
mapError
Transforms the errors emitted by this sink using f
.
Signature
export 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>
}
Added in v2.0.0
mapInput
Transforms this sink’s input elements.
Signature
export 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>
}
Added in v2.0.0
mapInputChunks
Transforms this sink’s input chunks. f
must preserve chunking-invariance.
Signature
export 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>
}
Added in v2.0.0
mapInputChunksEffect
Effectfully transforms this sink’s input chunks. f
must preserve chunking-invariance.
Signature
export 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>
}
Added in v2.0.0
mapInputEffect
Effectfully transforms this sink’s input elements.
Signature
export 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>
}
Added in v2.0.0
mapLeftover
Transforms the leftovers emitted by this sink using f
.
Signature
export 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>
}
Added in 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 {}
Added in 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
}
Added in v2.0.0
SinkUnifyIgnore (interface)
Signature
export interface SinkUnifyIgnore extends Effect.EffectUnifyIgnore {
Sink?: true
}
Added in 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
export 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>
}
Added in v2.0.0
symbols
SinkTypeId
Signature
export declare const SinkTypeId: typeof SinkTypeId
Added in v2.0.0
SinkTypeId (type alias)
Signature
export type SinkTypeId = typeof SinkTypeId
Added in v2.0.0
utils
Sink (namespace)
Added in 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>
}
Added in 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>
}
Added in v2.0.0
collectAllFrom
Repeatedly runs the sink and accumulates its results into a Chunk
.
Signature
export 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>
Added in 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
export 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>
}
Added in 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
export declare const collectLeftover: <A, In, L, E, R>(
self: Sink<A, In, L, E, R>
) => Sink<[A, Chunk.Chunk<L>], In, never, E, R>
Added in v2.0.0
ignoreLeftover
Drains the remaining elements from the stream after the sink finishes
Signature
export declare const ignoreLeftover: <A, In, L, E, R>(self: Sink<A, In, L, E, R>) => Sink<A, In, never, E, R>
Added in 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
export 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>
}
Added in 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
export 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>
}
Added in 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
export 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>
}
Added in 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
export 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>
}
Added in v2.0.0
summarized
Summarize a sink by running an effect when the sink starts and again when it completes.
Signature
export 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>
}
Added in v2.0.0
withDuration
Returns the sink that executes this one and times its execution.
Signature
export declare const withDuration: <A, In, L, E, R>(
self: Sink<A, In, L, E, R>
) => Sink<[A, Duration.Duration], In, L, E, R>
Added in 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
export 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>
}
Added in v2.0.0
zipLeft
Like Sink.zip
but keeps only the result from this sink.
Signature
export 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>
}
Added in v2.0.0
zipRight
Like Sink.zip
but keeps only the result from that
sink.
Signature
export 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>
}
Added in 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
export 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>
}
Added in v2.0.0