effect 4.0.0-beta.17 → 4.0.0-beta.19

package/dist/Stream.d.ts

@@ -8,7 +8,7 @@ import * as Duration from "./Duration.ts";
 import * as Effect from "./Effect.ts";
 import * as ExecutionPlan from "./ExecutionPlan.ts";
 import * as Exit from "./Exit.ts";
-import * as Filter from "./Filter.ts";
+import type * as Filter from "./Filter.ts";
 import type { LazyArg } from "./Function.ts";
 import type { TypeLambda } from "./HKT.ts";
 import type * as Layer from "./Layer.ts";
@@ -4775,7 +4775,7 @@ export declare const filter: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, Result extends Filter.ResultOrBool>(filter: Filter.OrPredicate<NoInfer<A>, Result>): <E, R>(self: Stream<A, E, R>) => Stream<Filter.Pass<A, Result>, E, R>;
+    <A>(predicate: Predicate<NoInfer<A>>): <E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
     /**
      * Filters a stream to the elements that satisfy a predicate.
      *
@@ -4821,20 +4821,38 @@ export declare const filter: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, E, R, Result extends Filter.ResultOrBool>(self: Stream<A, E, R>, filter: Filter.OrPredicate<NoInfer<A>, Result>): Stream<Filter.Pass<A, Result>, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, predicate: Predicate<A>): Stream<A, E, R>;
 };
 /**
- * Effectfully filters and maps elements in a single pass.
+ * Filters and maps stream elements in one pass using a `Filter`.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export declare const filterMap: {
+    /**
+     * Filters and maps stream elements in one pass using a `Filter`.
+     *
+     * @since 4.0.0
+     * @category Filtering
+     */
+    <A, B, X>(filter: Filter.Filter<NoInfer<A>, B, X>): <E, R>(self: Stream<A, E, R>) => Stream<B, E, R>;
+    /**
+     * Filters and maps stream elements in one pass using a `Filter`.
+     *
+     * @since 4.0.0
+     * @category Filtering
+     */
+    <A, E, R, B, X>(self: Stream<A, E, R>, filter: Filter.Filter<A, B, X>): Stream<B, E, R>;
+};
+/**
+ * Effectfully filters elements in a single pass.
  *
  * @example
  * ```ts
- * import { Console, Effect, Filter, Result, Stream } from "effect"
- *
- * const filter = Filter.makeEffect((n: number) =>
- *   Effect.succeed(n > 2 ? Result.succeed(n + 1) : Result.fail(n))
- * )
+ * import { Console, Effect, Stream } from "effect"
  *
- * const stream = Stream.make(1, 2, 3, 4).pipe(Stream.filterEffect(filter))
+ * const stream = Stream.make(1, 2, 3, 4).pipe(Stream.filterEffect((n) => Effect.succeed(n > 2)))
  *
  * const program = Effect.gen(function*() {
  *   const result = yield* Stream.runCollect(stream)
@@ -4842,7 +4860,7 @@ export declare const filter: {
  * })
  *
  * Effect.runPromise(program)
- * // Output: [ 4, 5 ]
+ * // Output: [ 3, 4 ]
  * ```
  *
  * @since 2.0.0
@@ -4850,17 +4868,13 @@ export declare const filter: {
  */
 export declare const filterEffect: {
     /**
-     * Effectfully filters and maps elements in a single pass.
+     * Effectfully filters elements in a single pass.
      *
      * @example
      * ```ts
-     * import { Console, Effect, Filter, Result, Stream } from "effect"
-     *
-     * const filter = Filter.makeEffect((n: number) =>
-     *   Effect.succeed(n > 2 ? Result.succeed(n + 1) : Result.fail(n))
-     * )
+     * import { Console, Effect, Stream } from "effect"
      *
-     * const stream = Stream.make(1, 2, 3, 4).pipe(Stream.filterEffect(filter))
+     * const stream = Stream.make(1, 2, 3, 4).pipe(Stream.filterEffect((n) => Effect.succeed(n > 2)))
      *
      * const program = Effect.gen(function*() {
      *   const result = yield* Stream.runCollect(stream)
@@ -4868,25 +4882,21 @@ export declare const filterEffect: {
      * })
      *
      * Effect.runPromise(program)
-     * // Output: [ 4, 5 ]
+     * // Output: [ 3, 4 ]
      * ```
      *
      * @since 2.0.0
      * @category Filtering
      */
-    <A, B, X, EX, RX>(filter: Filter.FilterEffect<A, B, X, EX, RX>): <E, R>(self: Stream<A, E, R>) => Stream<B, E | EX, R | RX>;
+    <A, EX, RX>(predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, EX, RX>): <E, R>(self: Stream<A, E, R>) => Stream<A, E | EX, R | RX>;
     /**
-     * Effectfully filters and maps elements in a single pass.
+     * Effectfully filters elements in a single pass.
      *
      * @example
      * ```ts
-     * import { Console, Effect, Filter, Result, Stream } from "effect"
-     *
-     * const filter = Filter.makeEffect((n: number) =>
-     *   Effect.succeed(n > 2 ? Result.succeed(n + 1) : Result.fail(n))
-     * )
+     * import { Console, Effect, Stream } from "effect"
      *
-     * const stream = Stream.make(1, 2, 3, 4).pipe(Stream.filterEffect(filter))
+     * const stream = Stream.make(1, 2, 3, 4).pipe(Stream.filterEffect((n) => Effect.succeed(n > 2)))
      *
      * const program = Effect.gen(function*() {
      *   const result = yield* Stream.runCollect(stream)
@@ -4894,28 +4904,48 @@ export declare const filterEffect: {
      * })
      *
      * Effect.runPromise(program)
-     * // Output: [ 4, 5 ]
+     * // Output: [ 3, 4 ]
      * ```
      *
      * @since 2.0.0
      * @category Filtering
      */
+    <A, E, R, EX, RX>(self: Stream<A, E, R>, predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, EX, RX>): Stream<A, E | EX, R | RX>;
+};
+/**
+ * Effectfully filters and maps elements in a single pass.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export declare const filterMapEffect: {
+    /**
+     * Effectfully filters and maps elements in a single pass.
+     *
+     * @since 4.0.0
+     * @category Filtering
+     */
+    <A, B, X, EX, RX>(filter: Filter.FilterEffect<NoInfer<A>, B, X, EX, RX>): <E, R>(self: Stream<A, E, R>) => Stream<B, E | EX, R | RX>;
+    /**
+     * Effectfully filters and maps elements in a single pass.
+     *
+     * @since 4.0.0
+     * @category Filtering
+     */
     <A, E, R, B, X, EX, RX>(self: Stream<A, E, R>, filter: Filter.FilterEffect<A, B, X, EX, RX>): Stream<B, E | EX, R | RX>;
 };
 /**
- * Partitions a stream using a Filter and exposes passing and failing values as queues.
+ * Partitions a stream using a `Filter` and exposes passing and failing values as queues.
  *
  * Each queue fails with the stream error or `Cause.Done` when the source ends.
  *
  * @example
  * ```ts
- * import { Console, Effect, Filter, Result, Stream } from "effect"
+ * import { Console, Effect, Result, Stream } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const [passes, fails] = yield* Stream.make(1, 2, 3, 4).pipe(
- *     Stream.partitionQueue(
- *       Filter.make((n) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n)))
- *     )
+ *     Stream.partitionQueue((n) => n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
  *   )
  *
  *   const passValues = yield* Stream.fromQueue(passes).pipe(Stream.runCollect)
@@ -4935,56 +4965,17 @@ export declare const filterEffect: {
  */
 export declare const partitionQueue: {
     /**
-     * Partitions a stream using a Filter and exposes passing and failing values as queues.
+     * Partitions a stream using a `Filter` and exposes passing and failing values as queues.
      *
      * Each queue fails with the stream error or `Cause.Done` when the source ends.
      *
      * @example
      * ```ts
-     * import { Console, Effect, Filter, Result, Stream } from "effect"
-     *
-     * const program = Effect.gen(function*() {
-     *   const [passes, fails] = yield* Stream.make(1, 2, 3, 4).pipe(
-     *     Stream.partitionQueue(
-     *       Filter.make((n) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n)))
-     *     )
-     *   )
-     *
-     *   const passValues = yield* Stream.fromQueue(passes).pipe(Stream.runCollect)
-     *   const failValues = yield* Stream.fromQueue(fails).pipe(Stream.runCollect)
-     *
-     *   yield* Console.log(passValues)
-     *   // Output: [ 2, 4 ]
-     *   yield* Console.log(failValues)
-     *   // Output: [ 1, 3 ]
-     * })
-     *
-     * Effect.runPromise(Effect.scoped(program))
-     * ```
-     *
-     * @since 4.0.0
-     * @category Filtering
-     */
-    <A, B extends A>(refinement: Refinement<NoInfer<A>, B>, options?: {
-        readonly capacity?: number | "unbounded" | undefined;
-    }): <E, R>(self: Stream<A, E, R>) => Effect.Effect<[
-        passes: Queue.Dequeue<B, E | Cause.Done>,
-        fails: Queue.Dequeue<Exclude<A, B>, E | Cause.Done>
-    ], never, R | Scope.Scope>;
-    /**
-     * Partitions a stream using a Filter and exposes passing and failing values as queues.
-     *
-     * Each queue fails with the stream error or `Cause.Done` when the source ends.
-     *
-     * @example
-     * ```ts
-     * import { Console, Effect, Filter, Result, Stream } from "effect"
+     * import { Console, Effect, Result, Stream } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const [passes, fails] = yield* Stream.make(1, 2, 3, 4).pipe(
-     *     Stream.partitionQueue(
-     *       Filter.make((n) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n)))
-     *     )
+     *     Stream.partitionQueue((n) => n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
      *   )
      *
      *   const passValues = yield* Stream.fromQueue(passes).pipe(Stream.runCollect)
@@ -5002,63 +4993,24 @@ export declare const partitionQueue: {
      * @since 4.0.0
      * @category Filtering
      */
-    <A, Result extends Filter.ResultOrBool>(filter: Filter.OrPredicate<NoInfer<A>, Result>, options?: {
+    <A, Pass, Fail>(filter: Filter.Filter<NoInfer<A>, Pass, Fail>, options?: {
         readonly capacity?: number | "unbounded" | undefined;
     }): <E, R>(self: Stream<A, E, R>) => Effect.Effect<[
-        passes: Queue.Dequeue<Filter.Pass<A, Result>, E | Cause.Done>,
-        fails: Queue.Dequeue<Filter.Fail<A, Result>, E | Cause.Done>
+        passes: Queue.Dequeue<Pass, E | Cause.Done>,
+        fails: Queue.Dequeue<Fail, E | Cause.Done>
     ], never, R | Scope.Scope>;
     /**
-     * Partitions a stream using a Filter and exposes passing and failing values as queues.
+     * Partitions a stream using a `Filter` and exposes passing and failing values as queues.
      *
      * Each queue fails with the stream error or `Cause.Done` when the source ends.
      *
      * @example
      * ```ts
-     * import { Console, Effect, Filter, Result, Stream } from "effect"
-     *
-     * const program = Effect.gen(function*() {
-     *   const [passes, fails] = yield* Stream.make(1, 2, 3, 4).pipe(
-     *     Stream.partitionQueue(
-     *       Filter.make((n) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n)))
-     *     )
-     *   )
-     *
-     *   const passValues = yield* Stream.fromQueue(passes).pipe(Stream.runCollect)
-     *   const failValues = yield* Stream.fromQueue(fails).pipe(Stream.runCollect)
-     *
-     *   yield* Console.log(passValues)
-     *   // Output: [ 2, 4 ]
-     *   yield* Console.log(failValues)
-     *   // Output: [ 1, 3 ]
-     * })
-     *
-     * Effect.runPromise(Effect.scoped(program))
-     * ```
-     *
-     * @since 4.0.0
-     * @category Filtering
-     */
-    <A, E, R, B extends A>(self: Stream<A, E, R>, refinement: Refinement<A, B>, options?: {
-        readonly capacity?: number | "unbounded" | undefined;
-    }): Effect.Effect<[
-        passes: Queue.Dequeue<B, E | Cause.Done>,
-        fails: Queue.Dequeue<Exclude<A, B>, E | Cause.Done>
-    ], never, R | Scope.Scope>;
-    /**
-     * Partitions a stream using a Filter and exposes passing and failing values as queues.
-     *
-     * Each queue fails with the stream error or `Cause.Done` when the source ends.
-     *
-     * @example
-     * ```ts
-     * import { Console, Effect, Filter, Result, Stream } from "effect"
+     * import { Console, Effect, Result, Stream } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const [passes, fails] = yield* Stream.make(1, 2, 3, 4).pipe(
-     *     Stream.partitionQueue(
-     *       Filter.make((n) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n)))
-     *     )
+     *     Stream.partitionQueue((n) => n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
      *   )
      *
      *   const passValues = yield* Stream.fromQueue(passes).pipe(Stream.runCollect)
@@ -5076,119 +5028,49 @@ export declare const partitionQueue: {
      * @since 4.0.0
      * @category Filtering
      */
-    <A, E, R, Result extends Filter.ResultOrBool>(self: Stream<A, E, R>, filter: Filter.OrPredicate<NoInfer<A>, Result>, options?: {
+    <A, E, R, Pass, Fail>(self: Stream<A, E, R>, filter: Filter.Filter<NoInfer<A>, Pass, Fail>, options?: {
         readonly capacity?: number | "unbounded" | undefined;
     }): Effect.Effect<[
-        passes: Queue.Dequeue<Filter.Pass<A, Result>, E | Cause.Done>,
-        fails: Queue.Dequeue<Filter.Fail<A, Result>, E | Cause.Done>
+        passes: Queue.Dequeue<Pass, E | Cause.Done>,
+        fails: Queue.Dequeue<Fail, E | Cause.Done>
     ], never, R | Scope.Scope>;
 };
 /**
- * Splits a stream using an effectful filter, producing pass and fail streams.
+ * Splits a stream using an effectful `Filter`, producing pass and fail streams.
  *
  * @since 4.0.0
  * @category Filtering
- *
- * @example
- * ```ts
- * import { Console, Effect, Result, Stream } from "effect"
- *
- * const program = Effect.scoped(
- *   Effect.gen(function*() {
- *     const [evens, odds] = yield* Stream.make(1, 2, 3, 4).pipe(
- *       Stream.partitionEffect((n) =>
- *         Effect.succeed(n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
- *       )
- *     )
- *     const result = yield* Effect.all({
- *       evens: Stream.runCollect(evens),
- *       odds: Stream.runCollect(odds)
- *     })
- *     yield* Console.log(result)
- *   })
- * )
- *
- * Effect.runPromise(program)
- * // Output: { evens: [ 2, 4 ], odds: [ 1, 3 ] }
- * ```
  */
 export declare const partitionEffect: {
     /**
-     * Splits a stream using an effectful filter, producing pass and fail streams.
+     * Splits a stream using an effectful `Filter`, producing pass and fail streams.
      *
      * @since 4.0.0
      * @category Filtering
-     *
-     * @example
-     * ```ts
-     * import { Console, Effect, Result, Stream } from "effect"
-     *
-     * const program = Effect.scoped(
-     *   Effect.gen(function*() {
-     *     const [evens, odds] = yield* Stream.make(1, 2, 3, 4).pipe(
-     *       Stream.partitionEffect((n) =>
-     *         Effect.succeed(n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
-     *       )
-     *     )
-     *     const result = yield* Effect.all({
-     *       evens: Stream.runCollect(evens),
-     *       odds: Stream.runCollect(odds)
-     *     })
-     *     yield* Console.log(result)
-     *   })
-     * )
-     *
-     * Effect.runPromise(program)
-     * // Output: { evens: [ 2, 4 ], odds: [ 1, 3 ] }
-     * ```
      */
-    <A, B, X, EX, RX>(filter: Filter.FilterEffect<A, B, X, EX, RX>, options?: {
+    <A, Pass, Fail, EX, RX>(filter: Filter.FilterEffect<NoInfer<A>, Pass, Fail, EX, RX>, options?: {
         readonly capacity?: number | "unbounded" | undefined;
         readonly concurrency?: number | "unbounded" | undefined;
     }): <E, R>(self: Stream<A, E, R>) => Effect.Effect<[
-        passes: Stream<B, E | EX>,
-        fails: Stream<X, E | EX>
+        passes: Stream<Pass, E | EX>,
+        fails: Stream<Fail, E | EX>
     ], never, R | RX | Scope.Scope>;
     /**
-     * Splits a stream using an effectful filter, producing pass and fail streams.
+     * Splits a stream using an effectful `Filter`, producing pass and fail streams.
      *
      * @since 4.0.0
      * @category Filtering
-     *
-     * @example
-     * ```ts
-     * import { Console, Effect, Result, Stream } from "effect"
-     *
-     * const program = Effect.scoped(
-     *   Effect.gen(function*() {
-     *     const [evens, odds] = yield* Stream.make(1, 2, 3, 4).pipe(
-     *       Stream.partitionEffect((n) =>
-     *         Effect.succeed(n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
-     *       )
-     *     )
-     *     const result = yield* Effect.all({
-     *       evens: Stream.runCollect(evens),
-     *       odds: Stream.runCollect(odds)
-     *     })
-     *     yield* Console.log(result)
-     *   })
-     * )
-     *
-     * Effect.runPromise(program)
-     * // Output: { evens: [ 2, 4 ], odds: [ 1, 3 ] }
-     * ```
      */
-    <A, E, R, B, X, EX, RX>(self: Stream<A, E, R>, filter: Filter.FilterEffect<A, B, X, EX, RX>, options?: {
+    <A, E, R, Pass, Fail, EX, RX>(self: Stream<A, E, R>, filter: Filter.FilterEffect<NoInfer<A>, Pass, Fail, EX, RX>, options?: {
         readonly capacity?: number | "unbounded" | undefined;
         readonly concurrency?: number | "unbounded" | undefined;
     }): Effect.Effect<[
-        passes: Stream<B, E | EX>,
-        fails: Stream<X, E | EX>
+        passes: Stream<Pass, E | EX>,
+        fails: Stream<Fail, E | EX>
     ], never, R | RX | Scope.Scope>;
 };
 /**
- * Splits a stream into excluded and satisfying substreams using a predicate,
- * refinement, or Filter.
+ * Splits a stream into excluded and satisfying substreams using a `Filter`.
  *
  * The faster stream may advance up to `bufferSize` elements ahead of the slower
  * one.
@@ -5198,12 +5080,12 @@ export declare const partitionEffect: {
  *
  * @example
  * ```ts
- * import { Console, Effect, Stream } from "effect"
+ * import { Console, Effect, Result, Stream } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const [excluded, satisfying] = yield* Stream.partition(
  *     Stream.make(1, 2, 3, 4),
- *     (n) => n % 2 === 0
+ *     (n) => n % 2 === 0 ? Result.succeed(n) : Result.fail(n)
  *   )
  *   const left = yield* Stream.runCollect(excluded)
  *   const right = yield* Stream.runCollect(satisfying)
@@ -5216,8 +5098,7 @@ export declare const partitionEffect: {
  */
 export declare const partition: {
     /**
-     * Splits a stream into excluded and satisfying substreams using a predicate,
-     * refinement, or Filter.
+     * Splits a stream into excluded and satisfying substreams using a `Filter`.
      *
      * The faster stream may advance up to `bufferSize` elements ahead of the slower
      * one.
@@ -5227,46 +5108,12 @@ export declare const partition: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Stream } from "effect"
-     *
-     * const program = Effect.gen(function*() {
-     *   const [excluded, satisfying] = yield* Stream.partition(
-     *     Stream.make(1, 2, 3, 4),
-     *     (n) => n % 2 === 0
-     *   )
-     *   const left = yield* Stream.runCollect(excluded)
-     *   const right = yield* Stream.runCollect(satisfying)
-     *   yield* Console.log(left)
-     *   // Output: [ 1, 3 ]
-     *   yield* Console.log(right)
-     *   // Output: [ 2, 4 ]
-     * })
-     * ```
-     */
-    <C extends A, B extends A, A = C>(refinement: Refinement<NoInfer<A>, B>, options?: {
-        readonly bufferSize?: number | undefined;
-    }): <E, R>(self: Stream<C, E, R>) => Effect.Effect<[
-        excluded: Stream<Exclude<C, B>, E>,
-        satisfying: Stream<B, E>
-    ], never, R | Scope.Scope>;
-    /**
-     * Splits a stream into excluded and satisfying substreams using a predicate,
-     * refinement, or Filter.
-     *
-     * The faster stream may advance up to `bufferSize` elements ahead of the slower
-     * one.
-     *
-     * @since 4.0.0
-     * @category Filtering
-     *
-     * @example
-     * ```ts
-     * import { Console, Effect, Stream } from "effect"
+     * import { Console, Effect, Result, Stream } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const [excluded, satisfying] = yield* Stream.partition(
      *     Stream.make(1, 2, 3, 4),
-     *     (n) => n % 2 === 0
+     *     (n) => n % 2 === 0 ? Result.succeed(n) : Result.fail(n)
      *   )
      *   const left = yield* Stream.runCollect(excluded)
      *   const right = yield* Stream.runCollect(satisfying)
@@ -5277,15 +5124,14 @@ export declare const partition: {
      * })
      * ```
      */
-    <A, Result extends Filter.ResultOrBool>(filter: Filter.OrPredicate<NoInfer<A>, Result>, options?: {
+    <A, Pass, Fail>(filter: Filter.Filter<NoInfer<A>, Pass, Fail>, options?: {
         readonly bufferSize?: number | undefined;
     }): <E, R>(self: Stream<A, E, R>) => Effect.Effect<[
-        excluded: Stream<Filter.Fail<A, Result>, E>,
-        satisfying: Stream<Filter.Pass<A, Result>, E>
+        excluded: Stream<Fail, E>,
+        satisfying: Stream<Pass, E>
     ], never, R | Scope.Scope>;
     /**
-     * Splits a stream into excluded and satisfying substreams using a predicate,
-     * refinement, or Filter.
+     * Splits a stream into excluded and satisfying substreams using a `Filter`.
      *
      * The faster stream may advance up to `bufferSize` elements ahead of the slower
      * one.
@@ -5295,46 +5141,12 @@ export declare const partition: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Stream } from "effect"
-     *
-     * const program = Effect.gen(function*() {
-     *   const [excluded, satisfying] = yield* Stream.partition(
-     *     Stream.make(1, 2, 3, 4),
-     *     (n) => n % 2 === 0
-     *   )
-     *   const left = yield* Stream.runCollect(excluded)
-     *   const right = yield* Stream.runCollect(satisfying)
-     *   yield* Console.log(left)
-     *   // Output: [ 1, 3 ]
-     *   yield* Console.log(right)
-     *   // Output: [ 2, 4 ]
-     * })
-     * ```
-     */
-    <C extends A, E, R, B extends A, A = C>(self: Stream<C, E, R>, refinement: Refinement<A, B>, options?: {
-        readonly bufferSize?: number | undefined;
-    }): Effect.Effect<[
-        excluded: Stream<Exclude<C, B>, E>,
-        satisfying: Stream<B, E>
-    ], never, R | Scope.Scope>;
-    /**
-     * Splits a stream into excluded and satisfying substreams using a predicate,
-     * refinement, or Filter.
-     *
-     * The faster stream may advance up to `bufferSize` elements ahead of the slower
-     * one.
-     *
-     * @since 4.0.0
-     * @category Filtering
-     *
-     * @example
-     * ```ts
-     * import { Console, Effect, Stream } from "effect"
+     * import { Console, Effect, Result, Stream } from "effect"
      *
      * const program = Effect.gen(function*() {
      *   const [excluded, satisfying] = yield* Stream.partition(
      *     Stream.make(1, 2, 3, 4),
-     *     (n) => n % 2 === 0
+     *     (n) => n % 2 === 0 ? Result.succeed(n) : Result.fail(n)
      *   )
      *   const left = yield* Stream.runCollect(excluded)
      *   const right = yield* Stream.runCollect(satisfying)
@@ -5345,11 +5157,11 @@ export declare const partition: {
      * })
      * ```
      */
-    <A, E, R, Result extends Filter.ResultOrBool>(self: Stream<A, E, R>, filter: Filter.OrPredicate<NoInfer<A>, Result>, options?: {
+    <A, E, R, Pass, Fail>(self: Stream<A, E, R>, filter: Filter.Filter<NoInfer<A>, Pass, Fail>, options?: {
         readonly bufferSize?: number | undefined;
     }): Effect.Effect<[
-        excluded: Stream<Filter.Fail<A, Result>, E>,
-        satisfying: Stream<Filter.Pass<A, Result>, E>
+        excluded: Stream<Fail, E>,
+        satisfying: Stream<Pass, E>
     ], never, R | Scope.Scope>;
 };
 /**
@@ -6043,7 +5855,7 @@ export declare const tapError: {
     <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, f: (error: E) => Effect.Effect<A2, E2, R2>): Stream<A, E | E2, R | R2>;
 };
 /**
- * Recovers from errors that match a filter by switching to a recovery stream.
+ * Recovers from errors that match a predicate by switching to a recovery stream.
  *
  * When a failure matches the filter, the stream switches to the recovery
  * stream. Non-matching failures propagate downstream, so the error type is
@@ -6057,12 +5869,12 @@ export declare const tapError: {
  *
  * @example
  * ```ts
- * import { Console, Effect, Filter, Stream } from "effect"
+ * import { Console, Effect, Stream } from "effect"
  *
  * const stream = Stream.make(1, 2).pipe(
  *   Stream.concat(Stream.fail(42)),
  *   Stream.catchIf(
- *     Filter.fromPredicate((error): error is 42 => error === 42),
+ *     (error): error is 42 => error === 42,
  *     () => Stream.make(999)
  *   )
  * )
@@ -6081,7 +5893,7 @@ export declare const tapError: {
  */
 export declare const catchIf: {
     /**
-     * Recovers from errors that match a filter by switching to a recovery stream.
+     * Recovers from errors that match a predicate by switching to a recovery stream.
      *
      * When a failure matches the filter, the stream switches to the recovery
      * stream. Non-matching failures propagate downstream, so the error type is
@@ -6095,12 +5907,12 @@ export declare const catchIf: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Filter, Stream } from "effect"
+     * import { Console, Effect, Stream } from "effect"
      *
      * const stream = Stream.make(1, 2).pipe(
      *   Stream.concat(Stream.fail(42)),
      *   Stream.catchIf(
-     *     Filter.fromPredicate((error): error is 42 => error === 42),
+     *     (error): error is 42 => error === 42,
      *     () => Stream.make(999)
      *   )
      * )
@@ -6119,7 +5931,7 @@ export declare const catchIf: {
      */
     <E, EB extends E, A2, E2, R2, A3 = never, E3 = Exclude<E, EB>, R3 = never>(refinement: Refinement<NoInfer<E>, EB>, f: (e: EB) => Stream<A2, E2, R2>, orElse?: ((e: Exclude<E, EB>) => Stream<A3, E3, R3>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A2 | A | A3, E2 | E3, R2 | R | R3>;
     /**
-     * Recovers from errors that match a filter by switching to a recovery stream.
+     * Recovers from errors that match a predicate by switching to a recovery stream.
      *
      * When a failure matches the filter, the stream switches to the recovery
      * stream. Non-matching failures propagate downstream, so the error type is
@@ -6133,12 +5945,12 @@ export declare const catchIf: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Filter, Stream } from "effect"
+     * import { Console, Effect, Stream } from "effect"
      *
      * const stream = Stream.make(1, 2).pipe(
      *   Stream.concat(Stream.fail(42)),
      *   Stream.catchIf(
-     *     Filter.fromPredicate((error): error is 42 => error === 42),
+     *     (error): error is 42 => error === 42,
      *     () => Stream.make(999)
      *   )
      * )
@@ -6155,9 +5967,9 @@ export declare const catchIf: {
      * @since 4.0.0
      * @category Error Handling
      */
-    <E, Result extends Filter.ResultOrBool, A2, E2, R2, A3 = never, E3 = Filter.Fail<E, Result>, R3 = never>(filter: Filter.OrPredicate<NoInfer<E>, Result>, f: (failure: Filter.Pass<E, Result>) => Stream<A2, E2, R2>, orElse?: ((failure: Filter.Fail<E, Result>) => Stream<A3, E3, R3>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | A2 | A3, E2 | E3, R | R2 | R3>;
+    <E, A2, E2, R2, A3 = never, E3 = E, R3 = never>(predicate: Predicate<NoInfer<E>>, f: (e: NoInfer<E>) => Stream<A2, E2, R2>, orElse?: ((e: NoInfer<E>) => Stream<A3, E3, R3>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A2 | A | A3, E2 | E3, R2 | R | R3>;
     /**
-     * Recovers from errors that match a filter by switching to a recovery stream.
+     * Recovers from errors that match a predicate by switching to a recovery stream.
      *
      * When a failure matches the filter, the stream switches to the recovery
      * stream. Non-matching failures propagate downstream, so the error type is
@@ -6171,12 +5983,12 @@ export declare const catchIf: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Filter, Stream } from "effect"
+     * import { Console, Effect, Stream } from "effect"
      *
      * const stream = Stream.make(1, 2).pipe(
      *   Stream.concat(Stream.fail(42)),
      *   Stream.catchIf(
-     *     Filter.fromPredicate((error): error is 42 => error === 42),
+     *     (error): error is 42 => error === 42,
      *     () => Stream.make(999)
      *   )
      * )
@@ -6195,7 +6007,7 @@ export declare const catchIf: {
      */
     <A, E, R, EB extends E, A2, E2, R2, A3 = never, E3 = Exclude<E, EB>, R3 = never>(self: Stream<A, E, R>, refinement: Refinement<E, EB>, f: (e: EB) => Stream<A2, E2, R2>, orElse?: ((e: Exclude<E, EB>) => Stream<A3, E3, R3>) | undefined): Stream<A | A2 | A3, E2 | E3, R | R2 | R3>;
     /**
-     * Recovers from errors that match a filter by switching to a recovery stream.
+     * Recovers from errors that match a predicate by switching to a recovery stream.
      *
      * When a failure matches the filter, the stream switches to the recovery
      * stream. Non-matching failures propagate downstream, so the error type is
@@ -6209,12 +6021,12 @@ export declare const catchIf: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Filter, Stream } from "effect"
+     * import { Console, Effect, Stream } from "effect"
      *
      * const stream = Stream.make(1, 2).pipe(
      *   Stream.concat(Stream.fail(42)),
      *   Stream.catchIf(
-     *     Filter.fromPredicate((error): error is 42 => error === 42),
+     *     (error): error is 42 => error === 42,
      *     () => Stream.make(999)
      *   )
      * )
@@ -6231,7 +6043,32 @@ export declare const catchIf: {
      * @since 4.0.0
      * @category Error Handling
      */
-    <A, E, R, Result extends Filter.ResultOrBool, A2, E2, R2, A3 = never, E3 = Filter.Fail<E, Result>, R3 = never>(self: Stream<A, E, R>, filter: Filter.OrPredicate<NoInfer<E>, Result>, f: (failure: Filter.Pass<E, Result>) => Stream<A2, E2, R2>, orElse?: ((failure: Filter.Fail<E, Result>) => Stream<A3, E3, R3>) | undefined): Stream<A | A2 | A3, E2 | E3, R | R2 | R3>;
+    <A, E, R, A2, E2, R2, A3 = never, E3 = E, R3 = never>(self: Stream<A, E, R>, predicate: Predicate<E>, f: (e: E) => Stream<A2, E2, R2>, orElse?: ((e: E) => Stream<A3, E3, R3>) | undefined): Stream<A | A2 | A3, E2 | E3, R | R2 | R3>;
+};
+/**
+ * Recovers from errors that match a `Filter` by switching to a recovery
+ * stream.
+ *
+ * @since 4.0.0
+ * @category Error Handling
+ */
+export declare const catchFilter: {
+    /**
+     * Recovers from errors that match a `Filter` by switching to a recovery
+     * stream.
+     *
+     * @since 4.0.0
+     * @category Error Handling
+     */
+    <E, EB, A2, E2, R2, X, A3 = never, E3 = X, R3 = never>(filter: Filter.Filter<NoInfer<E>, EB, X>, f: (failure: EB) => Stream<A2, E2, R2>, orElse?: ((failure: X) => Stream<A3, E3, R3>) | undefined): <A, R>(self: Stream<A, E, R>) => Stream<A | A2 | A3, E2 | E3, R | R2 | R3>;
+    /**
+     * Recovers from errors that match a `Filter` by switching to a recovery
+     * stream.
+     *
+     * @since 4.0.0
+     * @category Error Handling
+     */
+    <A, E, R, EB, A2, E2, R2, X, A3 = never, E3 = X, R3 = never>(self: Stream<A, E, R>, filter: Filter.Filter<NoInfer<E>, EB, X>, f: (failure: EB) => Stream<A2, E2, R2>, orElse?: ((failure: X) => Stream<A3, E3, R3>) | undefined): Stream<A | A2 | A3, E2 | E3, R | R2 | R3>;
 };
 /**
  * Recovers from failures whose `_tag` matches the provided value by switching to
@@ -6896,7 +6733,7 @@ export declare const catchCauseIf: {
      * @since 4.0.0
      * @category Error Handling
      */
-    <E, Result extends Filter.ResultOrBool<Cause.Cause<any>>, A2, E2, R2>(filter: Filter.OrPredicate<Cause.Cause<E>, Result>, f: (failure: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Stream<A2, E2, R2>): <A, R>(self: Stream<A, E, R>) => Stream<A | A2, Cause.Cause.Error<Filter.Fail<Cause.Cause<E>, Result>> | E2, R2 | R>;
+    <E, A2, E2, R2>(predicate: Predicate<Cause.Cause<E>>, f: (cause: Cause.Cause<E>) => Stream<A2, E2, R2>): <A, R>(self: Stream<A, E, R>) => Stream<A | A2, E | E2, R2 | R>;
     /**
      * Recovers from stream failures by filtering the `Cause` and switching to a recovery stream.
      * Non-matching causes are re-emitted as failures.
@@ -6930,7 +6767,32 @@ export declare const catchCauseIf: {
      * @since 4.0.0
      * @category Error Handling
      */
-    <A, E, R, A2, E2, R2, Result extends Filter.ResultOrBool<Cause.Cause<any>>>(self: Stream<A, E, R>, filter: Filter.OrPredicate<Cause.Cause<E>, Result>, f: (failure: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Stream<A2, E2, R2>): Stream<A | A2, Cause.Cause.Error<Filter.Fail<Cause.Cause<E>, Result>> | E2, R | R2>;
+    <A, E, R, A2, E2, R2>(self: Stream<A, E, R>, predicate: Predicate<Cause.Cause<E>>, f: (cause: Cause.Cause<E>) => Stream<A2, E2, R2>): Stream<A | A2, E | E2, R | R2>;
+};
+/**
+ * Recovers from stream failures by filtering the `Cause` and switching to a
+ * recovery stream.
+ *
+ * @since 4.0.0
+ * @category Error Handling
+ */
+export declare const catchCauseFilter: {
+    /**
+     * Recovers from stream failures by filtering the `Cause` and switching to a
+     * recovery stream.
+     *
+     * @since 4.0.0
+     * @category Error Handling
+     */
+    <E, EB, A2, E2, R2, X extends Cause.Cause<any>>(filter: Filter.Filter<Cause.Cause<E>, EB, X>, f: (failure: EB, cause: Cause.Cause<E>) => Stream<A2, E2, R2>): <A, R>(self: Stream<A, E, R>) => Stream<A | A2, Cause.Cause.Error<X> | E2, R2 | R>;
+    /**
+     * Recovers from stream failures by filtering the `Cause` and switching to a
+     * recovery stream.
+     *
+     * @since 4.0.0
+     * @category Error Handling
+     */
+    <A, E, R, EB, A2, E2, R2, X extends Cause.Cause<any>>(self: Stream<A, E, R>, filter: Filter.Filter<Cause.Cause<E>, EB, X>, f: (failure: EB, cause: Cause.Cause<E>) => Stream<A2, E2, R2>): Stream<A | A2, Cause.Cause.Error<X> | E2, R | R2>;
 };
 /**
  * Switches to a fallback stream if this stream is empty.
@@ -7811,7 +7673,7 @@ export declare const takeWhile: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, B, X>(f: Filter.Filter<NoInfer<A>, B, X>): <E, R>(self: Stream<A, E, R>) => Stream<B, E, R>;
+    <A, E, R, B extends A>(self: Stream<A, E, R>, refinement: (a: NoInfer<A>, n: number) => a is B): Stream<B, E, R>;
     /**
      * Takes the longest initial prefix of elements that satisfy the predicate.
      *
@@ -7835,52 +7697,26 @@ export declare const takeWhile: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, E, R, B extends A>(self: Stream<A, E, R>, refinement: (a: NoInfer<A>, n: number) => a is B): Stream<B, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, predicate: (a: NoInfer<A>, n: number) => boolean): Stream<A, E, R>;
+};
+/**
+ * Takes the longest initial prefix of elements that satisfy the filter.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export declare const takeWhileFilter: {
     /**
-     * Takes the longest initial prefix of elements that satisfy the predicate.
-     *
-     * @example
-     * ```ts
-     * import { Console, Effect, Stream } from "effect"
+     * Takes the longest initial prefix of elements that satisfy the filter.
      *
-     * const stream = Stream.range(1, 5).pipe(
-     *   Stream.takeWhile((n) => n % 3 !== 0)
-     * )
-     *
-     * const program = Effect.gen(function*() {
-     *   const result = yield* Stream.runCollect(stream)
-     *   yield* Console.log(result)
-     * })
-     *
-     * Effect.runPromise(program)
-     * // Output: [ 1, 2 ]
-     * ```
-     *
-     * @since 2.0.0
+     * @since 4.0.0
      * @category Filtering
      */
-    <A, E, R>(self: Stream<A, E, R>, predicate: (a: NoInfer<A>, n: number) => boolean): Stream<A, E, R>;
+    <A, B, X>(f: Filter.Filter<NoInfer<A>, B, X>): <E, R>(self: Stream<A, E, R>) => Stream<B, E, R>;
     /**
-     * Takes the longest initial prefix of elements that satisfy the predicate.
-     *
-     * @example
-     * ```ts
-     * import { Console, Effect, Stream } from "effect"
-     *
-     * const stream = Stream.range(1, 5).pipe(
-     *   Stream.takeWhile((n) => n % 3 !== 0)
-     * )
-     *
-     * const program = Effect.gen(function*() {
-     *   const result = yield* Stream.runCollect(stream)
-     *   yield* Console.log(result)
-     * })
+     * Takes the longest initial prefix of elements that satisfy the filter.
      *
-     * Effect.runPromise(program)
-     * // Output: [ 1, 2 ]
-     * ```
-     *
-     * @since 2.0.0
+     * @since 4.0.0
      * @category Filtering
      */
     <A, E, R, B, X>(self: Stream<A, E, R>, f: Filter.Filter<NoInfer<A>, B, X>): Stream<B, E, R>;
@@ -8236,53 +8072,29 @@ export declare const dropWhile: {
      * @since 2.0.0
      * @category Filtering
      */
-    <A, B, X>(f: Filter.Filter<NoInfer<A>, B, X>): <E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
+    <A, E, R>(self: Stream<A, E, R>, predicate: (a: NoInfer<A>, index: number) => boolean): Stream<A, E, R>;
+};
+/**
+ * Drops elements while the filter succeeds.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export declare const dropWhileFilter: {
     /**
-     * Drops elements from the stream while the specified predicate evaluates to `true`.
-     *
-     * @example
-     * ```ts
-     * import { Console, Effect, Stream } from "effect"
-     *
-     * const program = Effect.gen(function*() {
-     *   const values = yield* Stream.make(1, 2, 3, 4, 5).pipe(
-     *     Stream.dropWhile((n) => n < 3),
-     *     Stream.runCollect
-     *   )
-     *   yield* Console.log(values)
-     * })
-     *
-     * Effect.runPromise(program)
-     * // Output: [ 3, 4, 5 ]
-     * ```
+     * Drops elements while the filter succeeds.
      *
-     * @since 2.0.0
+     * @since 4.0.0
      * @category Filtering
      */
-    <A, E, R>(self: Stream<A, E, R>, predicate: (a: NoInfer<A>, index: number) => boolean): Stream<A, E, R>;
+    <A, B, X>(filter: Filter.Filter<NoInfer<A>, B, X>): <E, R>(self: Stream<A, E, R>) => Stream<A, E, R>;
     /**
-     * Drops elements from the stream while the specified predicate evaluates to `true`.
-     *
-     * @example
-     * ```ts
-     * import { Console, Effect, Stream } from "effect"
-     *
-     * const program = Effect.gen(function*() {
-     *   const values = yield* Stream.make(1, 2, 3, 4, 5).pipe(
-     *     Stream.dropWhile((n) => n < 3),
-     *     Stream.runCollect
-     *   )
-     *   yield* Console.log(values)
-     * })
+     * Drops elements while the filter succeeds.
      *
-     * Effect.runPromise(program)
-     * // Output: [ 3, 4, 5 ]
-     * ```
-     *
-     * @since 2.0.0
+     * @since 4.0.0
      * @category Filtering
      */
-    <A, E, R, B, X>(self: Stream<A, E, R>, f: Filter.Filter<NoInfer<A>, B, X>): Stream<A, E, R>;
+    <A, E, R, B, X>(self: Stream<A, E, R>, filter: Filter.Filter<NoInfer<A>, B, X>): Stream<A, E, R>;
 };
 /**
  * Drops elements while the specified effectful predicate evaluates to `true`.