<A>(options?: { readonly strategy?: QueuingStrategy<A> | undefined }): <
E
>(
self: Stream<A, E>
) => ReadableStream<A>
<A, E>(
self: Stream<A, E>,
options?: { readonly strategy?: QueuingStrategy<A> | undefined }
): ReadableStream<A>Converts a stream to a ReadableStream.
Details
See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
Example (Converting a stream to a ReadableStream)
import { Stream } from "effect"
const readableStream = Stream.toReadableStream(Stream.make(1, 2, 3))
const reader = readableStream.getReader()export const const toReadableStream: {
<A>(options?: {
readonly strategy?:
| QueuingStrategy<A>
| undefined
}): <E>(self: Stream<A, E>) => ReadableStream<A>
<A, E>(
self: Stream<A, E>,
options?: {
readonly strategy?:
| QueuingStrategy<A>
| undefined
}
): ReadableStream<A>
}
Converts a stream to a ReadableStream.
Details
See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
Example (Converting a stream to a ReadableStream)
import { Stream } from "effect"
const readableStream = Stream.toReadableStream(Stream.make(1, 2, 3))
const reader = readableStream.getReader()
toReadableStream: {
<function (type parameter) A in <A>(options?: {
readonly strategy?: QueuingStrategy<A> | undefined;
}): <E>(self: Stream<A, E>) => ReadableStream<A>
options: | {
readonly strategy?:
| QueuingStrategy<A>
| undefined
}
| undefined
strategy?: QueuingStrategy<A> | undefinedstrategy?: interface QueuingStrategy<T = any>QueuingStrategy<function (type parameter) A in <A>(options?: {
readonly strategy?: QueuingStrategy<A> | undefined;
}): <E>(self: Stream<A, E>) => ReadableStream<A>
function (type parameter) E in <E>(self: Stream<A, E>): ReadableStream<A>E>(
self: Stream<A, E>(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>(options?: {
readonly strategy?: QueuingStrategy<A> | undefined;
}): <E>(self: Stream<A, E>) => ReadableStream<A>
function (type parameter) E in <E>(self: Stream<A, E>): ReadableStream<A>E>
) => interface ReadableStream<R = any>The ReadableStream interface of the Streams API represents a readable stream of byte data.
ReadableStream<function (type parameter) A in <A>(options?: {
readonly strategy?: QueuingStrategy<A> | undefined;
}): <E>(self: Stream<A, E>) => ReadableStream<A>
function (type parameter) A in <A, E>(self: Stream<A, E>, options?: {
readonly strategy?: QueuingStrategy<A> | undefined;
}): ReadableStream<A>
function (type parameter) E in <A, E>(self: Stream<A, E>, options?: {
readonly strategy?: QueuingStrategy<A> | undefined;
}): ReadableStream<A>
self: Stream<A, E>(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>(self: Stream<A, E>, options?: {
readonly strategy?: QueuingStrategy<A> | undefined;
}): ReadableStream<A>
function (type parameter) E in <A, E>(self: Stream<A, E>, options?: {
readonly strategy?: QueuingStrategy<A> | undefined;
}): ReadableStream<A>
options: | {
readonly strategy?:
| QueuingStrategy<A>
| undefined
}
| undefined
strategy?: QueuingStrategy<A> | undefinedstrategy?: interface QueuingStrategy<T = any>QueuingStrategy<function (type parameter) A in <A, E>(self: Stream<A, E>, options?: {
readonly strategy?: QueuingStrategy<A> | undefined;
}): ReadableStream<A>
interface ReadableStream<R = any>The ReadableStream interface of the Streams API represents a readable stream of byte data.
ReadableStream<function (type parameter) A in <A, E>(self: Stream<A, E>, options?: {
readonly strategy?: QueuingStrategy<A> | undefined;
}): ReadableStream<A>
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]),
<function (type parameter) A in <A, E>(self: Stream<A, E>, options?: {
readonly strategy?: QueuingStrategy<A> | undefined;
}): ReadableStream<A>
function (type parameter) E in <A, E>(self: Stream<A, E>, options?: {
readonly strategy?: QueuingStrategy<A> | undefined;
}): ReadableStream<A>
self: Stream<A, E>(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>(self: Stream<A, E>, options?: {
readonly strategy?: QueuingStrategy<A> | undefined;
}): ReadableStream<A>
function (type parameter) E in <A, E>(self: Stream<A, E>, options?: {
readonly strategy?: QueuingStrategy<A> | undefined;
}): ReadableStream<A>
options: | {
readonly strategy?:
| QueuingStrategy<A>
| undefined
}
| undefined
strategy?: QueuingStrategy<A> | undefinedstrategy?: interface QueuingStrategy<T = any>QueuingStrategy<function (type parameter) A in <A, E>(self: Stream<A, E>, options?: {
readonly strategy?: QueuingStrategy<A> | undefined;
}): ReadableStream<A>
interface ReadableStream<R = any>The ReadableStream interface of the Streams API represents a readable stream of byte data.
ReadableStream<function (type parameter) A in <A, E>(self: Stream<A, E>, options?: {
readonly strategy?: QueuingStrategy<A> | undefined;
}): ReadableStream<A>
const toReadableStreamWith: (<A, XR>(
context: Context.Context<XR>,
options?: {
readonly strategy?:
| QueuingStrategy<A>
| undefined
}
) => <E, R extends XR>(
self: Stream<A, E, R>
) => ReadableStream<A>) &
(<A, E, XR, R extends XR>(
self: Stream<A, E, R>,
context: Context.Context<XR>,
options?: {
readonly strategy?:
| QueuingStrategy<A>
| undefined
}
) => ReadableStream<A>)
Converts the stream to a ReadableStream using the provided services.
When to use
Use when bridging to Web Streams and you already have the Context required
to run the stream outside an Effect.
Details
See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
Example (Converting to a ReadableStream with services)
import { Context, Stream } from "effect"
const stream = Stream.make(1, 2, 3, 4, 5)
const readableStream = Stream.toReadableStreamWith(stream, Context.empty())
toReadableStreamWith(self: Stream<A, E>(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; <…;
}
import ContextContext.empty(), options: | {
readonly strategy?:
| QueuingStrategy<A>
| undefined
}
| undefined