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

package/src/internal/effect.ts

@@ -2224,19 +2224,12 @@ export const filterOrFail: {
     predicate: Predicate.Predicate<NoInfer<A>>,
     orFailWith: (a: NoInfer<A>) => E2
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E2 | E, R>
-  <A, B, X, E2>(
-    filter: Filter.Filter<NoInfer<A>, B, X>,
-    orFailWith: (x: X) => E2
-  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E2 | E, R>
   <A, B extends A>(
     refinement: Predicate.Refinement<NoInfer<A>, B>
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, Cause.NoSuchElementError | E, R>
   <A>(
     predicate: Predicate.Predicate<NoInfer<A>>
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, Cause.NoSuchElementError | E, R>
-  <A, B, X>(
-    filter: Filter.Filter<NoInfer<A>, B, X>
-  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, Cause.NoSuchElementError | E, R>
   <A, E, R, E2, B extends A>(
     self: Effect.Effect<A, E, R>,
     refinement: Predicate.Refinement<NoInfer<A>, B>,
@@ -2247,11 +2240,6 @@ export const filterOrFail: {
     predicate: Predicate.Predicate<NoInfer<A>>,
     orFailWith: (a: NoInfer<A>) => E2
   ): Effect.Effect<A, E2 | E, R>
-  <A, E, R, B, X, E2>(
-    self: Effect.Effect<A, E, R>,
-    filter: Filter.Filter<A, B, X>,
-    orFailWith: (x: X) => E2
-  ): Effect.Effect<B, E2 | E, R>
   <A, E, R, B extends A>(
     self: Effect.Effect<A, E, R>,
     refinement: Predicate.Refinement<NoInfer<A>, B>
@@ -2260,18 +2248,14 @@ export const filterOrFail: {
     self: Effect.Effect<A, E, R>,
     predicate: Predicate.Predicate<NoInfer<A>>
   ): Effect.Effect<A, E | Cause.NoSuchElementError, R>
-  <A, E, R, B, X>(
-    self: Effect.Effect<A, E, R>,
-    filter: Filter.Filter<A, B, X>
-  ): Effect.Effect<B, E | Cause.NoSuchElementError, R>
 } = dual((args) => isEffect(args[0]), <A, E, R, E2>(
   self: Effect.Effect<A, E, R>,
-  filter: Predicate.Predicate<NoInfer<A>> | Filter.Filter<A, any, any>,
+  predicate: Predicate.Predicate<NoInfer<A>>,
   orFailWith?: (a: any) => E2
 ): Effect.Effect<any, E | E2 | Cause.NoSuchElementError, R> =>
   filterOrElse(
     self,
-    filter as any,
+    predicate as any,
     orFailWith ? (a: any) => fail(orFailWith(a)) : () => fail(new NoSuchElementError() as E2)
   ))
 
@@ -2421,27 +2405,55 @@ const OnFailureProto = makePrimitiveProto({
 
 /** @internal */
 export const catchCauseIf: {
-  <E, Result extends Filter.ResultOrBool<Cause.Cause<any>>, B, E2, R2>(
-    filter: Filter.OrPredicate<Cause.Cause<E>, Result>,
-    f: (failure: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
+  <E, B, E2, R2>(
+    predicate: Predicate.Predicate<Cause.Cause<E>>,
+    f: (cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
+  ): <A, R>(
+    self: Effect.Effect<A, E, R>
+  ) => Effect.Effect<A | B, E | E2, R | R2>
+  <A, E, R, B, E2, R2>(
+    self: Effect.Effect<A, E, R>,
+    predicate: Predicate.Predicate<Cause.Cause<E>>,
+    f: (cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
+  ): Effect.Effect<A | B, E | E2, R | R2>
+} = dual(
+  3,
+  <A, E, R, B, E2, R2>(
+    self: Effect.Effect<A, E, R>,
+    predicate: Predicate.Predicate<Cause.Cause<E>>,
+    f: (cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
+  ): Effect.Effect<A | B, E | E2, R | R2> =>
+    catchCause(self, (cause): Effect.Effect<B, E | E2, R2> => {
+      if (!predicate(cause)) {
+        return failCause(cause) as any
+      }
+      return internalCall(() => f(cause))
+    })
+)
+
+/** @internal */
+export const catchCauseFilter: {
+  <E, B, E2, R2, EB, X extends Cause.Cause<any>>(
+    filter: Filter.Filter<Cause.Cause<E>, EB, X>,
+    f: (failure: EB, cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
   ): <A, R>(
     self: Effect.Effect<A, E, R>
-  ) => Effect.Effect<A | B, Cause.Cause.Error<Filter.Fail<Cause.Cause<E>, Result>> | E2, R | R2>
-  <A, E, R, B, E2, R2, Result extends Filter.ResultOrBool<Cause.Cause<any>>>(
+  ) => Effect.Effect<A | B, Cause.Cause.Error<X> | E2, R | R2>
+  <A, E, R, B, E2, R2, EB, X extends Cause.Cause<any>>(
     self: Effect.Effect<A, E, R>,
-    filter: Filter.OrPredicate<Cause.Cause<E>, Result>,
-    f: (failure: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
-  ): Effect.Effect<A | B, Cause.Cause.Error<Filter.Fail<Cause.Cause<E>, Result>> | E2, R | R2>
+    filter: Filter.Filter<Cause.Cause<E>, EB, X>,
+    f: (failure: EB, cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
+  ): Effect.Effect<A | B, Cause.Cause.Error<X> | E2, R | R2>
 } = dual(
   3,
-  <A, E, R, B, E2, R2, Result extends Filter.ResultOrBool<Cause.Cause<any>>>(
-    self: Effect.Effect<A, E, R>,
-    filter: Filter.OrPredicate<Cause.Cause<E>, Result>,
-    f: (failure: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
-  ): Effect.Effect<A | B, Cause.Cause.Error<Filter.Fail<Cause.Cause<E>, Result>> | E2, R | R2> =>
-    catchCause(self, (cause): Effect.Effect<B, Cause.Cause.Error<Filter.Fail<Cause.Cause<E>, Result>> | E2, R | R2> => {
-      const eb = Filter.apply(filter as any, cause)
-      return !Result.isFailure(eb) ? internalCall(() => f(eb.success as any, cause)) : failCause(eb.failure as any)
+  <A, E, R, B, E2, R2, EB, X extends Cause.Cause<any>>(
+    self: Effect.Effect<A, E, R>,
+    filter: Filter.Filter<Cause.Cause<E>, EB, X>,
+    f: (failure: EB, cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
+  ): Effect.Effect<A | B, Cause.Cause.Error<X> | E2, R | R2> =>
+    catchCause(self, (cause): Effect.Effect<B, Cause.Cause.Error<X> | E2, R2> => {
+      const eb = filter(cause)
+      return Result.isFailure(eb) ? failCause(eb.failure) : internalCall(() => f(eb.success, cause))
     })
 )
 
@@ -2459,7 +2471,7 @@ export const catch_: {
   <A, E, R, B, E2, R2>(
     self: Effect.Effect<A, E, R>,
     f: (a: NoInfer<E>) => Effect.Effect<B, E2, R2>
-  ): Effect.Effect<A | B, E2, R | R2> => catchCauseIf(self, findError as any, (e: any) => f(e)) as any
+  ): Effect.Effect<A | B, E2, R | R2> => catchCauseFilter(self, findError as any, (e: any) => f(e)) as any
 )
 
 /** @internal */
@@ -2490,7 +2502,7 @@ export const catchDefect: {
   <A, E, R, B, E2, R2>(
     self: Effect.Effect<A, E, R>,
     f: (defect: unknown) => Effect.Effect<B, E2, R2>
-  ): Effect.Effect<A | B, E | E2, R | R2> => catchCauseIf(self, findDefect as any, f as any) as any
+  ): Effect.Effect<A | B, E | E2, R | R2> => catchCauseFilter(self, findDefect as any, f as any) as any
 )
 
 /** @internal */
@@ -2513,32 +2525,56 @@ export const tapCause: {
 
 /** @internal */
 export const tapCauseIf: {
-  <E, Result extends Filter.ResultOrBool, B, E2, R2>(
-    filter: Filter.OrPredicate<Cause.Cause<E>, Result>,
-    f: (a: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
+  <E, B, E2, R2>(
+    predicate: Predicate.Predicate<Cause.Cause<E>>,
+    f: (cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
   ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, R | R2>
-  <A, E, R, Result extends Filter.ResultOrBool, B, E2, R2>(
+  <A, E, R, B, E2, R2>(
     self: Effect.Effect<A, E, R>,
-    filter: Filter.OrPredicate<Cause.Cause<E>, Result>,
-    f: (a: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
+    predicate: Predicate.Predicate<Cause.Cause<E>>,
+    f: (cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
   ): Effect.Effect<A, E | E2, R | R2>
 } = dual(
   3,
-  <A, E, R, Result extends Filter.ResultOrBool, B, E2, R2>(
+  <A, E, R, B, E2, R2>(
     self: Effect.Effect<A, E, R>,
-    filter: Filter.OrPredicate<Cause.Cause<E>, Result>,
-    f: (a: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
+    predicate: Predicate.Predicate<Cause.Cause<E>>,
+    f: (cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
   ): Effect.Effect<A, E | E2, R | R2> =>
     catchCauseIf(
       self,
-      ((cause: Cause.Cause<E>) => {
-        const result = Filter.apply(filter as any, cause)
-        return Result.isFailure(result) ? Result.fail(cause) : result
-      }) as any,
-      (failure: any, cause: Cause.Cause<E>) => andThen(internalCall(() => f(failure, cause)), failCause(cause))
+      predicate,
+      (cause) => andThen(internalCall(() => f(cause)), failCause(cause))
     )
 )
 
+/** @internal */
+export const tapCauseFilter: {
+  <E, B, E2, R2, EB, X extends Cause.Cause<any>>(
+    filter: Filter.Filter<Cause.Cause<E>, EB, X>,
+    f: (a: EB, cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
+  ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, R | R2>
+  <A, E, R, B, E2, R2, EB, X extends Cause.Cause<any>>(
+    self: Effect.Effect<A, E, R>,
+    filter: Filter.Filter<Cause.Cause<E>, EB, X>,
+    f: (a: EB, cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
+  ): Effect.Effect<A, E | E2, R | R2>
+} = dual(
+  3,
+  <A, E, R, B, E2, R2, EB, X extends Cause.Cause<any>>(
+    self: Effect.Effect<A, E, R>,
+    filter: Filter.Filter<Cause.Cause<E>, EB, X>,
+    f: (a: EB, cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
+  ): Effect.Effect<A, E | E2, R | R2> =>
+    catchCause(self, (cause) => {
+      const result = filter(cause)
+      if (Result.isFailure(result)) {
+        return failCause(cause)
+      }
+      return andThen(internalCall(() => f(result.success, cause)), failCause(cause))
+    })
+)
+
 /** @internal */
 export const tapError: {
   <E, B, E2, R2>(
@@ -2553,7 +2589,7 @@ export const tapError: {
   <A, E, R, B, E2, R2>(
     self: Effect.Effect<A, E, R>,
     f: (e: NoInfer<E>) => Effect.Effect<B, E2, R2>
-  ): Effect.Effect<A, E | E2, R | R2> => tapCauseIf(self, findError as any, (e: any) => f(e)) as any
+  ): Effect.Effect<A, E | E2, R | R2> => tapCauseFilter(self, findError as any, (e: any) => f(e)) as any
 )
 
 /** @internal */
@@ -2620,7 +2656,7 @@ export const tapDefect: {
   <A, E, R, B, E2, R2>(
     self: Effect.Effect<A, E, R>,
     f: (defect: unknown) => Effect.Effect<B, E2, R2>
-  ): Effect.Effect<A, E | E2, R | R2> => tapCauseIf(self, findDefect as any, (_: any) => f(_)) as any
+  ): Effect.Effect<A, E | E2, R | R2> => tapCauseFilter(self, findDefect as any, (_: any) => f(_)) as any
 )
 
 /** @internal */
@@ -2630,10 +2666,10 @@ export const catchIf: {
     f: (e: EB) => Effect.Effect<A2, E2, R2>,
     orElse?: ((e: Exclude<E, EB>) => Effect.Effect<A3, E3, R3>) | undefined
   ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A2 | A3, E2 | E3, R | R2 | R3>
-  <E, Result extends Filter.ResultOrBool, A2, E2, R2, A3 = never, E3 = Filter.Fail<E, Result>, R3 = never>(
-    filter: Filter.OrPredicate<NoInfer<E>, Result>,
-    f: (e: Filter.Pass<E, Result>) => Effect.Effect<A2, E2, R2>,
-    orElse?: ((e: Filter.Fail<E, Result>) => Effect.Effect<A3, E3, R3>) | undefined
+  <E, A2, E2, R2, A3 = never, E3 = E, R3 = never>(
+    predicate: Predicate.Predicate<NoInfer<E>>,
+    f: (e: NoInfer<E>) => Effect.Effect<A2, E2, R2>,
+    orElse?: ((e: NoInfer<E>) => Effect.Effect<A3, E3, R3>) | undefined
   ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A2 | A3, E2 | E3, R | R2 | R3>
   <A, E, R, EB extends E, A2, E2, R2, A3 = never, E3 = Exclude<E, EB>, R3 = never>(
     self: Effect.Effect<A, E, R>,
@@ -2641,28 +2677,59 @@ export const catchIf: {
     f: (e: EB) => Effect.Effect<A2, E2, R2>,
     orElse?: ((e: Exclude<E, EB>) => Effect.Effect<A3, E3, R3>) | undefined
   ): Effect.Effect<A | A2 | A3, E2 | E3, R | R2 | R3>
-  <A, E, R, Result extends Filter.ResultOrBool, A2, E2, R2, A3 = never, E3 = Filter.Fail<E, Result>, R3 = never>(
+  <A, E, R, A2, E2, R2, A3 = never, E3 = E, R3 = never>(
     self: Effect.Effect<A, E, R>,
-    filter: Filter.OrPredicate<NoInfer<E>, Result>,
-    f: (e: Filter.Pass<E, Result>) => Effect.Effect<A2, E2, R2>,
-    orElse?: ((e: Filter.Fail<E, Result>) => Effect.Effect<A3, E3, R3>) | undefined
+    predicate: Predicate.Predicate<E>,
+    f: (e: E) => Effect.Effect<A2, E2, R2>,
+    orElse?: ((e: E) => Effect.Effect<A3, E3, R3>) | undefined
+  ): Effect.Effect<A | A2 | A3, E2 | E3, R | R2 | R3>
+} = dual(
+  (args) => isEffect(args[0]),
+  <A, E, R, A2, E2, R2, A3 = never, E3 = E, R3 = never>(
+    self: Effect.Effect<A, E, R>,
+    predicate: Predicate.Predicate<E>,
+    f: (e: E) => Effect.Effect<A2, E2, R2>,
+    orElse?: ((e: E) => Effect.Effect<A3, E3, R3>) | undefined
+  ): Effect.Effect<A | A2 | A3, E2 | E3, R | R2 | R3> =>
+    catchCause(self, (cause): Effect.Effect<A2 | A3, E2 | E3, R2 | R3> => {
+      const error = findError(cause)
+      if (Result.isFailure(error)) return failCause(error.failure)
+      if (!predicate(error.success)) {
+        return orElse ? internalCall(() => orElse(error.success as any)) : failCause(cause as any as Cause.Cause<E3>)
+      }
+      return internalCall(() => f(error.success as any))
+    })
+)
+
+/** @internal */
+export const catchFilter: {
+  <E, EB, A2, E2, R2, X, A3 = never, E3 = X, R3 = never>(
+    filter: Filter.Filter<NoInfer<E>, EB, X>,
+    f: (e: EB) => Effect.Effect<A2, E2, R2>,
+    orElse?: ((e: X) => Effect.Effect<A3, E3, R3>) | undefined
+  ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A2 | A3, E2 | E3, R | R2 | R3>
+  <A, E, R, EB, A2, E2, R2, X, A3 = never, E3 = X, R3 = never>(
+    self: Effect.Effect<A, E, R>,
+    filter: Filter.Filter<NoInfer<E>, EB, X>,
+    f: (e: EB) => Effect.Effect<A2, E2, R2>,
+    orElse?: ((e: X) => Effect.Effect<A3, E3, R3>) | undefined
   ): Effect.Effect<A | A2 | A3, E2 | E3, R | R2 | R3>
 } = dual(
   (args) => isEffect(args[0]),
   <A, E, R, EB, A2, E2, R2, X, A3 = never, E3 = X, R3 = never>(
     self: Effect.Effect<A, E, R>,
-    filter: Filter.Filter<NoInfer<E>, EB, X> | Predicate.Predicate<NoInfer<E>>,
+    filter: Filter.Filter<NoInfer<E>, EB, X>,
     f: (e: EB) => Effect.Effect<A2, E2, R2>,
     orElse?: ((e: X) => Effect.Effect<A3, E3, R3>) | undefined
   ): Effect.Effect<A | A2 | A3, E2 | E3, R | R2 | R3> =>
     catchCause(self, (cause): Effect.Effect<A2 | A3, E2 | E3, R2 | R3> => {
       const error = findError(cause)
       if (Result.isFailure(error)) return failCause(error.failure)
-      const result = Filter.apply(filter as any, error.success)
+      const result = filter(error.success)
       if (Result.isFailure(result)) {
         return orElse ? internalCall(() => orElse(result.failure as any)) : failCause(cause as any as Cause.Cause<E3>)
       }
-      return internalCall(() => f(result.success as any))
+      return internalCall(() => f(result.success))
     })
 )
 
@@ -2798,7 +2865,7 @@ export const catchTags: {
   >
 } = dual((args) => isEffect(args[0]), (self: Effect.Effect<any, any, any>, cases: Record<string, any>, orElse: any) => {
   let keys: Array<string>
-  return catchIf(
+  return catchFilter(
     self,
     (e) => {
       keys ??= Object.keys(cases)
@@ -2808,7 +2875,7 @@ export const catchTags: {
     },
     (e: any) => internalCall(() => cases[e["_tag"] as string](e)),
     orElse
-  )
+  ) as any
 })
 
 /** @internal */
@@ -3044,7 +3111,7 @@ export const unwrapReason: {
     self: Effect.Effect<A, E, R>,
     errorTag: K
   ): Effect.Effect<A, ExcludeTag<E, K> | ReasonOf<ExtractTag<E, K>>, R> =>
-    catchIf(
+    catchFilter(
       self,
       (e: any) => {
         if (isTagged(e, errorTag) && hasProperty(e, "reason")) {
@@ -3053,7 +3120,7 @@ export const unwrapReason: {
         return Result.fail(e)
       },
       fail as any
-    )
+    ) as any
 )
 
 /** @internal */
@@ -3804,34 +3871,51 @@ export const ensuring: {
 
 /** @internal */
 export const onExitIf: {
-  <A, E, XE, XR, Result extends Filter.ResultOrBool>(
-    filter: Filter.OrPredicate<Exit.Exit<NoInfer<A>, NoInfer<E>>, Result>,
-    f: (
-      pass: Filter.Pass<Exit.Exit<NoInfer<A>, NoInfer<E>>, Result>,
-      exit: Exit.Exit<NoInfer<A>, NoInfer<E>>
-    ) => Effect.Effect<void, XE, XR>
+  <A, E, XE, XR>(
+    predicate: Predicate.Predicate<Exit.Exit<NoInfer<A>, NoInfer<E>>>,
+    f: (exit: Exit.Exit<NoInfer<A>, NoInfer<E>>) => Effect.Effect<void, XE, XR>
   ): <R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | XE, R | XR>
-  <A, E, R, XE, XR, Result extends Filter.ResultOrBool>(
+  <A, E, R, XE, XR>(
     self: Effect.Effect<A, E, R>,
-    filter: Filter.OrPredicate<Exit.Exit<NoInfer<A>, NoInfer<E>>, Result>,
-    f: (
-      pass: Filter.Pass<Exit.Exit<NoInfer<A>, NoInfer<E>>, Result>,
-      exit: Exit.Exit<NoInfer<A>, NoInfer<E>>
-    ) => Effect.Effect<void, XE, XR>
+    predicate: Predicate.Predicate<Exit.Exit<NoInfer<A>, NoInfer<E>>>,
+    f: (exit: Exit.Exit<NoInfer<A>, NoInfer<E>>) => Effect.Effect<void, XE, XR>
   ): Effect.Effect<A, E | XE, R | XR>
 } = dual(
   3,
-  <A, E, R, XE, XR, Result extends Filter.ResultOrBool>(
+  <A, E, R, XE, XR>(
     self: Effect.Effect<A, E, R>,
-    filter: Filter.OrPredicate<Exit.Exit<NoInfer<A>, NoInfer<E>>, Result>,
-    f: (
-      pass: Filter.Pass<Exit.Exit<NoInfer<A>, NoInfer<E>>, Result>,
-      exit: Exit.Exit<NoInfer<A>, NoInfer<E>>
-    ) => Effect.Effect<void, XE, XR>
+    predicate: Predicate.Predicate<Exit.Exit<NoInfer<A>, NoInfer<E>>>,
+    f: (exit: Exit.Exit<NoInfer<A>, NoInfer<E>>) => Effect.Effect<void, XE, XR>
   ): Effect.Effect<A, E | XE, R | XR> =>
     onExit(self, (exit) => {
-      const pass = Filter.apply(filter, exit)
-      return Result.isFailure(pass) ? void_ : f(pass.success as any, exit)
+      if (!predicate(exit)) {
+        return void_
+      }
+      return f(exit)
+    })
+)
+
+/** @internal */
+export const onExitFilter: {
+  <A, E, XE, XR, B, X>(
+    filter: Filter.Filter<Exit.Exit<NoInfer<A>, NoInfer<E>>, B, X>,
+    f: (b: B, exit: Exit.Exit<NoInfer<A>, NoInfer<E>>) => Effect.Effect<void, XE, XR>
+  ): <R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | XE, R | XR>
+  <A, E, R, XE, XR, B, X>(
+    self: Effect.Effect<A, E, R>,
+    filter: Filter.Filter<Exit.Exit<NoInfer<A>, NoInfer<E>>, B, X>,
+    f: (b: B, exit: Exit.Exit<NoInfer<A>, NoInfer<E>>) => Effect.Effect<void, XE, XR>
+  ): Effect.Effect<A, E | XE, R | XR>
+} = dual(
+  3,
+  <A, E, R, XE, XR, B, X>(
+    self: Effect.Effect<A, E, R>,
+    filter: Filter.Filter<Exit.Exit<NoInfer<A>, NoInfer<E>>, B, X>,
+    f: (b: B, exit: Exit.Exit<NoInfer<A>, NoInfer<E>>) => Effect.Effect<void, XE, XR>
+  ): Effect.Effect<A, E | XE, R | XR> =>
+    onExit(self, (exit) => {
+      const b = filter(exit)
+      return Result.isFailure(b) ? void_ : f(b.success, exit)
     })
 )
 
@@ -3849,37 +3933,66 @@ export const onError: {
   <A, E, R, XE, XR>(
     self: Effect.Effect<A, E, R>,
     f: (cause: Cause.Cause<NoInfer<E>>) => Effect.Effect<void, XE, XR>
-  ): Effect.Effect<A, E | XE, R | XR> => onExitIf(self, exitFilterCause as any, f as any) as any
+  ): Effect.Effect<A, E | XE, R | XR> => onExitFilter(self, exitFilterCause as any, f as any) as any
 )
 
 /** @internal */
 export const onErrorIf: {
-  <E, Result extends Filter.ResultOrBool, XE, XR>(
-    filter: Filter.OrPredicate<Cause.Cause<E>, Result>,
-    f: (failure: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Effect.Effect<void, XE, XR>
+  <E, XE, XR>(
+    predicate: Predicate.Predicate<Cause.Cause<E>>,
+    f: (cause: Cause.Cause<E>) => Effect.Effect<void, XE, XR>
   ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | XE, R | XR>
-  <A, E, R, XE, XR, Result extends Filter.ResultOrBool>(
+  <A, E, R, XE, XR>(
     self: Effect.Effect<A, E, R>,
-    filter: Filter.OrPredicate<Cause.Cause<E>, Result>,
-    f: (failure: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Effect.Effect<void, XE, XR>
+    predicate: Predicate.Predicate<Cause.Cause<E>>,
+    f: (cause: Cause.Cause<E>) => Effect.Effect<void, XE, XR>
   ): Effect.Effect<A, E | XE, R | XR>
 } = dual(
   3,
-  <A, E, R, XE, XR, Result extends Filter.ResultOrBool>(
+  <A, E, R, XE, XR>(
     self: Effect.Effect<A, E, R>,
-    filter: Filter.OrPredicate<Cause.Cause<E>, Result>,
-    f: (failure: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Effect.Effect<void, XE, XR>
+    predicate: Predicate.Predicate<Cause.Cause<E>>,
+    f: (cause: Cause.Cause<E>) => Effect.Effect<void, XE, XR>
   ): Effect.Effect<A, E | XE, R | XR> =>
     onExitIf(
       self,
-      ((exit: Exit.Exit<any, any>) => {
-        if (exit._tag !== "Failure") return Result.fail(exit)
-        return Filter.apply(filter, exit.cause)
-      }) as any,
-      (eb: any, exit: any) => f(eb, (exit as Exit.Failure<any, any>).cause)
+      (exit): exit is Exit.Failure<A, E> => {
+        if (exit._tag !== "Failure") {
+          return false
+        }
+        return predicate(exit.cause)
+      },
+      (exit) => f((exit as Exit.Failure<A, E>).cause)
     ) as any
 )
 
+/** @internal */
+export const onErrorFilter: {
+  <A, E, EB, X, XE, XR>(
+    filter: Filter.Filter<Cause.Cause<E>, EB, X>,
+    f: (failure: EB, cause: Cause.Cause<E>) => Effect.Effect<void, XE, XR>
+  ): <R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | XE, R | XR>
+  <A, E, R, EB, X, XE, XR>(
+    self: Effect.Effect<A, E, R>,
+    filter: Filter.Filter<Cause.Cause<E>, EB, X>,
+    f: (failure: EB, cause: Cause.Cause<E>) => Effect.Effect<void, XE, XR>
+  ): Effect.Effect<A, E | XE, R | XR>
+} = dual(
+  3,
+  <A, E, R, EB, X, XE, XR>(
+    self: Effect.Effect<A, E, R>,
+    filter: Filter.Filter<Cause.Cause<E>, EB, X>,
+    f: (failure: EB, cause: Cause.Cause<E>) => Effect.Effect<void, XE, XR>
+  ): Effect.Effect<A, E | XE, R | XR> =>
+    onExit(self, (exit) => {
+      if (exit._tag !== "Failure") {
+        return void_
+      }
+      const result = filter(exit.cause)
+      return Result.isFailure(result) ? void_ : f(result.success, exit.cause)
+    })
+)
+
 /** @internal */
 export const onInterrupt: {
   <XE, XR>(
@@ -3894,8 +4007,7 @@ export const onInterrupt: {
   <A, E, R, XE, XR>(
     self: Effect.Effect<A, E, R>,
     finalizer: (interruptors: ReadonlySet<number>) => Effect.Effect<void, XE, XR>
-  ): Effect.Effect<A, E | XE, R | XR> =>
-    onErrorIf<E, Result.Result<Set<number>, Cause.Cause<E>>, XE, XR>(causeFilterInterruptors, finalizer)(self)
+  ): Effect.Effect<A, E | XE, R | XR> => onErrorFilter(causeFilterInterruptors as any, finalizer)(self) as any
 )
 
 /** @internal */
@@ -4102,25 +4214,25 @@ export const all = <
 
 /** @internal */
 export const partition: {
-  <A, B, E, R>(
-    f: (a: A, i: number) => Effect.Effect<B, E, R>,
+  <A, Pass, Fail, E, R>(
+    filter: Filter.FilterEffect<NoInfer<A>, Pass, Fail, E, R, [i: number]>,
     options?: { readonly concurrency?: Concurrency | undefined }
-  ): (elements: Iterable<A>) => Effect.Effect<[excluded: Array<E>, satisfying: Array<B>], never, R>
-  <A, B, E, R>(
+  ): (elements: Iterable<A>) => Effect.Effect<[excluded: Array<Fail>, satisfying: Array<Pass>], E, R>
+  <A, Pass, Fail, E, R>(
     elements: Iterable<A>,
-    f: (a: A, i: number) => Effect.Effect<B, E, R>,
+    filter: Filter.FilterEffect<NoInfer<A>, Pass, Fail, E, R, [i: number]>,
     options?: { readonly concurrency?: Concurrency | undefined }
-  ): Effect.Effect<[excluded: Array<E>, satisfying: Array<B>], never, R>
+  ): Effect.Effect<[excluded: Array<Fail>, satisfying: Array<Pass>], E, R>
 } = dual(
   (args) => isIterable(args[0]) && !isEffect(args[0]),
-  <A, B, E, R>(
+  <A, Pass, Fail, E, R>(
     elements: Iterable<A>,
-    f: (a: A, i: number) => Effect.Effect<B, E, R>,
+    filter: Filter.FilterEffect<A, Pass, Fail, E, R, [i: number]>,
     options?: { readonly concurrency?: Concurrency | undefined }
-  ): Effect.Effect<[excluded: Array<E>, satisfying: Array<B>], never, R> =>
+  ): Effect.Effect<[excluded: Array<Fail>, satisfying: Array<Pass>], E, R> =>
     map(
-      forEach(elements, (a, i) => result(f(a, i)), options),
-      (results) => Arr.partitionMap(results, identity)
+      forEach(elements, filter, options),
+      (results) => Arr.partition(results, identity)
     )
 )
 
@@ -4167,7 +4279,7 @@ export const validate: {
     } | undefined
   ): Effect.Effect<Array<B> | void, Arr.NonEmptyArray<E>, R> =>
     flatMap(
-      partition(elements, f, { concurrency: options?.concurrency }),
+      partition(elements, (a, i) => result(f(a, i)), { concurrency: options?.concurrency }),
       ([excluded, satisfying]) => {
         if (Arr.isArrayNonEmpty(excluded)) {
           return fail(excluded)
@@ -4348,33 +4460,85 @@ export const filterOrElse: {
     refinement: Predicate.Refinement<NoInfer<A>, B>,
     orElse: (a: EqualsWith<A, B, NoInfer<A>, Exclude<NoInfer<A>, B>>) => Effect.Effect<C, E2, R2>
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B | C, E2 | E, R2 | R>
-  <A, Result extends Filter.ResultOrBool, C, E2, R2>(
-    filter: Filter.OrPredicate<NoInfer<A>, Result>,
-    orElse: (a: Filter.Fail<A, Result>) => Effect.Effect<C, E2, R2>
-  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<Filter.Pass<A, Result> | C, E2 | E, R2 | R>
+  <A, C, E2, R2>(
+    predicate: Predicate.Predicate<NoInfer<A>>,
+    orElse: (a: NoInfer<A>) => Effect.Effect<C, E2, R2>
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | C, E2 | E, R2 | R>
   <A, E, R, C, E2, R2, B extends A>(
     self: Effect.Effect<A, E, R>,
     refinement: Predicate.Refinement<A, B>,
     orElse: (a: EqualsWith<A, B, A, Exclude<A, B>>) => Effect.Effect<C, E2, R2>
   ): Effect.Effect<B | C, E | E2, R | R2>
-  <A, E, R, Result extends Filter.ResultOrBool, C, E2, R2>(
+  <A, E, R, C, E2, R2>(
+    self: Effect.Effect<A, E, R>,
+    predicate: Predicate.Predicate<NoInfer<A>>,
+    orElse: (a: NoInfer<A>) => Effect.Effect<C, E2, R2>
+  ): Effect.Effect<A | C, E | E2, R | R2>
+} = dual(3, <A, E, R, B, E2, R2>(
+  self: Effect.Effect<A, E, R>,
+  predicate: Predicate.Predicate<A>,
+  orElse: (a: A) => Effect.Effect<B, E2, R2>
+): Effect.Effect<A | B, E | E2, R | R2> =>
+  flatMap(
+    self,
+    (a) => predicate(a) ? succeed<A | B>(a) : orElse(a)
+  ))
+
+/** @internal */
+export const filterMapOrElse: {
+  <A, B, X, C, E2, R2>(
+    filter: Filter.Filter<NoInfer<A>, B, X>,
+    orElse: (x: X) => Effect.Effect<C, E2, R2>
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B | C, E2 | E, R2 | R>
+  <A, E, R, B, X, C, E2, R2>(
     self: Effect.Effect<A, E, R>,
-    filter: Filter.OrPredicate<NoInfer<A>, Result>,
-    orElse: (a: Filter.Fail<A, Result>) => Effect.Effect<C, E2, R2>
-  ): Effect.Effect<Filter.Pass<A, Result> | C, E | E2, R | R2>
-} = dual(3, <A, E, R, Result extends Filter.ResultOrBool, C, E2, R2>(
+    filter: Filter.Filter<NoInfer<A>, B, X>,
+    orElse: (x: X) => Effect.Effect<C, E2, R2>
+  ): Effect.Effect<B | C, E | E2, R | R2>
+} = dual(3, <A, E, R, B, X, C, E2, R2>(
   self: Effect.Effect<A, E, R>,
-  filter: Filter.OrPredicate<NoInfer<A>, Result>,
-  orElse: (a: Filter.Fail<A, Result>) => Effect.Effect<C, E2, R2>
-): Effect.Effect<Filter.Pass<A, Result> | C, E | E2, R | R2> =>
+  filter: Filter.Filter<NoInfer<A>, B, X>,
+  orElse: (x: X) => Effect.Effect<C, E2, R2>
+): Effect.Effect<B | C, E | E2, R | R2> =>
   flatMap(
     self,
     (a) => {
-      const result = Filter.apply(filter, a)
-      return Result.isFailure(result) ? orElse(result.failure) : succeed(result.success) as any
+      const result = filter(a)
+      return (Result.isFailure(result)
+        ? orElse(result.failure)
+        : succeed(result.success)) as Effect.Effect<B | C, E2, R2>
     }
   ))
 
+/* @internal */
+export const filterMapOrFail: {
+  <A, B, X, E2>(
+    filter: Filter.Filter<NoInfer<A>, B, X>,
+    orFailWith: (x: X) => E2
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E2 | E, R>
+  <A, B, X>(
+    filter: Filter.Filter<NoInfer<A>, B, X>
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, Cause.NoSuchElementError | E, R>
+  <A, E, R, B, X, E2>(
+    self: Effect.Effect<A, E, R>,
+    filter: Filter.Filter<NoInfer<A>, B, X>,
+    orFailWith: (x: X) => E2
+  ): Effect.Effect<B, E2 | E, R>
+  <A, E, R, B, X>(
+    self: Effect.Effect<A, E, R>,
+    filter: Filter.Filter<NoInfer<A>, B, X>
+  ): Effect.Effect<B, Cause.NoSuchElementError | E, R>
+} = dual((args) => isEffect(args[0]), <A, E, R, B, X, E2>(
+  self: Effect.Effect<A, E, R>,
+  filter: Filter.Filter<NoInfer<A>, B, X>,
+  orFailWith?: (x: X) => E2
+): Effect.Effect<B, E2 | Cause.NoSuchElementError | E, R> =>
+  filterMapOrElse(
+    self,
+    filter,
+    orFailWith ? (x: X) => fail(orFailWith(x)) : () => fail(new NoSuchElementError() as E2)
+  ))
+
 /** @internal */
 export const filter: {
   <A, B extends A>(
@@ -4383,13 +4547,6 @@ export const filter: {
   <A>(
     predicate: Predicate.Predicate<NoInfer<A>>
   ): (elements: Iterable<A>) => Effect.Effect<Array<A>>
-  <A, B, X>(
-    filter: Filter.Filter<NoInfer<A>, B, X>
-  ): (elements: Iterable<A>) => Effect.Effect<Array<B>>
-  <A, B, X, E, R>(
-    filter: Filter.FilterEffect<NoInfer<A>, B, X, E, R>,
-    options?: { readonly concurrency?: Concurrency | undefined }
-  ): (elements: Iterable<A>) => Effect.Effect<Array<B>, E, R>
   <A, E, R>(
     predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>,
     options?: { readonly concurrency?: Concurrency | undefined }
@@ -4402,15 +4559,6 @@ export const filter: {
     elements: Iterable<A>,
     predicate: Predicate.Predicate<A>
   ): Effect.Effect<Array<A>>
-  <A, B, X>(
-    elements: Iterable<A>,
-    filter: Filter.Filter<NoInfer<A>, B, X>
-  ): Effect.Effect<Array<B>>
-  <A, B, X, E, R>(
-    elements: Iterable<A>,
-    filter: Filter.FilterEffect<NoInfer<A>, B, X, E, R>,
-    options?: { readonly concurrency?: Concurrency | undefined }
-  ): Effect.Effect<Array<B>, E, R>
   <A, E, R>(
     iterable: Iterable<A>,
     predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>,
@@ -4418,36 +4566,27 @@ export const filter: {
   ): Effect.Effect<Array<A>, E, R>
 } = dual(
   (args) => isIterable(args[0]) && !isEffect(args[0]),
-  <A, B, X, E, R>(
+  <A, E, R>(
     elements: Iterable<A>,
-    filter:
-      | Filter.FilterEffect<A, B, X, E, R>
+    predicate:
       | Predicate.Predicate<A>
       | ((a: A, i: number) => Effect.Effect<boolean, E, R>),
     options?: { readonly concurrency?: Concurrency | undefined }
-  ): Effect.Effect<Array<B>, E, R> =>
+  ): Effect.Effect<Array<A>, E, R> =>
     suspend(() => {
-      const out: Array<any> = []
+      const out: Array<A> = []
       return as(
         forEach(
           elements,
           (a, i) => {
-            const result = (filter as Function)(a, i)
+            const result = (predicate as Function)(a, i)
             if (typeof result === "boolean") {
               if (result) out.push(a)
               return void_ as any
             }
-            if (!isEffect(result)) {
-              if (!Result.isFailure(result)) {
-                out.push(result.success)
-              }
-              return void_ as any
-            }
-            return map(result, (r: any) => {
-              if (typeof r === "boolean") {
-                if (r) out.push(a)
-              } else if (!Result.isFailure(r)) {
-                out.push(r.success)
+            return map(result, (keep) => {
+              if (keep) {
+                out.push(a)
               }
             })
           },
@@ -4461,6 +4600,72 @@ export const filter: {
     })
 )
 
+/** @internal */
+export const filterMap: {
+  <A, B, X>(
+    filter: Filter.Filter<NoInfer<A>, B, X>
+  ): (elements: Iterable<A>) => Effect.Effect<Array<B>>
+  <A, B, X>(
+    elements: Iterable<A>,
+    filter: Filter.Filter<NoInfer<A>, B, X>
+  ): Effect.Effect<Array<B>>
+} = dual(
+  (args) => isIterable(args[0]) && !isEffect(args[0]),
+  <A, B, X>(
+    elements: Iterable<A>,
+    filter: Filter.Filter<A, B, X>
+  ): Effect.Effect<Array<B>> =>
+    suspend(() => {
+      const out: Array<B> = []
+      for (const a of elements) {
+        const result = filter(a)
+        if (Result.isSuccess(result)) {
+          out.push(result.success)
+        }
+      }
+      return succeed(out)
+    })
+)
+
+/** @internal */
+export const filterMapEffect: {
+  <A, B, X, E, R>(
+    filter: Filter.FilterEffect<NoInfer<A>, B, X, E, R>,
+    options?: { readonly concurrency?: Concurrency | undefined }
+  ): (elements: Iterable<A>) => Effect.Effect<Array<B>, E, R>
+  <A, B, X, E, R>(
+    elements: Iterable<A>,
+    filter: Filter.FilterEffect<NoInfer<A>, B, X, E, R>,
+    options?: { readonly concurrency?: Concurrency | undefined }
+  ): Effect.Effect<Array<B>, E, R>
+} = dual(
+  (args) => isIterable(args[0]) && !isEffect(args[0]),
+  <A, B, X, E, R>(
+    elements: Iterable<A>,
+    filter: Filter.FilterEffect<A, B, X, E, R>,
+    options?: { readonly concurrency?: Concurrency | undefined }
+  ): Effect.Effect<Array<B>, E, R> =>
+    suspend(() => {
+      const out: Array<B> = []
+      return as(
+        forEach(
+          elements,
+          (a) =>
+            map(filter(a), (result) => {
+              if (Result.isSuccess(result)) {
+                out.push(result.success)
+              }
+            }),
+          {
+            discard: true,
+            concurrency: options?.concurrency
+          }
+        ),
+        out
+      )
+    })
+)
+
 // ----------------------------------------------------------------------------
 // do notation
 // ----------------------------------------------------------------------------