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

package/src/Channel.ts

@@ -63,7 +63,7 @@ import * as Chunk from "./Chunk.ts"
 import * as Effect from "./Effect.ts"
 import * as Exit from "./Exit.ts"
 import * as Fiber from "./Fiber.ts"
-import * as Filter from "./Filter.ts"
+import type * as Filter from "./Filter.ts"
 import type { LazyArg } from "./Function.ts"
 import { constant, constTrue, constVoid, dual, identity as identity_ } from "./Function.ts"
 import { ClockRef, endSpan } from "./internal/effect.ts"
@@ -3564,9 +3564,9 @@ export const filter: {
    * @since 2.0.0
    * @category Filtering
    */
-  <OutElem, Result extends Filter.ResultOrBool>(filter: Filter.OrPredicate<OutElem, Result>): <OutErr, OutDone, InElem, InErr, InDone, Env>(
+  <OutElem>(predicate: Predicate.Predicate<OutElem>): <OutErr, OutDone, InElem, InErr, InDone, Env>(
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>
-  ) => Channel<Filter.Pass<OutElem, Result>, OutErr, OutDone, InElem, InErr, InDone, Env>
+  ) => Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>
   /**
    * Filters the output elements of a channel using a predicate function.
    * Elements that don't match the predicate are discarded.
@@ -3625,24 +3625,59 @@ export const filter: {
    * @since 2.0.0
    * @category Filtering
    */
-  <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, Result extends Filter.ResultOrBool>(
+  <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
+    self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
+    predicate: Predicate.Predicate<OutElem>
+  ): Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>
+} = dual(2, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
+  self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
+  predicate: Predicate.Predicate<OutElem>
+): Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env> =>
+  fromTransform((upstream, scope) =>
+    Effect.map(
+      toTransform(self)(upstream, scope),
+      (pull) =>
+        Effect.flatMap(pull, function loop(elem): Pull.Pull<OutElem, OutErr, OutDone> {
+          return predicate(elem)
+            ? Effect.succeed(elem)
+            : Effect.flatMap(pull, loop)
+        })
+    )
+  ))
+
+/**
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const filterMap: {
+  /**
+   * @since 4.0.0
+   * @category Filtering
+   */
+  <OutElem, B, X>(filter: Filter.Filter<OutElem, B, X>): <OutErr, OutDone, InElem, InErr, InDone, Env>(
+    self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>
+  ) => Channel<B, OutErr, OutDone, InElem, InErr, InDone, Env>
+  /**
+   * @since 4.0.0
+   * @category Filtering
+   */
+  <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, B, X>(
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-    filter: Filter.OrPredicate<OutElem, Result>
-  ): Channel<Filter.Pass<OutElem, Result>, OutErr, OutDone, InElem, InErr, InDone, Env>
-} = dual(2, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, Result extends Filter.ResultOrBool>(
+    filter: Filter.Filter<OutElem, B, X>
+  ): Channel<B, OutErr, OutDone, InElem, InErr, InDone, Env>
+} = dual(2, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, B, X>(
   self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-  filter: Filter.OrPredicate<OutElem, Result>
-): Channel<Filter.Pass<OutElem, Result>, OutErr, OutDone, InElem, InErr, InDone, Env> =>
+  filter: Filter.Filter<OutElem, B, X>
+): Channel<B, OutErr, OutDone, InElem, InErr, InDone, Env> =>
   fromTransform((upstream, scope) =>
     Effect.map(
       toTransform(self)(upstream, scope),
       (pull) =>
-        Effect.flatMap(pull, function loop(elem): Pull.Pull<Filter.Pass<OutElem, Result>, OutErr, OutDone> {
+        Effect.flatMap(pull, function loop(elem): Pull.Pull<B, OutErr, OutDone> {
           const result = filter(elem)
-          if (result === true) return Effect.succeed(elem as Filter.Pass<OutElem, Result>)
-          else if (result === false) return Effect.flatMap(pull, loop)
-          else if (Result.isSuccess(result)) return Effect.succeed(result.success)
-          return Effect.flatMap(pull, loop)
+          return Result.isFailure(result)
+            ? Effect.flatMap(pull, loop)
+            : Effect.succeed(result.success)
         })
     )
   ))
@@ -3652,6 +3687,46 @@ export const filter: {
  * @category Filtering
  */
 export const filterEffect: {
+  /**
+   * @since 4.0.0
+   * @category Filtering
+   */
+  <OutElem, E, R>(predicate: (a: OutElem) => Effect.Effect<boolean, E, R>): <OutErr, OutDone, InElem, InErr, InDone, Env>(
+    self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>
+  ) => Channel<OutElem, OutErr | E, OutDone, InElem, InErr, InDone, Env | R>
+  /**
+   * @since 4.0.0
+   * @category Filtering
+   */
+  <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, E, R>(
+    self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
+    predicate: (a: OutElem) => Effect.Effect<boolean, E, R>
+  ): Channel<OutElem, OutErr | E, OutDone, InElem, InErr, InDone, Env | R>
+} = dual(2, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, E, R>(
+  self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
+  predicate: (a: OutElem) => Effect.Effect<boolean, E, R>
+): Channel<OutElem, OutErr | E, OutDone, InElem, InErr, InDone, Env | R> =>
+  fromTransform((upstream, scope) =>
+    Effect.map(
+      toTransform(self)(upstream, scope),
+      (pull) =>
+        Effect.flatMap(pull, function loop(elem): Pull.Pull<OutElem, OutErr | E, OutDone, R> {
+          return Effect.flatMap(
+            predicate(elem),
+            (passes) =>
+              passes
+                ? Effect.succeed(elem)
+                : Effect.flatMap(pull, loop)
+          )
+        })
+    )
+  ))
+
+/**
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const filterMapEffect: {
   /**
    * @since 4.0.0
    * @category Filtering
@@ -3796,9 +3871,9 @@ export const filterArray: {
    * @since 4.0.0
    * @category Filtering
    */
-  <OutElem, Result extends Filter.ResultOrBool>(filter: Filter.OrPredicate<Types.NoInfer<OutElem>, Result>): <OutErr, OutDone, InElem, InErr, InDone, Env>(
+  <OutElem>(predicate: Predicate.Predicate<Types.NoInfer<OutElem>>): <OutErr, OutDone, InElem, InErr, InDone, Env>(
     self: Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>
-  ) => Channel<Arr.NonEmptyReadonlyArray<Filter.Pass<OutElem, Result>>, OutErr, OutDone, InElem, InErr, InDone, Env>
+  ) => Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>
   /**
    * Filters arrays of elements emitted by a channel, applying the filter
    * to each element within the arrays and only emitting non-empty filtered arrays.
@@ -3873,19 +3948,24 @@ export const filterArray: {
    * @since 4.0.0
    * @category Filtering
    */
-  <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, Result extends Filter.ResultOrBool>(
+  <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
     self: Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>,
-    filter: Filter.OrPredicate<Types.NoInfer<OutElem>, Result>
-  ): Channel<Arr.NonEmptyReadonlyArray<Filter.Pass<OutElem, Result>>, OutErr, OutDone, InElem, InErr, InDone, Env>
-} = dual(2, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, Result extends Filter.ResultOrBool>(
+    predicate: Predicate.Predicate<Types.NoInfer<OutElem>>
+  ): Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>
+} = dual(2, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
   self: Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>,
-  filter: Filter.OrPredicate<Types.NoInfer<OutElem>, Result>
-): Channel<Arr.NonEmptyReadonlyArray<Filter.Pass<OutElem, Result>>, OutErr, OutDone, InElem, InErr, InDone, Env> =>
+  predicate: Predicate.Predicate<Types.NoInfer<OutElem>>
+): Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env> =>
   transformPull(self, (pull) =>
     Effect.succeed(Effect.flatMap(
       pull,
-      function loop(arr): Pull.Pull<Arr.NonEmptyReadonlyArray<any>, OutErr, OutDone> {
-        const [, passes] = Arr.partition(arr, filter as any)
+      function loop(arr): Pull.Pull<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone> {
+        const passes: Array<OutElem> = []
+        for (let i = 0; i < arr.length; i++) {
+          if (predicate(arr[i] as Types.NoInfer<OutElem>)) {
+            passes.push(arr[i])
+          }
+        }
         return Arr.isReadonlyArrayNonEmpty(passes)
           ? Effect.succeed(passes)
           : Effect.flatMap(pull, loop)
@@ -3896,23 +3976,57 @@ export const filterArray: {
  * @since 4.0.0
  * @category Filtering
  */
-export const filterArrayEffect: {
+export const filterMapArray: {
   /**
    * @since 4.0.0
    * @category Filtering
    */
-  <OutElem, E, R>(
-    predicate: (a: Types.NoInfer<OutElem>, index: number) => Effect.Effect<boolean, E, R>
-  ): <OutErr, OutDone, InElem, InErr, InDone, Env>(
+  <OutElem, B, X>(filter: Filter.Filter<Types.NoInfer<OutElem>, B, X>): <OutErr, OutDone, InElem, InErr, InDone, Env>(
     self: Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>
-  ) => Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr | E, OutDone, InElem, InErr, InDone, Env | R>
+  ) => Channel<Arr.NonEmptyReadonlyArray<B>, OutErr, OutDone, InElem, InErr, InDone, Env>
   /**
    * @since 4.0.0
    * @category Filtering
    */
-  <OutElem, B, X, EX, RX>(filter: Filter.FilterEffect<OutElem, B, X, EX, RX>): <OutErr, OutDone, InElem, InErr, InDone, Env>(
+  <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, B, X>(
+    self: Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>,
+    filter: Filter.Filter<OutElem, B, X>
+  ): Channel<Arr.NonEmptyReadonlyArray<B>, OutErr, OutDone, InElem, InErr, InDone, Env>
+} = dual(2, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, B, X>(
+  self: Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>,
+  filter: Filter.Filter<OutElem, B, X>
+): Channel<Arr.NonEmptyReadonlyArray<B>, OutErr, OutDone, InElem, InErr, InDone, Env> =>
+  transformPull(self, (pull) =>
+    Effect.succeed(Effect.flatMap(
+      pull,
+      function loop(arr): Pull.Pull<Arr.NonEmptyReadonlyArray<B>, OutErr, OutDone> {
+        const passes: Array<B> = []
+        for (let i = 0; i < arr.length; i++) {
+          const result = filter(arr[i])
+          if (Result.isSuccess(result)) {
+            passes.push(result.success)
+          }
+        }
+        return Arr.isReadonlyArrayNonEmpty(passes)
+          ? Effect.succeed(passes)
+          : Effect.flatMap(pull, loop)
+      }
+    ))))
+
+/**
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const filterArrayEffect: {
+  /**
+   * @since 4.0.0
+   * @category Filtering
+   */
+  <OutElem, E, R>(
+    predicate: (a: Types.NoInfer<OutElem>, index: number) => Effect.Effect<boolean, E, R>
+  ): <OutErr, OutDone, InElem, InErr, InDone, Env>(
     self: Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>
-  ) => Channel<Arr.NonEmptyReadonlyArray<B>, OutErr | EX, OutDone, InElem, InErr, InDone, Env | RX>
+  ) => Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr | E, OutDone, InElem, InErr, InDone, Env | R>
   /**
    * @since 4.0.0
    * @category Filtering
@@ -3921,6 +4035,32 @@ export const filterArrayEffect: {
     self: Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>,
     predicate: (a: Types.NoInfer<OutElem>, index: number) => Effect.Effect<boolean, E, R>
   ): Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr | E, OutDone, InElem, InErr, InDone, Env | R>
+} = dual(2, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, E, R>(
+  self: Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>,
+  predicate: (a: Types.NoInfer<OutElem>, index: number) => Effect.Effect<boolean, E, R>
+): Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr | E, OutDone, InElem, InErr, InDone, Env | R> =>
+  transformPull(self, (pull) => {
+    const f = Effect.flatMap(pull, (arr) => Effect.filter(arr, predicate))
+    return Effect.succeed(Effect.flatMap(
+      f,
+      function loop(arr): Pull.Pull<Arr.NonEmptyReadonlyArray<OutElem>, OutErr | E, OutDone, R> {
+        return Arr.isReadonlyArrayNonEmpty(arr) ? Effect.succeed(arr) : Effect.flatMap(f, loop)
+      }
+    ))
+  }))
+
+/**
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const filterMapArrayEffect: {
+  /**
+   * @since 4.0.0
+   * @category Filtering
+   */
+  <OutElem, B, X, EX, RX>(filter: Filter.FilterEffect<Types.NoInfer<OutElem>, B, X, EX, RX>): <OutErr, OutDone, InElem, InErr, InDone, Env>(
+    self: Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>
+  ) => Channel<Arr.NonEmptyReadonlyArray<B>, OutErr | EX, OutDone, InElem, InErr, InDone, Env | RX>
   /**
    * @since 4.0.0
    * @category Filtering
@@ -3929,32 +4069,23 @@ export const filterArrayEffect: {
     self: Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>,
     filter: Filter.FilterEffect<OutElem, B, X, EX, RX>
   ): Channel<Arr.NonEmptyReadonlyArray<B>, OutErr | EX, OutDone, InElem, InErr, InDone, Env | RX>
-} = dual(2, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
+} = dual(2, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, B, X, EX, RX>(
   self: Channel<Arr.NonEmptyReadonlyArray<OutElem>, OutErr, OutDone, InElem, InErr, InDone, Env>,
-  filter:
-    | Filter.FilterEffect<OutElem, any, any, any, any>
-    | ((a: OutElem, index: number) => Effect.Effect<boolean, any, any>)
-): Channel<Arr.NonEmptyReadonlyArray<any>, any, OutDone, InElem, InErr, InDone, any> => {
-  if (filter.length > 1) {
-    // effectful boolean predicate: (a, index) => Effect<boolean>
-    const predicate = filter as (a: OutElem, index: number) => Effect.Effect<boolean, any, any>
-    return transformPull(self, (pull) => {
-      const f = Effect.flatMap(pull, (arr) => Effect.filter(arr, predicate))
-      return Effect.succeed(Effect.flatMap(
-        f,
-        function loop(arr): Pull.Pull<Arr.NonEmptyReadonlyArray<any>, any, OutDone, any> {
-          return Arr.isReadonlyArrayNonEmpty(arr) ? Effect.succeed(arr) : Effect.flatMap(f, loop)
-        }
-      ))
-    })
-  }
-  // FilterEffect: (a) => Effect<pass|fail>
-  return filterEffect(self, (arr) =>
-    Effect.map(
-      Effect.filter(arr, filter as any),
-      (passes) => Arr.isReadonlyArrayNonEmpty(passes) ? Result.succeed(passes) : Result.fail(undefined)
-    ))
-})
+  filter: Filter.FilterEffect<OutElem, B, X, EX, RX>
+): Channel<Arr.NonEmptyReadonlyArray<B>, OutErr | EX, OutDone, InElem, InErr, InDone, Env | RX> =>
+  transformPull(self, (pull) =>
+    Effect.succeed(Effect.flatMap(
+      pull,
+      function loop(arr): Pull.Pull<Arr.NonEmptyReadonlyArray<B>, OutErr | EX, OutDone, RX> {
+        return Effect.flatMap(
+          Effect.filterMapEffect(arr, filter as any),
+          (passes) =>
+            Arr.isReadonlyArrayNonEmpty(passes)
+              ? Effect.succeed(passes as Arr.NonEmptyReadonlyArray<B>)
+              : Effect.flatMap(pull, loop)
+        )
+      }
+    ))))
 
 /**
  * Statefully maps over a channel with an accumulator, where each element can produce multiple output values.
@@ -4757,7 +4888,6 @@ export const catchCauseIf: {
    */
   <
     OutErr,
-    Result extends Filter.ResultOrBool<Cause.Cause<any>>,
     OutElem1,
     OutErr1,
     OutDone1,
@@ -4766,11 +4896,8 @@ export const catchCauseIf: {
     InDone1,
     Env1
   >(
-    filter: Filter.OrPredicate<Cause.Cause<OutErr>, Result>,
-    f: (
-      failure: Filter.Pass<Cause.Cause<OutErr>, Result>,
-      cause: Cause.Cause<OutErr>
-    ) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>
+    predicate: Predicate.Predicate<Cause.Cause<OutErr>>,
+    f: (cause: Cause.Cause<OutErr>) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>
   ): <
     OutElem,
     OutDone,
@@ -4780,7 +4907,7 @@ export const catchCauseIf: {
     Env
   >(self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>) => Channel<
     OutElem | OutElem1,
-    Cause.Cause.Error<Filter.Fail<Cause.Cause<OutErr>, Result>> | OutErr1,
+    OutErr | OutErr1,
     OutDone | OutDone1,
     InElem & InElem1,
     InErr & InErr1,
@@ -4802,7 +4929,6 @@ export const catchCauseIf: {
     InErr,
     InDone,
     Env,
-    Result extends Filter.ResultOrBool<Cause.Cause<any>>,
     OutElem1,
     OutErr1,
     OutDone1,
@@ -4812,14 +4938,137 @@ export const catchCauseIf: {
     Env1
   >(
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-    filter: Filter.OrPredicate<Cause.Cause<OutErr>, Result>,
+    predicate: Predicate.Predicate<Cause.Cause<OutErr>>,
+    f: (cause: Cause.Cause<OutErr>) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>
+  ): Channel<
+    OutElem | OutElem1,
+    OutErr | OutErr1,
+    OutDone | OutDone1,
+    InElem & InElem1,
+    InErr & InErr1,
+    InDone & InDone1,
+    Env | Env1
+  >
+} = dual(3, <
+  OutElem,
+  OutErr,
+  OutDone,
+  InElem,
+  InErr,
+  InDone,
+  Env,
+  OutElem1,
+  OutErr1,
+  OutDone1,
+  InElem1,
+  InErr1,
+  InDone1,
+  Env1
+>(
+  self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
+  predicate: Predicate.Predicate<Cause.Cause<OutErr>>,
+  f: (cause: Cause.Cause<OutErr>) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>
+): Channel<
+  OutElem | OutElem1,
+  OutErr | OutErr1,
+  OutDone | OutDone1,
+  InElem & InElem1,
+  InErr & InErr1,
+  InDone & InDone1,
+  Env | Env1
+> =>
+  catchCause(
+    self,
+    (
+      cause
+    ): Channel<
+      OutElem1,
+      OutErr | OutErr1,
+      OutDone1,
+      InElem1,
+      InErr1,
+      InDone1,
+      Env1
+    > => {
+      return predicate(cause)
+        ? f(cause)
+        : failCause(cause as any)
+    }
+  ))
+
+/**
+ * @since 4.0.0
+ * @category Error handling
+ */
+export const catchCauseFilter: {
+  /**
+   * @since 4.0.0
+   * @category Error handling
+   */
+  <
+    OutErr,
+    EB,
+    X extends Cause.Cause<any>,
+    OutElem1,
+    OutErr1,
+    OutDone1,
+    InElem1,
+    InErr1,
+    InDone1,
+    Env1
+  >(
+    filter: Filter.Filter<Cause.Cause<OutErr>, EB, X>,
+    f: (
+      failure: EB,
+      cause: Cause.Cause<OutErr>
+    ) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>
+  ): <
+    OutElem,
+    OutDone,
+    InElem,
+    InErr,
+    InDone,
+    Env
+  >(self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>) => Channel<
+    OutElem | OutElem1,
+    Cause.Cause.Error<X> | OutErr1,
+    OutDone | OutDone1,
+    InElem & InElem1,
+    InErr & InErr1,
+    InDone & InDone1,
+    Env | Env1
+  >
+  /**
+   * @since 4.0.0
+   * @category Error handling
+   */
+  <
+    OutElem,
+    OutErr,
+    OutDone,
+    InElem,
+    InErr,
+    InDone,
+    Env,
+    EB,
+    X extends Cause.Cause<any>,
+    OutElem1,
+    OutErr1,
+    OutDone1,
+    InElem1,
+    InErr1,
+    InDone1,
+    Env1
+  >(
+    self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
+    filter: Filter.Filter<Cause.Cause<OutErr>, EB, X>,
     f: (
-      failure: Filter.Pass<Cause.Cause<OutErr>, Result>,
+      failure: EB,
       cause: Cause.Cause<OutErr>
     ) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>
   ): Channel<
     OutElem | OutElem1,
-    Cause.Cause.Error<Filter.Fail<Cause.Cause<OutErr>, Result>> | OutErr1,
+    Cause.Cause.Error<X> | OutErr1,
     OutDone | OutDone1,
     InElem & InElem1,
     InErr & InErr1,
@@ -4834,7 +5083,8 @@ export const catchCauseIf: {
   InErr,
   InDone,
   Env,
-  Result extends Filter.ResultOrBool<Cause.Cause<any>>,
+  EB,
+  X extends Cause.Cause<any>,
   OutElem1,
   OutErr1,
   OutDone1,
@@ -4844,14 +5094,14 @@ export const catchCauseIf: {
   Env1
 >(
   self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-  filter: Filter.OrPredicate<Cause.Cause<OutErr>, Result>,
+  filter: Filter.Filter<Cause.Cause<OutErr>, EB, X>,
   f: (
-    failure: Filter.Pass<Cause.Cause<OutErr>, Result>,
+    failure: EB,
     cause: Cause.Cause<OutErr>
   ) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>
 ): Channel<
   OutElem | OutElem1,
-  Cause.Cause.Error<Filter.Fail<Cause.Cause<OutErr>, Result>> | OutErr1,
+  Cause.Cause.Error<X> | OutErr1,
   OutDone | OutDone1,
   InElem & InElem1,
   InErr & InErr1,
@@ -4864,18 +5114,17 @@ export const catchCauseIf: {
       cause
     ): Channel<
       OutElem1,
-      Cause.Cause.Error<Filter.Fail<Cause.Cause<OutErr>, Result>> | OutErr1,
+      Cause.Cause.Error<X> | OutErr1,
       OutDone1,
       InElem1,
       InErr1,
       InDone1,
       Env1
     > => {
-      const eb = filter(cause)
-      if (eb === true) return f(cause as any, cause)
-      else if (eb === false) return failCause(cause as any)
-      else if (Result.isSuccess(eb)) return f(eb.success as any, cause)
-      return failCause(eb.failure)
+      const result = filter(cause)
+      return Result.isFailure(result)
+        ? failCause(result.failure)
+        : f(result.success, cause)
     }
   ))
 
@@ -4951,7 +5200,7 @@ const catch_: {
   InErr & InErr1,
   InDone & InDone1,
   Env | Env1
-> => catchCauseIf(self, Cause.findError as any, (e: any) => f(e)) as any)
+> => catchCauseFilter(self, Cause.findError, (e) => f(e)))
 
 export {
   /**
@@ -5101,7 +5350,6 @@ export const catchIf: {
    */
   <
     OutErr,
-    Result extends Filter.ResultOrBool,
     OutElem1,
     OutErr1,
     OutDone1,
@@ -5110,18 +5358,18 @@ export const catchIf: {
     InDone1,
     Env1,
     OutElem2 = never,
-    OutErr2 = Filter.Fail<OutErr, Result>,
+    OutErr2 = OutErr,
     OutDone2 = never,
     InElem2 = unknown,
     InErr2 = unknown,
     InDone2 = unknown,
     Env2 = never
   >(
-    filter: Filter.OrPredicate<OutErr, Result>,
-    f: (failure: Filter.Pass<OutErr, Result>) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
+    predicate: Predicate.Predicate<OutErr>,
+    f: (failure: OutErr) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
     orElse?:
       | ((
-        failure: Filter.Fail<OutErr, Result>
+        failure: OutErr
       ) => Channel<OutElem2, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>)
       | undefined
   ): <
@@ -5197,7 +5445,6 @@ export const catchIf: {
     InErr,
     InDone,
     Env,
-    Result extends Filter.ResultOrBool,
     OutElem1,
     OutErr1,
     OutDone1,
@@ -5206,7 +5453,7 @@ export const catchIf: {
     InDone1,
     Env1,
     OutElem2 = never,
-    OutErr2 = Filter.Fail<OutErr, Result>,
+    OutErr2 = OutErr,
     OutDone2 = never,
     InElem2 = unknown,
     InErr2 = unknown,
@@ -5214,11 +5461,11 @@ export const catchIf: {
     Env2 = never
   >(
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-    filter: Filter.OrPredicate<OutErr, Result>,
-    f: (failure: Filter.Pass<OutErr, Result>) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
+    predicate: Predicate.Predicate<OutErr>,
+    f: (failure: OutErr) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
     orElse?:
       | ((
-        failure: Filter.Fail<OutErr, Result>
+        failure: OutErr
       ) => Channel<OutElem2, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>)
       | undefined
   ): Channel<
@@ -5238,7 +5485,6 @@ export const catchIf: {
   InErr,
   InDone,
   Env,
-  Result extends Filter.ResultOrBool,
   OutElem1,
   OutErr1,
   OutDone1,
@@ -5247,7 +5493,7 @@ export const catchIf: {
   InDone1,
   Env1,
   OutElem2 = never,
-  OutErr2 = Filter.Fail<OutErr, Result>,
+  OutErr2 = OutErr,
   OutDone2 = never,
   InElem2 = unknown,
   InErr2 = unknown,
@@ -5255,11 +5501,11 @@ export const catchIf: {
   Env2 = never
 >(
   self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-  filter: Filter.OrPredicate<OutErr, Result>,
-  f: (failure: Filter.Pass<OutErr, Result>) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
+  predicate: Predicate.Predicate<OutErr>,
+  f: (failure: OutErr) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
   orElse?:
     | ((
-      failure: Filter.Fail<OutErr, Result>
+      failure: OutErr
     ) => Channel<OutElem2, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>)
     | undefined
 ): Channel<
@@ -5282,12 +5528,170 @@ export const catchIf: {
       InDone1 & InDone2,
       Env1 | Env2
     > => {
-      const eb = Filter.apply(filter as any, err)
-      return !Result.isFailure(eb)
-        ? f(eb.success as any)
+      return predicate(err)
+        ? f(err)
         : orElse
-        ? orElse(eb.failure as any)
-        : fail(eb.failure as any) as any
+        ? orElse(err)
+        : fail(err as any) as any
+    }
+  ))
+
+/**
+ * @since 4.0.0
+ * @category Error handling
+ */
+export const catchFilter: {
+  /**
+   * @since 4.0.0
+   * @category Error handling
+   */
+  <
+    OutErr,
+    EB,
+    X,
+    OutElem1,
+    OutErr1,
+    OutDone1,
+    InElem1,
+    InErr1,
+    InDone1,
+    Env1,
+    OutElem2 = never,
+    OutErr2 = X,
+    OutDone2 = never,
+    InElem2 = unknown,
+    InErr2 = unknown,
+    InDone2 = unknown,
+    Env2 = never
+  >(
+    filter: Filter.Filter<OutErr, EB, X>,
+    f: (failure: EB) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
+    orElse?:
+      | ((
+        failure: X
+      ) => Channel<OutElem2, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>)
+      | undefined
+  ): <
+    OutElem,
+    OutDone,
+    InElem,
+    InErr,
+    InDone,
+    Env
+  >(self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>) => Channel<
+    OutElem | OutElem1 | OutElem2,
+    OutErr1 | OutErr2,
+    OutDone | OutDone1 | OutDone2,
+    InElem & InElem1 & InElem2,
+    InErr & InErr1 & InErr2,
+    InDone & InDone1 & InDone2,
+    Env | Env1 | Env2
+  >
+  /**
+   * @since 4.0.0
+   * @category Error handling
+   */
+  <
+    OutElem,
+    OutErr,
+    OutDone,
+    InElem,
+    InErr,
+    InDone,
+    Env,
+    EB,
+    X,
+    OutElem1,
+    OutErr1,
+    OutDone1,
+    InElem1,
+    InErr1,
+    InDone1,
+    Env1,
+    OutElem2 = never,
+    OutErr2 = X,
+    OutDone2 = never,
+    InElem2 = unknown,
+    InErr2 = unknown,
+    InDone2 = unknown,
+    Env2 = never
+  >(
+    self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
+    filter: Filter.Filter<OutErr, EB, X>,
+    f: (failure: EB) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
+    orElse?:
+      | ((
+        failure: X
+      ) => Channel<OutElem2, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>)
+      | undefined
+  ): Channel<
+    OutElem | OutElem1 | OutElem2,
+    OutErr1 | OutErr2,
+    OutDone | OutDone1 | OutDone2,
+    InElem & InElem1 & InElem2,
+    InErr & InErr1 & InErr2,
+    InDone & InDone1 & InDone2,
+    Env | Env1 | Env2
+  >
+} = dual((args) => isChannel(args[0]), <
+  OutElem,
+  OutErr,
+  OutDone,
+  InElem,
+  InErr,
+  InDone,
+  Env,
+  EB,
+  X,
+  OutElem1,
+  OutErr1,
+  OutDone1,
+  InElem1,
+  InErr1,
+  InDone1,
+  Env1,
+  OutElem2 = never,
+  OutErr2 = X,
+  OutDone2 = never,
+  InElem2 = unknown,
+  InErr2 = unknown,
+  InDone2 = unknown,
+  Env2 = never
+>(
+  self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
+  filter: Filter.Filter<OutErr, EB, X>,
+  f: (failure: EB) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
+  orElse?:
+    | ((
+      failure: X
+    ) => Channel<OutElem2, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>)
+    | undefined
+): Channel<
+  OutElem | OutElem1 | OutElem2,
+  OutErr1 | OutErr2,
+  OutDone | OutDone1 | OutDone2,
+  InElem & InElem1 & InElem2,
+  InErr & InErr1 & InErr2,
+  InDone & InDone1 & InDone2,
+  Env | Env1 | Env2
+> =>
+  catch_(
+    self,
+    (err): Channel<
+      OutElem1 | OutElem2,
+      OutErr1 | OutErr2,
+      OutDone1 | OutDone2,
+      InElem1 & InElem2,
+      InErr1 & InErr2,
+      InDone1 & InDone2,
+      Env1 | Env2
+    > => {
+      const result = filter(err)
+      return Result.isFailure(result)
+        ? orElse
+          ? orElse(result.failure)
+          : fail(result.failure as any) as any
+        : f(result.success)
     }
   ))
 
@@ -5872,7 +6276,7 @@ export const catchReasons: {
   >
 } = dual((args) => isChannel(args[0]), (self, errorTag, cases, orElse) => {
   let keys: Set<string>
-  return catch_(self, (error: any) => {
+  return catch_(self, (error) => {
     if (
       isTagged(error, errorTag) &&
       hasProperty(error, "reason") &&
@@ -6034,11 +6438,11 @@ export const unwrapReason: {
   InDone,
   Env
 > =>
-  catchIf(
+  catchFilter(
     self,
-    (error: any) =>
+    (error) =>
       isTagged(error, errorTag) && hasProperty(error, "reason") ? Result.succeed(error.reason) : Result.fail(error),
-    fail as any
+    fail
   ) as any)
 
 /**