(options: {
readonly concurrency: number | "unbounded"
readonly bufferSize?: number | undefined
}): <A, E, R>(streams: Iterable<Stream<A, E, R>>) => Stream<A, E, R>
<A, E, R>(
streams: Iterable<Stream<A, E, R>>,
options: {
readonly concurrency: number | "unbounded"
readonly bufferSize?: number | undefined
}
): Stream<A, E, R>Merges a collection of streams, running up to the specified number concurrently.
When to use
Use to merge an iterable of already-created streams while bounding how many inner streams may run at the same time.
Details
The concurrency option is required and may be a number or "unbounded".
bufferSize controls buffering between inner streams, and outputs are
emitted as they arrive under concurrent merging.
Example (Merging streams with bounded concurrency)
import { Console, Effect, Stream } from "effect"
const streams = [
Stream.fromEffect(Effect.delay(Effect.succeed("A"), "20 millis")),
Stream.fromEffect(Effect.delay(Effect.succeed("B"), "10 millis"))
]
const program = Effect.gen(function*() {
const values = yield* Stream.mergeAll(streams, { concurrency: 2 }).pipe(
Stream.runCollect
)
yield* Console.log(values)
})
Effect.runPromise(program)
// Output: [ "B", "A" ]export const const mergeAll: {
(options: {
readonly concurrency: number | "unbounded"
readonly bufferSize?: number | undefined
}): <A, E, R>(
streams: Iterable<Stream<A, E, R>>
) => Stream<A, E, R>
<A, E, R>(
streams: Iterable<Stream<A, E, R>>,
options: {
readonly concurrency: number | "unbounded"
readonly bufferSize?: number | undefined
}
): Stream<A, E, R>
}
Merges a collection of streams, running up to the specified number concurrently.
When to use
Use to merge an iterable of already-created streams while bounding how many
inner streams may run at the same time.
Details
The concurrency option is required and may be a number or "unbounded".
bufferSize controls buffering between inner streams, and outputs are
emitted as they arrive under concurrent merging.
Example (Merging streams with bounded concurrency)
import { Console, Effect, Stream } from "effect"
const streams = [
Stream.fromEffect(Effect.delay(Effect.succeed("A"), "20 millis")),
Stream.fromEffect(Effect.delay(Effect.succeed("B"), "10 millis"))
]
const program = Effect.gen(function*() {
const values = yield* Stream.mergeAll(streams, { concurrency: 2 }).pipe(
Stream.runCollect
)
yield* Console.log(values)
})
Effect.runPromise(program)
// Output: [ "B", "A" ]
mergeAll: {
(
options: {
readonly concurrency: number | "unbounded"
readonly bufferSize?: number | undefined
}
concurrency: number | "unbounded"concurrency: number | "unbounded"
readonly bufferSize?: number | undefinedbufferSize?: number | undefined
}
): <function (type parameter) A in <A, E, R>(streams: Iterable<Stream<A, E, R>>): Stream<A, E, R>A, function (type parameter) E in <A, E, R>(streams: Iterable<Stream<A, E, R>>): Stream<A, E, R>E, function (type parameter) R in <A, E, R>(streams: Iterable<Stream<A, E, R>>): Stream<A, E, R>R>(streams: Iterable<Stream<A, E, R>>streams: import IterableIterable<interface Stream<out A, out E = never, out R = never>A Stream<A, E, R> describes a program that can emit many A values, fail
with E, and require R.
Details
Streams are pull-based with backpressure and emit chunks to amortize effect
evaluation. They support monadic composition and error handling similar to
Effect, adapted for multiple values.
Example (Creating and consuming streams)
import { Console, Effect, Stream } from "effect"
const program = Effect.gen(function*() {
yield* Stream.make(1, 2, 3).pipe(
Stream.map((n) => n * 2),
Stream.runForEach((n) => Console.log(n))
)
})
Effect.runPromise(program)
// Output:
// 2
// 4
// 6
Stream<function (type parameter) A in <A, E, R>(streams: Iterable<Stream<A, E, R>>): Stream<A, E, R>A, function (type parameter) E in <A, E, R>(streams: Iterable<Stream<A, E, R>>): Stream<A, E, R>E, function (type parameter) R in <A, E, R>(streams: Iterable<Stream<A, E, R>>): Stream<A, E, R>R>>) => interface Stream<out A, out E = never, out R = never>A Stream<A, E, R> describes a program that can emit many A values, fail
with E, and require R.
Details
Streams are pull-based with backpressure and emit chunks to amortize effect
evaluation. They support monadic composition and error handling similar to
Effect, adapted for multiple values.
Example (Creating and consuming streams)
import { Console, Effect, Stream } from "effect"
const program = Effect.gen(function*() {
yield* Stream.make(1, 2, 3).pipe(
Stream.map((n) => n * 2),
Stream.runForEach((n) => Console.log(n))
)
})
Effect.runPromise(program)
// Output:
// 2
// 4
// 6
Stream<function (type parameter) A in <A, E, R>(streams: Iterable<Stream<A, E, R>>): Stream<A, E, R>A, function (type parameter) E in <A, E, R>(streams: Iterable<Stream<A, E, R>>): Stream<A, E, R>E, function (type parameter) R in <A, E, R>(streams: Iterable<Stream<A, E, R>>): Stream<A, E, R>R>
<function (type parameter) A in <A, E, R>(streams: Iterable<Stream<A, E, R>>, options: {
readonly concurrency: number | "unbounded";
readonly bufferSize?: number | undefined;
}): Stream<A, E, R>
function (type parameter) E in <A, E, R>(streams: Iterable<Stream<A, E, R>>, options: {
readonly concurrency: number | "unbounded";
readonly bufferSize?: number | undefined;
}): Stream<A, E, R>
function (type parameter) R in <A, E, R>(streams: Iterable<Stream<A, E, R>>, options: {
readonly concurrency: number | "unbounded";
readonly bufferSize?: number | undefined;
}): Stream<A, E, R>
streams: Iterable<Stream<A, E, R>>streams: import IterableIterable<interface Stream<out A, out E = never, out R = never>A Stream<A, E, R> describes a program that can emit many A values, fail
with E, and require R.
Details
Streams are pull-based with backpressure and emit chunks to amortize effect
evaluation. They support monadic composition and error handling similar to
Effect, adapted for multiple values.
Example (Creating and consuming streams)
import { Console, Effect, Stream } from "effect"
const program = Effect.gen(function*() {
yield* Stream.make(1, 2, 3).pipe(
Stream.map((n) => n * 2),
Stream.runForEach((n) => Console.log(n))
)
})
Effect.runPromise(program)
// Output:
// 2
// 4
// 6
Stream<function (type parameter) A in <A, E, R>(streams: Iterable<Stream<A, E, R>>, options: {
readonly concurrency: number | "unbounded";
readonly bufferSize?: number | undefined;
}): Stream<A, E, R>
function (type parameter) E in <A, E, R>(streams: Iterable<Stream<A, E, R>>, options: {
readonly concurrency: number | "unbounded";
readonly bufferSize?: number | undefined;
}): Stream<A, E, R>
function (type parameter) R in <A, E, R>(streams: Iterable<Stream<A, E, R>>, options: {
readonly concurrency: number | "unbounded";
readonly bufferSize?: number | undefined;
}): Stream<A, E, R>
options: {
readonly concurrency: number | "unbounded"
readonly bufferSize?: number | undefined
}
concurrency: number | "unbounded"concurrency: number | "unbounded"
readonly bufferSize?: number | undefinedbufferSize?: number | undefined
}
): interface Stream<out A, out E = never, out R = never>A Stream<A, E, R> describes a program that can emit many A values, fail
with E, and require R.
Details
Streams are pull-based with backpressure and emit chunks to amortize effect
evaluation. They support monadic composition and error handling similar to
Effect, adapted for multiple values.
Example (Creating and consuming streams)
import { Console, Effect, Stream } from "effect"
const program = Effect.gen(function*() {
yield* Stream.make(1, 2, 3).pipe(
Stream.map((n) => n * 2),
Stream.runForEach((n) => Console.log(n))
)
})
Effect.runPromise(program)
// Output:
// 2
// 4
// 6
Stream<function (type parameter) A in <A, E, R>(streams: Iterable<Stream<A, E, R>>, options: {
readonly concurrency: number | "unbounded";
readonly bufferSize?: number | undefined;
}): Stream<A, E, R>
function (type parameter) E in <A, E, R>(streams: Iterable<Stream<A, E, R>>, options: {
readonly concurrency: number | "unbounded";
readonly bufferSize?: number | undefined;
}): Stream<A, E, R>
function (type parameter) R in <A, E, R>(streams: Iterable<Stream<A, E, R>>, options: {
readonly concurrency: number | "unbounded";
readonly bufferSize?: number | undefined;
}): Stream<A, E, R>
import dualdual(2, <function (type parameter) A in <A, E, R>(streams: Iterable<Stream<A, E, R>>, options: {
readonly concurrency: number | "unbounded";
readonly bufferSize?: number | undefined;
}): Stream<A, E, R>
function (type parameter) E in <A, E, R>(streams: Iterable<Stream<A, E, R>>, options: {
readonly concurrency: number | "unbounded";
readonly bufferSize?: number | undefined;
}): Stream<A, E, R>
function (type parameter) R in <A, E, R>(streams: Iterable<Stream<A, E, R>>, options: {
readonly concurrency: number | "unbounded";
readonly bufferSize?: number | undefined;
}): Stream<A, E, R>
streams: Iterable<Stream<A, E, R>>streams: import IterableIterable<interface Stream<out A, out E = never, out R = never>A Stream<A, E, R> describes a program that can emit many A values, fail
with E, and require R.
Details
Streams are pull-based with backpressure and emit chunks to amortize effect
evaluation. They support monadic composition and error handling similar to
Effect, adapted for multiple values.
Example (Creating and consuming streams)
import { Console, Effect, Stream } from "effect"
const program = Effect.gen(function*() {
yield* Stream.make(1, 2, 3).pipe(
Stream.map((n) => n * 2),
Stream.runForEach((n) => Console.log(n))
)
})
Effect.runPromise(program)
// Output:
// 2
// 4
// 6
Stream<function (type parameter) A in <A, E, R>(streams: Iterable<Stream<A, E, R>>, options: {
readonly concurrency: number | "unbounded";
readonly bufferSize?: number | undefined;
}): Stream<A, E, R>
function (type parameter) E in <A, E, R>(streams: Iterable<Stream<A, E, R>>, options: {
readonly concurrency: number | "unbounded";
readonly bufferSize?: number | undefined;
}): Stream<A, E, R>
function (type parameter) R in <A, E, R>(streams: Iterable<Stream<A, E, R>>, options: {
readonly concurrency: number | "unbounded";
readonly bufferSize?: number | undefined;
}): Stream<A, E, R>
options: {
readonly concurrency: number | "unbounded"
readonly bufferSize?: number | undefined
}
concurrency: number | "unbounded"concurrency: number | "unbounded"
readonly bufferSize?: number | undefinedbufferSize?: number | undefined
}
): interface Stream<out A, out E = never, out R = never>A Stream<A, E, R> describes a program that can emit many A values, fail
with E, and require R.
Details
Streams are pull-based with backpressure and emit chunks to amortize effect
evaluation. They support monadic composition and error handling similar to
Effect, adapted for multiple values.
Example (Creating and consuming streams)
import { Console, Effect, Stream } from "effect"
const program = Effect.gen(function*() {
yield* Stream.make(1, 2, 3).pipe(
Stream.map((n) => n * 2),
Stream.runForEach((n) => Console.log(n))
)
})
Effect.runPromise(program)
// Output:
// 2
// 4
// 6
Stream<function (type parameter) A in <A, E, R>(streams: Iterable<Stream<A, E, R>>, options: {
readonly concurrency: number | "unbounded";
readonly bufferSize?: number | undefined;
}): Stream<A, E, R>
function (type parameter) E in <A, E, R>(streams: Iterable<Stream<A, E, R>>, options: {
readonly concurrency: number | "unbounded";
readonly bufferSize?: number | undefined;
}): Stream<A, E, R>
function (type parameter) R in <A, E, R>(streams: Iterable<Stream<A, E, R>>, options: {
readonly concurrency: number | "unbounded";
readonly bufferSize?: number | undefined;
}): Stream<A, E, R>
const flatten: <
Arg extends
| Stream<Stream<any, any, any>, any, any>
| {
readonly concurrency?:
| number
| "unbounded"
| undefined
readonly bufferSize?: number | undefined
}
| undefined = {
readonly concurrency?:
| number
| "unbounded"
| undefined
readonly bufferSize?: number | undefined
}
>(
selfOrOptions?: Arg,
options?:
| {
readonly concurrency?:
| number
| "unbounded"
| undefined
readonly bufferSize?: number | undefined
}
| undefined
) => [Arg] extends [
Stream<
Stream<infer _A, infer _E, infer _R>,
infer _E2,
infer _R2
>
]
? Stream<_A, _E | _E2, _R | _R2>
: <A, E, R, E2, R2>(
self: Stream<Stream<A, E, R>, E2, R2>
) => Stream<A, E | E2, R | R2>
Flattens a stream of streams into a single stream.
Details
With the default sequential concurrency, inner streams are concatenated in
strict order. When concurrency is greater than 1 or "unbounded",
multiple inner streams may run at the same time and their outputs are merged
as they arrive.
Example (Flattening nested streams)
import { Console, Effect, Stream } from "effect"
const streamOfStreams = Stream.make(
Stream.make(1, 2),
Stream.make(3, 4),
Stream.make(5, 6)
)
const program = Effect.gen(function*() {
const values = yield* Stream.runCollect(Stream.flatten(streamOfStreams))
yield* Console.log(values)
})
Effect.runPromise(program)
// Output: [ 1, 2, 3, 4, 5, 6 ]
flatten(const fromIterable: <A>(
iterable: Iterable<A>,
options?: {
readonly chunkSize?: number | undefined
}
) => Stream<A>
Creates a new Stream from an iterable collection of values.
Details
chunkSize: Maximum number of values emitted per chunk.
Example (Creating a stream from an iterable)
import { Console, Effect, Stream } from "effect"
const numbers = [1, 2, 3]
const program = Effect.gen(function*() {
const stream = Stream.fromIterable(numbers)
const values = yield* Stream.runCollect(stream)
yield* Console.log(values)
})
Effect.runPromise(program)
// Output: [ 1, 2, 3 ]
fromIterable(streams: Iterable<Stream<A, E, R>>streams), options: {
readonly concurrency: number | "unbounded"
readonly bufferSize?: number | undefined
}