effect 3.4.9 → 3.5.0

package/dist/dts/Stream.d.ts

@@ -28,7 +28,7 @@ import type * as Emit from "./StreamEmit.js";
 import type * as HaltStrategy from "./StreamHaltStrategy.js";
 import type * as Take from "./Take.js";
 import type * as Tracer from "./Tracer.js";
-import type { Covariant, NoInfer } from "./Types.js";
+import type { Covariant, NoInfer, TupleOf } from "./Types.js";
 import type * as Unify from "./Unify.js";
 /**
  * @since 2.0.0
@@ -134,11 +134,13 @@ export declare namespace Stream {
     /**
      * @since 2.0.0
      * @category models
+     * @deprecated use Types.TupleOf instead
      */
     type DynamicTuple<T, N extends number> = N extends N ? number extends N ? Array<T> : DynamicTupleOf<T, N, []> : never;
     /**
      * @since 2.0.0
      * @category models
+     * @deprecated use Types.TupleOf instead
      */
     type DynamicTupleOf<T, N extends number, R extends Array<unknown>> = R["length"] extends N ? R : DynamicTupleOf<T, N, [T, ...R]>;
 }
@@ -267,7 +269,10 @@ export declare const as: {
     <B>(value: B): <A, E, R>(self: Stream<A, E, R>) => Stream<B, E, R>;
     <A, E, R, B>(self: Stream<A, E, R>, value: B): Stream<B, E, R>;
 };
-declare const _async: <A, E = never, R = never>(register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<void, never, R> | void, outputBuffer?: number) => Stream<A, E, R>;
+declare const _async: <A, E = never, R = never>(register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<void, never, R> | void, bufferSize?: number | "unbounded" | {
+    readonly bufferSize?: number | undefined;
+    readonly strategy?: "dropping" | "sliding" | "suspend" | undefined;
+} | undefined) => Stream<A, E, R>;
 export { 
 /**
  * Creates a stream from an asynchronous callback that can be called multiple
@@ -313,7 +318,10 @@ _async as async };
  * @since 2.0.0
  * @category constructors
  */
-export declare const asyncEffect: <A, E = never, R = never>(register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<unknown, E, R>, outputBuffer?: number) => Stream<A, E, R>;
+export declare const asyncEffect: <A, E = never, R = never>(register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<unknown, E, R>, bufferSize?: number | "unbounded" | {
+    readonly bufferSize?: number | undefined;
+    readonly strategy?: "dropping" | "sliding" | "suspend" | undefined;
+} | undefined) => Stream<A, E, R>;
 /**
  * Creates a stream from an asynchronous callback that can be called multiple
  * times. The registration of the callback itself returns an a scoped
@@ -323,7 +331,10 @@ export declare const asyncEffect: <A, E = never, R = never>(register: (emit: Emi
  * @since 2.0.0
  * @category constructors
  */
-export declare const asyncScoped: <A, E = never, R = never>(register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<unknown, E, R | Scope.Scope>, outputBuffer?: number) => Stream<A, E, Exclude<R, Scope.Scope>>;
+export declare const asyncScoped: <A, E = never, R = never>(register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<unknown, E, R | Scope.Scope>, bufferSize?: number | "unbounded" | {
+    readonly bufferSize?: number | undefined;
+    readonly strategy?: "dropping" | "sliding" | "suspend" | undefined;
+} | undefined) => Stream<A, E, Exclude<R, Scope.Scope>>;
 /**
  * Returns a `Stream` that first collects `n` elements from the input `Stream`,
  * and then creates a new `Stream` using the specified function, and sends all
@@ -416,8 +427,8 @@ export declare const branchAfter: {
  * @category utils
  */
 export declare const broadcast: {
-    <N extends number>(n: N, maximumLag: number): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Stream.DynamicTuple<Stream<A, E>, N>, never, Scope.Scope | R>;
-    <A, E, R, N extends number>(self: Stream<A, E, R>, n: N, maximumLag: number): Effect.Effect<Stream.DynamicTuple<Stream<A, E>, N>, never, Scope.Scope | R>;
+    <N extends number>(n: N, maximumLag: number): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<TupleOf<N, Stream<A, E>>, never, Scope.Scope | R>;
+    <A, E, R, N extends number>(self: Stream<A, E, R>, n: N, maximumLag: number): Effect.Effect<TupleOf<N, Stream<A, E>>, never, Scope.Scope | R>;
 };
 /**
  * Fan out the stream, producing a dynamic number of streams that have the
@@ -442,8 +453,8 @@ export declare const broadcastDynamic: {
  * @category utils
  */
 export declare const broadcastedQueues: {
-    <N extends number>(n: N, maximumLag: number): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Stream.DynamicTuple<Queue.Dequeue<Take.Take<A, E>>, N>, never, R | Scope.Scope>;
-    <A, E, R, N extends number>(self: Stream<A, E, R>, n: N, maximumLag: number): Effect.Effect<Stream.DynamicTuple<Queue.Dequeue<Take.Take<A, E>>, N>, never, Scope.Scope | R>;
+    <N extends number>(n: N, maximumLag: number): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<TupleOf<N, Queue.Dequeue<Take.Take<A, E>>>, never, R | Scope.Scope>;
+    <A, E, R, N extends number>(self: Stream<A, E, R>, n: N, maximumLag: number): Effect.Effect<TupleOf<N, Queue.Dequeue<Take.Take<A, E>>>, never, Scope.Scope | R>;
 };
 /**
  * Converts the stream to a scoped dynamic amount of queues. Every chunk will
@@ -941,12 +952,12 @@ export declare const distributedWith: {
         readonly size: N;
         readonly maximumLag: number;
         readonly decide: (a: A) => Effect.Effect<Predicate<number>>;
-    }): <E, R>(self: Stream<A, E, R>) => Effect.Effect<Stream.DynamicTuple<Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>, N>, never, Scope.Scope | R>;
+    }): <E, R>(self: Stream<A, E, R>) => Effect.Effect<TupleOf<N, Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>>, never, Scope.Scope | R>;
     <A, E, R, N extends number>(self: Stream<A, E, R>, options: {
         readonly size: N;
         readonly maximumLag: number;
         readonly decide: (a: A) => Effect.Effect<Predicate<number>>;
-    }): Effect.Effect<Stream.DynamicTuple<Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>, N>, never, Scope.Scope | R>;
+    }): Effect.Effect<TupleOf<N, Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>>, never, Scope.Scope | R>;
 };
 /**
  * More powerful version of `Stream.distributedWith`. This returns a function
@@ -2397,8 +2408,8 @@ export declare const mergeEither: {
  * @category utils
  */
 export declare const mergeLeft: {
-    <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, R2 | R>;
-    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A, E | E2, R | R2>;
+    <AR, ER, RR>(right: Stream<AR, ER, RR>): <AL, EL, RL>(left: Stream<AL, EL, RL>) => Stream<AL, ER | EL, RR | RL>;
+    <AL, EL, RL, AR, ER, RR>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>): Stream<AL, EL | ER, RL | RR>;
 };
 /**
  * Merges this stream and the specified stream together, discarding the values
@@ -2408,8 +2419,8 @@ export declare const mergeLeft: {
  * @category utils
  */
 export declare const mergeRight: {
-    <A2, E2, R2>(that: Stream<A2, E2, R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A2, E2 | E, R2 | R>;
-    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, that: Stream<A2, E2, R2>): Stream<A2, E | E2, R | R2>;
+    <AR, ER, RR>(right: Stream<AR, ER, RR>): <AL, EL, RL>(left: Stream<AL, EL, RL>) => Stream<AR, ER | EL, RR | RL>;
+    <AL, EL, RL, AR, ER, RR>(left: Stream<AL, EL, RL>, right: Stream<AR, ER, RR>): Stream<AR, EL | ER, RL | RR>;
 };
 /**
  * Returns a combined string resulting from concatenating each of the values
@@ -2803,6 +2814,33 @@ export declare const provideSomeLayer: {
     <RIn, E2, ROut>(layer: Layer.Layer<ROut, E2, RIn>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E2 | E, RIn | Exclude<R, ROut>>;
     <A, E, R, RIn, E2, ROut>(self: Stream<A, E, R>, layer: Layer.Layer<ROut, E2, RIn>): Stream<A, E | E2, RIn | Exclude<R, ROut>>;
 };
+/**
+ * Returns a stream that mirrors the first upstream to emit an item.
+ * As soon as one of the upstream emits a first value, all the others are interrupted.
+ * The resulting stream will forward all items from the "winning" source stream.
+ * Any upstream failures will cause the returned stream to fail.
+ *
+ * @example
+ * import { Stream, Schedule, Console, Effect } from "effect"
+ *
+ * const stream = Stream.raceAll(
+ *   Stream.fromSchedule(Schedule.spaced('1 millis')),
+ *   Stream.fromSchedule(Schedule.spaced('2 millis')),
+ *   Stream.fromSchedule(Schedule.spaced('4 millis')),
+ * ).pipe(Stream.take(6), Stream.tap(Console.log))
+ *
+ * Effect.runPromise(Stream.runDrain(stream))
+ * // Output each millisecond from the first stream, the rest streams are interrupted
+ * // 0
+ * // 1
+ * // 2
+ * // 3
+ * // 4
+ * // 5
+ * @since 3.5.0
+ * @category racing
+ */
+export declare const raceAll: <S extends ReadonlyArray<Stream<any, any, any>>>(...streams: S) => Stream<Stream.Success<S[number]>, Stream.Error<S[number]>, Stream.Context<S[number]>>;
 /**
  * Constructs a stream from a range of integers, including both endpoints.
  *
@@ -3044,7 +3082,7 @@ export declare const retry: {
  */
 export declare const run: {
     <A2, A, E2, R2>(sink: Sink.Sink<A2, A, unknown, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<A2, E2 | E, R2 | R>;
-    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, sink: Sink.Sink<A2, A, unknown, E2, R2>): Effect.Effect<A2, E | E2, R | R2>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, sink: Sink.Sink<A2, A, unknown, E2, R2>): Effect.Effect<A2, E | E2, Exclude<R | R2, Scope.Scope>>;
 };
 /**
  * Runs the stream and collects all of its elements to a chunk.
@@ -3052,21 +3090,21 @@ export declare const run: {
  * @since 2.0.0
  * @category destructors
  */
-export declare const runCollect: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Chunk.Chunk<A>, E, R>;
+export declare const runCollect: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Chunk.Chunk<A>, E, Exclude<R, Scope.Scope>>;
 /**
  * Runs the stream and emits the number of elements processed
  *
  * @since 2.0.0
  * @category destructors
  */
-export declare const runCount: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<number, E, R>;
+export declare const runCount: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<number, E, Exclude<R, Scope.Scope>>;
 /**
  * Runs the stream only for its effects. The emitted elements are discarded.
  *
  * @since 2.0.0
  * @category destructors
  */
-export declare const runDrain: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E, R>;
+export declare const runDrain: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E, Exclude<R, Scope.Scope>>;
 /**
  * Executes a pure fold over the stream of values - reduces all elements in
  * the stream to a value of type `S`.
@@ -3075,8 +3113,8 @@ export declare const runDrain: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect
  * @category destructors
  */
 export declare const runFold: {
-    <S, A>(s: S, f: (s: S, a: A) => S): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E, R>;
-    <A, E, R, S>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => S): Effect.Effect<S, E, R>;
+    <S, A>(s: S, f: (s: S, a: A) => S): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E, Exclude<R, Scope.Scope>>;
+    <A, E, R, S>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => S): Effect.Effect<S, E, Exclude<R, Scope.Scope>>;
 };
 /**
  * Executes an effectful fold over the stream of values.
@@ -3085,8 +3123,8 @@ export declare const runFold: {
  * @category destructors
  */
 export declare const runFoldEffect: {
-    <S, A, E2, R2>(s: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, R2 | R>;
-    <A, E, R, S, E2, R2>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): Effect.Effect<S, E | E2, R | R2>;
+    <S, A, E2, R2>(s: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, Exclude<R | R2, Scope.Scope>>;
+    <A, E, R, S, E2, R2>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): Effect.Effect<S, E | E2, Exclude<R | R2, Scope.Scope>>;
 };
 /**
  * Executes a pure fold over the stream of values. Returns a scoped value that
@@ -3118,8 +3156,8 @@ export declare const runFoldScopedEffect: {
  * @category destructors
  */
 export declare const runFoldWhile: {
-    <S, A>(s: S, cont: Predicate<S>, f: (s: S, a: A) => S): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E, R>;
-    <A, E, R, S>(self: Stream<A, E, R>, s: S, cont: Predicate<S>, f: (s: S, a: A) => S): Effect.Effect<S, E, R>;
+    <S, A>(s: S, cont: Predicate<S>, f: (s: S, a: A) => S): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E, Exclude<R, Scope.Scope>>;
+    <A, E, R, S>(self: Stream<A, E, R>, s: S, cont: Predicate<S>, f: (s: S, a: A) => S): Effect.Effect<S, E, Exclude<R, Scope.Scope>>;
 };
 /**
  * Executes an effectful fold over the stream of values. Stops the fold early
@@ -3129,8 +3167,8 @@ export declare const runFoldWhile: {
  * @category destructors
  */
 export declare const runFoldWhileEffect: {
-    <S, A, E2, R2>(s: S, cont: Predicate<S>, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, R2 | R>;
-    <A, E, R, S, E2, R2>(self: Stream<A, E, R>, s: S, cont: Predicate<S>, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): Effect.Effect<S, E | E2, R | R2>;
+    <S, A, E2, R2>(s: S, cont: Predicate<S>, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E2 | E, Exclude<R | R2, Scope.Scope>>;
+    <A, E, R, S, E2, R2>(self: Stream<A, E, R>, s: S, cont: Predicate<S>, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): Effect.Effect<S, E | E2, Exclude<R | R2, Scope.Scope>>;
 };
 /**
  * Executes a pure fold over the stream of values. Returns a scoped value that