<
E,
Cases extends E extends { _tag: string }
? {
[K in E["_tag"]]+?: (
error: Extract<E, { _tag: K }>
) => Stream<any, any, any>
}
: {},
A2 = unassigned,
E2 = never,
R2 = never
>(
cases: Cases,
orElse?:
| ((e: Exclude<E, { _tag: keyof Cases }>) => Stream<A2, E2, R2>)
| undefined
): <A, R>(
self: Stream<A, E, R>
) => Stream<
| A
| Exclude<A2, unassigned>
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Stream<infer A, any, any>
? A
: never
}[keyof Cases],
| E2
| (A2 extends unassigned ? Exclude<E, { _tag: keyof Cases }> : never)
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Stream<any, infer E, any>
? E
: never
}[keyof Cases],
| R
| R2
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Stream<any, any, infer R>
? R
: never
}[keyof Cases]
>
<
R,
E,
A,
Cases extends E extends { _tag: string }
? {
[K in E["_tag"]]+?: (
error: Extract<E, { _tag: K }>
) => Stream<any, any, any>
}
: {},
A2 = unassigned,
E2 = never,
R2 = never
>(
self: Stream<A, E, R>,
cases: Cases,
orElse?:
| ((e: Exclude<E, { _tag: keyof Cases }>) => Stream<A2, E2, R2>)
| undefined
): Stream<
| A
| Exclude<A2, unassigned>
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Stream<infer A, any, any>
? A
: never
}[keyof Cases],
| E2
| (A2 extends unassigned ? Exclude<E, { _tag: keyof Cases }> : never)
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Stream<any, infer E, any>
? E
: never
}[keyof Cases],
| R
| R2
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Stream<any, any, infer R>
? R
: never
}[keyof Cases]
>Switches to a recovery stream based on matching _tag handlers.
Example (Catching tagged failures with handlers)
import { Console, Effect, Stream } from "effect"
class NotFound {
readonly _tag = "NotFound"
constructor(readonly resource: string) {}
}
class Unauthorized {
readonly _tag = "Unauthorized"
constructor(readonly user: string) {}
}
const stream = Stream.fail(new NotFound("profile"))
const program = Effect.gen(function* () {
const result = yield* stream.pipe(
Stream.catchTags({
NotFound: () => Stream.succeed("fallback"),
Unauthorized: () => Stream.succeed("login")
}),
Stream.runCollect
)
yield* Console.log(result)
})
// Output: [ "fallback" ]error handling
Source effect/Stream.ts:539076 lines
export const const catchTags: {
<
E,
Cases extends E extends { _tag: string }
? {
[K in E["_tag"]]+?: (
error: Extract<
E,
{
_tag: K
}
>
) => Stream<any, any, any>
}
: {},
A2 = unassigned,
E2 = never,
R2 = never
>(
cases: Cases,
orElse?:
| ((
e: Exclude<E, { _tag: keyof Cases }>
) => Stream<A2, E2, R2>)
| undefined
): <A, R>(
self: Stream<A, E, R>
) => Stream<
| A
| Exclude<A2, unassigned>
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Stream<infer A, any, any>
? A
: never
}[keyof Cases],
| E2
| (A2 extends unassigned
? Exclude<E, { _tag: keyof Cases }>
: never)
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Stream<any, infer E, any>
? E
: never
}[keyof Cases],
| R
| R2
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Stream<any, any, infer R>
? R
: never
}[keyof Cases]
>
<
R,
E,
A,
Cases extends E extends { _tag: string }
? {
[K in E["_tag"]]+?: (
error: Extract<
E,
{
_tag: K
}
>
) => Stream<any, any, any>
}
: {},
A2 = unassigned,
E2 = never,
R2 = never
>(
self: Stream<A, E, R>,
cases: Cases,
orElse?:
| ((
e: Exclude<E, { _tag: keyof Cases }>
) => Stream<A2, E2, R2>)
| undefined
): Stream<
| A
| Exclude<A2, unassigned>
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Stream<infer A, any, any>
? A
: never
}[keyof Cases],
| E2
| (A2 extends unassigned
? Exclude<E, { _tag: keyof Cases }>
: never)
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Stream<any, infer E, any>
? E
: never
}[keyof Cases],
| R
| R2
| {
[K in keyof Cases]: Cases[K] extends (
...args: Array<any>
) => Stream<any, any, infer R>
? R
: never
}[keyof Cases]
>
}
Switches to a recovery stream based on matching _tag handlers.
Example (Catching tagged failures with handlers)
import { Console, Effect, Stream } from "effect"
class NotFound {
readonly _tag = "NotFound"
constructor(readonly resource: string) {}
}
class Unauthorized {
readonly _tag = "Unauthorized"
constructor(readonly user: string) {}
}
const stream = Stream.fail(new NotFound("profile"))
const program = Effect.gen(function* () {
const result = yield* stream.pipe(
Stream.catchTags({
NotFound: () => Stream.succeed("fallback"),
Unauthorized: () => Stream.succeed("login")
}),
Stream.runCollect
)
yield* Console.log(result)
})
// Output: [ "fallback" ]
catchTags: {
<
function (type parameter) E in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) Cases in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) E in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
_tag: string_tag: string } ? {
[function (type parameter) KK in function (type parameter) E in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
error: Extract<
E,
{
_tag: K
}
>
type Extract<T, U> = T extends U
? T
: never
Extract from T those types that are assignable to U
Extract<function (type parameter) E in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
_tag: K extends E["_tag"]_tag: function (type parameter) KK }>) => 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<any, any, any>
} :
{}),
function (type parameter) A2 in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) E2 in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) R2 in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
cases: Cases extends (E extends { _tag: string; } ? { [K in E["_tag"]]+?: (error: Extract<E, { _tag: K; }>) => Stream<any, any, any>; } : {})cases: function (type parameter) Cases in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
orElse: | ((
e: Exclude<E, { _tag: keyof Cases }>
) => Stream<A2, E2, R2>)
| undefined
e: Exclude<
E,
{
_tag: keyof Cases
}
>
type Exclude<T, U> = T extends U
? never
: T
Exclude from T those types that are assignable to U
Exclude<function (type parameter) E in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
_tag: keyof Cases_tag: keyof function (type parameter) Cases in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
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) A2 in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) E2 in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) R2 in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) A in <A, R>(self: Stream<A, E, R>): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) R in <A, R>(self: Stream<A, E, R>): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
self: Stream<A, E, R>(parameter) self: {
channel: Channel.Channel<Arr.NonEmptyReadonlyArray<A>, E, void, unknown, unknown, unknown, R>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
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, R>(self: Stream<A, E, R>): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) E in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) R in <A, R>(self: Stream<A, E, R>): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
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, R>(self: Stream<A, E, R>): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
type Exclude<T, U> = T extends U
? never
: T
Exclude from T those types that are assignable to U
Exclude<function (type parameter) A2 in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) KK in keyof function (type parameter) Cases in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) Cases in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) KK] extends ((...args: any[]args: interface Array<T>Array<any>) => 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<infer function (type parameter) AA, any, any>) ? function (type parameter) AA : never
}[keyof function (type parameter) Cases in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) E2 in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) A2 in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
type Exclude<T, U> = T extends U
? never
: T
Exclude from T those types that are assignable to U
Exclude<function (type parameter) E in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
_tag: keyof Cases_tag: keyof function (type parameter) Cases in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) KK in keyof function (type parameter) Cases in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) Cases in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) KK] extends ((...args: any[]args: interface Array<T>Array<any>) => 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<any, infer function (type parameter) EE, any>) ? function (type parameter) EE : never
}[keyof function (type parameter) Cases in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) R in <A, R>(self: Stream<A, E, R>): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) R2 in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) KK in keyof function (type parameter) Cases in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) Cases in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) KK] extends ((...args: any[]args: interface Array<T>Array<any>) => 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<any, any, infer function (type parameter) RR>) ? function (type parameter) RR : never
}[keyof function (type parameter) Cases in <E, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) R in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) E in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) A in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) Cases in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) E in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
_tag: string_tag: string } ? {
[function (type parameter) KK in function (type parameter) E in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
error: Extract<
E,
{
_tag: K
}
>
type Extract<T, U> = T extends U
? T
: never
Extract from T those types that are assignable to U
Extract<function (type parameter) E in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
_tag: K extends E["_tag"]_tag: function (type parameter) KK }>) => 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<any, any, any>
} :
{}),
function (type parameter) A2 in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) E2 in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) R2 in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
self: Stream<A, E, R>(parameter) self: {
channel: Channel.Channel<Arr.NonEmptyReadonlyArray<A>, E, void, unknown, unknown, unknown, R>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
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 <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) E in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) R in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
cases: Cases extends (E extends { _tag: string; } ? { [K in E["_tag"]]+?: (error: Extract<E, { _tag: K; }>) => Stream<any, any, any>; } : {})cases: function (type parameter) Cases in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
orElse: | ((
e: Exclude<E, { _tag: keyof Cases }>
) => Stream<A2, E2, R2>)
| undefined
e: Exclude<
E,
{
_tag: keyof Cases
}
>
type Exclude<T, U> = T extends U
? never
: T
Exclude from T those types that are assignable to U
Exclude<function (type parameter) E in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
_tag: keyof Cases_tag: keyof function (type parameter) Cases in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
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) A2 in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) E2 in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) R2 in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
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 <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
type Exclude<T, U> = T extends U
? never
: T
Exclude from T those types that are assignable to U
Exclude<function (type parameter) A2 in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) KK in keyof function (type parameter) Cases in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) Cases in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) KK] extends ((...args: any[]args: interface Array<T>Array<any>) => 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<infer function (type parameter) AA, any, any>) ? function (type parameter) AA : never
}[keyof function (type parameter) Cases in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) E2 in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) A2 in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
type Exclude<T, U> = T extends U
? never
: T
Exclude from T those types that are assignable to U
Exclude<function (type parameter) E in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
_tag: keyof Cases_tag: keyof function (type parameter) Cases in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) KK in keyof function (type parameter) Cases in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) Cases in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) KK] extends ((...args: any[]args: interface Array<T>Array<any>) => 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<any, infer function (type parameter) EE, any>) ? function (type parameter) EE : never
}[keyof function (type parameter) Cases in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) R in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) R2 in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) KK in keyof function (type parameter) Cases in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) Cases in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
function (type parameter) KK] extends ((...args: any[]args: interface Array<T>Array<any>) => 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<any, any, infer function (type parameter) RR>) ? function (type parameter) RR : never
}[keyof function (type parameter) Cases in <R, E, A, Cases extends (E extends {
_tag: string;
} ? { [K in E["_tag"]]+?: (error: Extract<E, {
_tag: K;
}>) => Stream<any, any, any>; } : {}), A2 = unassigned, E2 = never, R2 = never>(self: Stream<A, E, R>, cases: Cases, orElse?: ((e: Exclude<E, {
_tag: keyof Cases;
}>) => Stream<A2, E2, R2>) | undefined): Stream<A | Exclude<A2, unassigned> | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<infer A, any, any>) ? A : never; }[keyof Cases], E2 | (A2 extends unassigned ? Exclude<E, {
_tag: keyof Cases;
}> : never) | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, infer E, any>) ? E : never; }[keyof Cases], R | R2 | { [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Stream<any, any, infer R>) ? R : never; }[keyof Cases]>
import dualdual((args: anyargs) => const isStream: (
u: unknown
) => u is Stream<unknown, unknown, unknown>
Checks whether a value is a Stream.
Example (Checking whether a value is a Stream)
import { Console, Effect, Stream } from "effect"
const program = Effect.gen(function*() {
const stream = Stream.make(1, 2, 3)
const notStream = { data: [1, 2, 3] }
yield* Console.log(Stream.isStream(stream))
// true
yield* Console.log(Stream.isStream(notStream))
// false
})
Effect.runPromise(program)
isStream(args: anyargs[0]), (self: anyself, cases: anycases, orElse: anyorElse) => {
let let keys: string[]keys: interface Array<T>Array<string>
return const catchFilter: {
<
E,
EB,
A2,
E2,
R2,
X,
A3 = unassigned,
E3 = never,
R3 = never
>(
filter: Filter.Filter<NoInfer<E>, EB, X>,
f: (failure: EB) => Stream<A2, E2, R2>,
orElse?:
| ((failure: X) => Stream<A3, E3, R3>)
| undefined
): <A, R>(
self: Stream<A, E, R>
) => Stream<
A | A2 | Exclude<A3, unassigned>,
E2 | E3 | (A3 extends unassigned ? X : never),
R | R2 | R3
>
<
A,
E,
R,
EB,
A2,
E2,
R2,
X,
A3 = unassigned,
E3 = never,
R3 = never
>(
self: Stream<A, E, R>,
filter: Filter.Filter<NoInfer<E>, EB, X>,
f: (failure: EB) => Stream<A2, E2, R2>,
orElse?:
| ((failure: X) => Stream<A3, E3, R3>)
| undefined
): Stream<
A | A2 | Exclude<A3, unassigned>,
E2 | E3 | (A3 extends unassigned ? X : never),
R | R2 | R3
>
}
self: anyself,
(e: anye: any) => {
let keys: string[]keys ??= var Object: ObjectConstructorProvides functionality common to all JavaScript objects.
Object.ObjectConstructor.keys(o: {}): string[] (+1 overload)Returns the names of the enumerable string properties and methods of an object.
keys(cases: anycases)
return import hasPropertyhasProperty(e: anye, "_tag") && const isString: Refinement<
unknown,
string
>
Checks whether a value is a string.
Example (Checking for strings)
import { String } from "effect"
import * as assert from "node:assert"
assert.deepStrictEqual(String.isString("a"), true)
assert.deepStrictEqual(String.isString(1), false)
isString(e: any(parameter) e: {
_tag: unknown;
}
let keys: string[]keys.Array<string>.includes(searchElement: string, fromIndex?: number): booleanDetermines whether an array includes a certain element, returning true or false as appropriate.
includes(e: any(parameter) e: {
_tag: unknown;
}
import ResultResult.succeed(e: any(parameter) e: {
_tag: unknown;
}
import ResultResult.fail(e: anye)
},
(e: anye: any) => cases: anycases[e: anye["_tag"] as string](e: anye),
orElse: anyorElse
)
})