(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: interface Iterable<T, TReturn = any, TNext = any>Iterable<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: interface Iterable<T, TReturn = any, TNext = any>Iterable<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>
dual<(...args: Array<any>) => any, <A, E, R>(streams: Iterable<Stream<A, E, R>>, options: {
readonly concurrency: number | "unbounded";
readonly bufferSize?: number | undefined;
}) => Stream<A, E, R>>(arity: 2, body: <A, E, R>(streams: Iterable<Stream<A, E, R>>, options: {
readonly concurrency: number | "unbounded";
readonly bufferSize?: number | undefined;
}) => Stream<A, E, R>): ((...args: Array<any>) => any) & (<A, E, R>(streams: Iterable<Stream<A, E, R>>, options: {
readonly concurrency: number | "unbounded";
readonly bufferSize?: number | undefined;
}) => Stream<A, E, R>) (+1 overload)
Creates a function that can be called in data-first style or data-last
(pipe-friendly) style.
When to use
Use to expose one implementation through both direct and pipe-friendly
call styles.
Details
Pass either the arity of the uncurried function or a predicate that decides
whether the current call is data-first. Arity is the common case. Use a
predicate when optional arguments make arity ambiguous.
Example (Selecting data-first or data-last style by arity)
import { Function, pipe } from "effect"
const sum = Function.dual<
(that: number) => (self: number) => number,
(self: number, that: number) => number
>(2, (self, that) => self + that)
console.log(sum(2, 3)) // 5
console.log(pipe(2, sum(3))) // 5
Example (Defining overloads with call signatures)
import { Function, pipe } from "effect"
const sum: {
(that: number): (self: number) => number
(self: number, that: number): number
} = Function.dual(2, (self: number, that: number): number => self + that)
console.log(sum(2, 3)) // 5
console.log(pipe(2, sum(3))) // 5
Example (Selecting data-first or data-last style with a predicate)
import { Function, pipe } from "effect"
const sum = Function.dual<
(that: number) => (self: number) => number,
(self: number, that: number) => number
>(
(args) => args.length === 2,
(self, that) => self + that
)
console.log(sum(2, 3)) // 5
console.log(pipe(2, sum(3))) // 5
dual(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: interface Iterable<T, TReturn = any, TNext = any>Iterable<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
}