effect 2.2.0 → 2.2.2

package/dist/dts/Stream.d.ts

@@ -27,7 +27,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 * as Types from "./Types.js";
+import type { Covariant, NoInfer } from "./Types.js";
 import type * as Unify from "./Unify.js";
 /**
  * @since 2.0.0
@@ -108,9 +108,9 @@ export declare namespace Stream {
      */
     interface Variance<out R, out E, out A> {
         readonly [StreamTypeId]: {
-            _R: Types.Covariant<R>;
-            _E: Types.Covariant<E>;
-            _A: Types.Covariant<A>;
+            _R: Covariant<R>;
+            _E: Covariant<E>;
+            _A: Covariant<A>;
         };
     }
     /**
@@ -769,7 +769,7 @@ export declare const dropRight: {
  * @category utils
  */
 export declare const dropUntil: {
-    <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>;
+    <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
     <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>;
 };
 /**
@@ -780,8 +780,8 @@ export declare const dropUntil: {
  * @category utils
  */
 export declare const dropUntilEffect: {
-    <A, X extends A, R2, E2>(predicate: (a: X) => Effect.Effect<R2, E2, boolean>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
-    <R, E, A, X extends A, R2, E2>(self: Stream<R, E, A>, predicate: (a: X) => Effect.Effect<R2, E2, boolean>): Stream<R | R2, E | E2, A>;
+    <A, R2, E2>(predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
+    <R, E, A, R2, E2>(self: Stream<R, E, A>, predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>): Stream<R | R2, E | E2, A>;
 };
 /**
  * Drops all elements of the stream for as long as the specified predicate
@@ -791,7 +791,7 @@ export declare const dropUntilEffect: {
  * @category utils
  */
 export declare const dropWhile: {
-    <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>;
+    <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
     <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>;
 };
 /**
@@ -802,8 +802,8 @@ export declare const dropWhile: {
  * @category utils
  */
 export declare const dropWhileEffect: {
-    <A, X extends A, R2, E2>(predicate: (a: X) => Effect.Effect<R2, E2, boolean>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
-    <R, E, A, X extends A, R2, E2>(self: Stream<R, E, A>, predicate: (a: X) => Effect.Effect<R2, E2, boolean>): Stream<R | R2, E | E2, A>;
+    <A, R2, E2>(predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
+    <R, E, A, R2, E2>(self: Stream<R, E, A>, predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>): Stream<R | R2, E | E2, A>;
 };
 /**
  * Returns a stream whose failures and successes have been lifted into an
@@ -913,8 +913,8 @@ export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => St
  * @category filtering
  */
 export declare const filter: {
-    <A, B extends A>(refinement: Refinement<A, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>;
-    <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>;
+    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>;
+    <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
     <R, E, A, B extends A>(self: Stream<R, E, A>, refinement: Refinement<A, B>): Stream<R, E, B>;
     <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>;
 };
@@ -925,8 +925,8 @@ export declare const filter: {
  * @category filtering
  */
 export declare const filterEffect: {
-    <A, X extends A, R2, E2>(f: (a: X) => Effect.Effect<R2, E2, boolean>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
-    <R, E, A, X extends A, R2, E2>(self: Stream<R, E, A>, f: (a: X) => Effect.Effect<R2, E2, boolean>): Stream<R | R2, E | E2, A>;
+    <A, R2, E2>(f: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
+    <R, E, A, R2, E2>(self: Stream<R, E, A>, f: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>): Stream<R | R2, E | E2, A>;
 };
 /**
  * Performs a filter and map in a single step.
@@ -986,8 +986,8 @@ export declare const finalizer: <R, _>(finalizer: Effect.Effect<R, never, _>) =>
  * @category elements
  */
 export declare const find: {
-    <A, B extends A>(refinement: Refinement<A, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>;
-    <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>;
+    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>;
+    <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
     <R, E, A, B extends A>(self: Stream<R, E, A>, refinement: Refinement<A, B>): Stream<R, E, B>;
     <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>;
 };
@@ -999,8 +999,8 @@ export declare const find: {
  * @category elements
  */
 export declare const findEffect: {
-    <A, X extends A, R2, E2>(predicate: (a: X) => Effect.Effect<R2, E2, boolean>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
-    <R, E, A, X extends A, R2, E2>(self: Stream<R, E, A>, predicate: (a: X) => Effect.Effect<R2, E2, boolean>): Stream<R | R2, E | E2, A>;
+    <A, R2, E2>(predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
+    <R, E, A, R2, E2>(self: Stream<R, E, A>, predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>): Stream<R | R2, E | E2, A>;
 };
 /**
  * Returns a stream made of the concatenation in strict order of all the
@@ -1946,7 +1946,7 @@ export declare const paginateEffect: <S, R, E, A>(s: S, f: (s: S) => Effect.Effe
  * @category utils
  */
 export declare const partition: {
-    <C extends A, B extends A, A = C>(refinement: Refinement<A, B>, options?: {
+    <C extends A, B extends A, A = C>(refinement: Refinement<NoInfer<A>, B>, options?: {
         bufferSize?: number | undefined;
     }): <R, E>(self: Stream<R, E, C>) => Effect.Effect<Scope.Scope | R, E, [excluded: Stream<never, E, Exclude<C, B>>, satisfying: Stream<never, E, B>]>;
     <A>(predicate: Predicate<A>, options?: {
@@ -1967,7 +1967,7 @@ export declare const partition: {
  * @category utils
  */
 export declare const partitionEither: {
-    <A, R2, E2, A2, A3>(predicate: (a: A) => Effect.Effect<R2, E2, Either.Either<A2, A3>>, options?: {
+    <A, R2, E2, A2, A3>(predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, Either.Either<A2, A3>>, options?: {
         readonly bufferSize?: number | undefined;
     }): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, [left: Stream<never, E2 | E, A2>, right: Stream<never, E2 | E, A3>]>;
     <R, E, A, R2, E2, A2, A3>(self: Stream<R, E, A>, predicate: (a: A) => Effect.Effect<R2, E2, Either.Either<A2, A3>>, options?: {
@@ -2720,7 +2720,7 @@ export declare const someOrFail: {
  * @category utils
  */
 export declare const split: {
-    <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, Chunk.Chunk<B>>;
+    <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>>;
     <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, Chunk.Chunk<A>>;
 };
 /**
@@ -2790,7 +2790,7 @@ export declare const takeRight: {
  * @category utils
  */
 export declare const takeUntil: {
-    <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>;
+    <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
     <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>;
 };
 /**
@@ -2801,7 +2801,7 @@ export declare const takeUntil: {
  * @category utils
  */
 export declare const takeUntilEffect: {
-    <A, R2, E2>(predicate: (a: A) => Effect.Effect<R2, E2, boolean>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
+    <A, R2, E2>(predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
     <R, E, A, R2, E2>(self: Stream<R, E, A>, predicate: (a: A) => Effect.Effect<R2, E2, boolean>): Stream<R | R2, E | E2, A>;
 };
 /**
@@ -2812,8 +2812,8 @@ export declare const takeUntilEffect: {
  * @category utils
  */
 export declare const takeWhile: {
-    <A, B extends A>(refinement: Refinement<A, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>;
-    <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>;
+    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>;
+    <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
     <R, E, A, B extends A>(self: Stream<R, E, A>, refinement: Refinement<A, B>): Stream<R, E, B>;
     <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>;
 };
@@ -2824,8 +2824,8 @@ export declare const takeWhile: {
  * @category sequencing
  */
 export declare const tap: {
-    <A, X extends A, R2, E2, _>(f: (a: X) => Effect.Effect<R2, E2, _>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
-    <R, E, A, X extends A, R2, E2, _>(self: Stream<R, E, A>, f: (a: X) => Effect.Effect<R2, E2, _>): Stream<R | R2, E | E2, A>;
+    <A, R2, E2, _>(f: (a: NoInfer<A>) => Effect.Effect<R2, E2, _>): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>;
+    <R, E, A, R2, E2, _>(self: Stream<R, E, A>, f: (a: NoInfer<A>) => Effect.Effect<R2, E2, _>): Stream<R | R2, E | E2, A>;
 };
 /**
  * Returns a stream that effectfully "peeks" at the failure or success of
@@ -2835,13 +2835,13 @@ export declare const tap: {
  * @category sequencing
  */
 export declare const tapBoth: {
-    <E, XE extends E, A, XA extends A, R2, E2, X, R3, E3, X1>(options: {
-        readonly onFailure: (e: XE) => Effect.Effect<R2, E2, X>;
-        readonly onSuccess: (a: XA) => Effect.Effect<R3, E3, X1>;
+    <E, R2, E2, X1, A, R3, E3, X2>(options: {
+        readonly onFailure: (e: NoInfer<E>) => Effect.Effect<R2, E2, X1>;
+        readonly onSuccess: (a: NoInfer<A>) => Effect.Effect<R3, E3, X2>;
     }): <R>(self: Stream<R, E, A>) => Stream<R | R2 | R3, E | E2 | E3, A>;
-    <R, E, A, XE extends E, XA extends A, R2, E2, X, R3, E3, X1>(self: Stream<R, E, A>, options: {
-        readonly onFailure: (e: XE) => Effect.Effect<R2, E2, X>;
-        readonly onSuccess: (a: XA) => Effect.Effect<R3, E3, X1>;
+    <R, E, A, R2, E2, X1, R3, E3, X2>(self: Stream<R, E, A>, options: {
+        readonly onFailure: (e: NoInfer<E>) => Effect.Effect<R2, E2, X1>;
+        readonly onSuccess: (a: NoInfer<A>) => Effect.Effect<R3, E3, X2>;
     }): Stream<R | R2 | R3, E | E2 | E3, A>;
 };
 /**
@@ -2851,8 +2851,8 @@ export declare const tapBoth: {
  * @category sequencing
  */
 export declare const tapError: {
-    <E, X extends E, R2, E2, _>(f: (error: X) => Effect.Effect<R2, E2, _>): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E | E2, A>;
-    <R, A, E, X extends E, R2, E2, _>(self: Stream<R, E, A>, f: (error: X) => Effect.Effect<R2, E2, _>): Stream<R | R2, E | E2, A>;
+    <E, R2, E2, _>(f: (error: NoInfer<E>) => Effect.Effect<R2, E2, _>): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E | E2, A>;
+    <R, A, E, R2, E2, _>(self: Stream<R, E, A>, f: (error: E) => Effect.Effect<R2, E2, _>): Stream<R | R2, E | E2, A>;
 };
 /**
  * Returns a stream that effectfully "peeks" at the cause of failure of the
@@ -2862,8 +2862,8 @@ export declare const tapError: {
  * @category utils
  */
 export declare const tapErrorCause: {
-    <E, X extends E, R2, E2, _>(f: (cause: Cause.Cause<X>) => Effect.Effect<R2, E2, _>): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E | E2, A>;
-    <R, A, E, X extends E, R2, E2, _>(self: Stream<R, E, A>, f: (cause: Cause.Cause<X>) => Effect.Effect<R2, E2, _>): Stream<R | R2, E | E2, A>;
+    <E, R2, E2, _>(f: (cause: Cause.Cause<NoInfer<E>>) => Effect.Effect<R2, E2, _>): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E | E2, A>;
+    <R, A, E, R2, E2, _>(self: Stream<R, E, A>, f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, _>): Stream<R | R2, E | E2, A>;
 };
 /**
  * Sends all elements emitted by this stream to the specified sink in addition