(duration: Duration.Input): <A, E, R>(
self: Stream<A, E, R>
) => Stream<A, E, R>
<A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<
A,
E,
R
>Ends the stream if it does not produce a value within the specified duration.
Example (Timing out a stream)
import { Console, Effect, Stream } from "effect"
const program = Effect.gen(function*() {
const values = yield* Stream.make(1).pipe(
Stream.concat(Stream.never),
Stream.timeout("1 second"),
Stream.runCollect
)
yield* Console.log(values)
})
Effect.runPromise(program)
// Output: [ 1 ]export const const timeout: {
(duration: Duration.Input): <A, E, R>(
self: Stream<A, E, R>
) => Stream<A, E, R>
<A, E, R>(
self: Stream<A, E, R>,
duration: Duration.Input
): Stream<A, E, R>
}
Ends the stream if it does not produce a value within the specified duration.
Example (Timing out a stream)
import { Console, Effect, Stream } from "effect"
const program = Effect.gen(function*() {
const values = yield* Stream.make(1).pipe(
Stream.concat(Stream.never),
Stream.timeout("1 second"),
Stream.runCollect
)
yield* Console.log(values)
})
Effect.runPromise(program)
// Output: [ 1 ]
timeout: {
(duration: Duration.Inputduration: import DurationDuration.type Duration.Input = /*unresolved*/ anyInput): <function (type parameter) A in <A, E, R>(self: Stream<A, E, R>): Stream<A, E, R>A, function (type parameter) E in <A, E, R>(self: Stream<A, E, R>): Stream<A, E, R>E, function (type parameter) R in <A, E, R>(self: Stream<A, E, R>): Stream<A, E, R>R>(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, E, R>(self: Stream<A, E, R>): Stream<A, E, R>A, function (type parameter) E in <A, E, R>(self: Stream<A, E, R>): Stream<A, E, R>E, function (type parameter) R in <A, E, R>(self: 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>(self: Stream<A, E, R>): Stream<A, E, R>A, function (type parameter) E in <A, E, R>(self: Stream<A, E, R>): Stream<A, E, R>E, function (type parameter) R in <A, E, R>(self: Stream<A, E, R>): Stream<A, E, R>R>
<function (type parameter) A in <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>A, function (type parameter) E in <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>E, function (type parameter) R in <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>R>(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, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>A, function (type parameter) E in <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>E, function (type parameter) R in <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>R>, duration: Duration.Inputduration: import DurationDuration.type Duration.Input = /*unresolved*/ anyInput): 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>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>A, function (type parameter) E in <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>E, function (type parameter) R in <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>R>
} = import dualdual(
2,
<function (type parameter) A in <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>A, function (type parameter) E in <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>E, function (type parameter) R in <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>R>(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, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>A, function (type parameter) E in <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>E, function (type parameter) R in <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>R>, duration: Duration.Inputduration: import DurationDuration.type Duration.Input = /*unresolved*/ anyInput): 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>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>A, function (type parameter) E in <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>E, function (type parameter) R in <A, E, R>(self: Stream<A, E, R>, duration: Duration.Input): Stream<A, E, R>R> =>
const timeoutOrElse: {
<B, E2, R2>(options: {
readonly duration: Duration.Input
readonly orElse: () => Stream<B, E2, R2>
}): <A, E, R>(
self: Stream<A, E, R>
) => Stream<A | B, E | E2, R | R2>
<A, E, R, B, E2, R2>(
self: Stream<A, E, R>,
options: {
readonly duration: Duration.Input
readonly orElse: () => Stream<B, E2, R2>
}
): Stream<A | B, E | E2, R | R2>
}
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; <…;
}
duration: Duration.Inputduration,
orElse: () => Stream<never, never, never>orElse: () => const empty: Stream<never>const empty: {
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; <…;
}
Creates an empty stream.
Example (Creating an empty stream)
import { Console, Effect, Stream } from "effect"
const program = Effect.gen(function*() {
const values = yield* Stream.empty.pipe(Stream.runCollect)
yield* Console.log(values)
})
Effect.runPromise(program)
// []
empty
})
)