effect 2.0.0-next.55 → 2.0.0-next.56

package/dist/dts/Stream.d.ts

@@ -58,7 +58,7 @@ export type StreamTypeId = typeof StreamTypeId;
  * @since 2.0.0
  * @category models
  */
-export interface Stream<R, E, A> extends Stream.Variance<R, E, A>, Pipeable {
+export interface Stream<out R, out E, out A> extends Stream.Variance<R, E, A>, Pipeable {
     [Unify.typeSymbol]?: unknown;
     [Unify.unifySymbol]?: StreamUnify<this>;
     [Unify.ignoreSymbol]?: StreamUnifyIgnore;
@@ -105,7 +105,7 @@ export declare namespace Stream {
      * @since 2.0.0
      * @category models
      */
-    interface Variance<R, E, A> {
+    interface Variance<out R, out E, out A> {
         readonly [StreamTypeId]: {
             _R: (_: never) => R;
             _E: (_: never) => E;
@@ -768,8 +768,8 @@ export declare const dropRight: {
  * @category utils
  */
 export declare const dropUntil: {
-    <A, X extends A>(predicate: Predicate<X>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
-    <R, E, A, X extends A>(self: Stream<R, E, A>, predicate: Predicate<X>): Stream<R, E, A>;
+    <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>;
+    <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>;
 };
 /**
  * Drops all elements of the stream until the specified effectful predicate
@@ -790,8 +790,8 @@ export declare const dropUntilEffect: {
  * @category utils
  */
 export declare const dropWhile: {
-    <A, X extends A>(predicate: Predicate<X>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
-    <R, E, A, X extends A>(self: Stream<R, E, A>, predicate: Predicate<X>): Stream<R, E, A>;
+    <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>;
+    <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>;
 };
 /**
  * Drops all elements of the stream for as long as the specified predicate
@@ -913,9 +913,9 @@ export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => St
  */
 export declare const filter: {
     <A, B extends A>(refinement: Refinement<A, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>;
-    <A, X extends A>(predicate: Predicate<X>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
+    <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>;
     <R, E, A, B extends A>(self: Stream<R, E, A>, refinement: Refinement<A, B>): Stream<R, E, B>;
-    <R, E, A, X extends A>(self: Stream<R, E, A>, predicate: Predicate<X>): Stream<R, E, A>;
+    <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>;
 };
 /**
  * Effectfully filters the elements emitted by this stream.
@@ -986,9 +986,9 @@ export declare const finalizer: <R, _>(finalizer: Effect.Effect<R, never, _>) =>
  */
 export declare const find: {
     <A, B extends A>(refinement: Refinement<A, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>;
-    <A, X extends A>(predicate: Predicate<X>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
+    <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>;
     <R, E, A, B extends A>(self: Stream<R, E, A>, refinement: Refinement<A, B>): Stream<R, E, B>;
-    <R, E, A, X extends A>(self: Stream<R, E, A>, predicate: Predicate<X>): Stream<R, E, A>;
+    <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>;
 };
 /**
  * Finds the first element emitted by this stream that satisfies the provided
@@ -1945,12 +1945,18 @@ 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?: {
+        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?: {
         bufferSize?: number | undefined;
-    }): <R, E>(self: Stream<R, E, A>) => Effect.Effect<Scope.Scope | R, E, [Stream<never, E, A>, Stream<never, E, A>]>;
+    }): <R, E, B extends A>(self: Stream<R, E, B>) => Effect.Effect<Scope.Scope | R, E, [excluded: Stream<never, E, B>, satisfying: Stream<never, E, B>]>;
+    <R, E, A, B extends A>(self: Stream<R, E, A>, refinement: Refinement<A, B>, options?: {
+        bufferSize?: number | undefined;
+    }): Effect.Effect<Scope.Scope | R, E, [excluded: Stream<never, E, Exclude<A, B>>, satisfying: Stream<never, E, B>]>;
     <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>, options?: {
         bufferSize?: number | undefined;
-    }): Effect.Effect<Scope.Scope | R, E, [Stream<never, E, A>, Stream<never, E, A>]>;
+    }): Effect.Effect<Scope.Scope | R, E, [excluded: Stream<never, E, A>, satisfying: Stream<never, E, A>]>;
 };
 /**
  * Split a stream by an effectful predicate. The faster stream may advance by
@@ -1962,10 +1968,10 @@ export declare const partition: {
 export declare const partitionEither: {
     <A, R2, E2, A2, A3>(predicate: (a: 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, [Stream<never, E2 | E, A2>, Stream<never, E2 | E, A3>]>;
+    }): <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?: {
         readonly bufferSize?: number | undefined;
-    }): Effect.Effect<Scope.Scope | R | R2, E | E2, [Stream<never, E | E2, A2>, Stream<never, E | E2, A3>]>;
+    }): Effect.Effect<Scope.Scope | R | R2, E | E2, [left: Stream<never, E | E2, A2>, right: Stream<never, E | E2, A3>]>;
 };
 /**
  * Peels off enough material from the stream to construct a `Z` using the
@@ -2713,7 +2719,7 @@ export declare const someOrFail: {
  * @category utils
  */
 export declare const split: {
-    <A>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>>;
+    <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, Chunk.Chunk<B>>;
     <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, Chunk.Chunk<A>>;
 };
 /**
@@ -2783,7 +2789,7 @@ export declare const takeRight: {
  * @category utils
  */
 export declare const takeUntil: {
-    <A>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
+    <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>;
     <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>;
 };
 /**
@@ -2805,7 +2811,9 @@ export declare const takeUntilEffect: {
  * @category utils
  */
 export declare const takeWhile: {
-    <A>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>;
+    <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>;
+    <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>;
 };
 /**
@@ -3127,8 +3135,8 @@ export declare const updateService: (<T extends Context.Tag<any, any>>(tag: T, f
  * @category utils
  */
 export declare const when: {
-    (predicate: LazyArg<boolean>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
-    <R, E, A>(self: Stream<R, E, A>, predicate: LazyArg<boolean>): Stream<R, E, A>;
+    (test: LazyArg<boolean>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>;
+    <R, E, A>(self: Stream<R, E, A>, test: LazyArg<boolean>): Stream<R, E, A>;
 };
 /**
  * Returns the resulting stream when the given `PartialFunction` is defined