effect 2.2.0 → 2.2.2

package/src/STM.ts

@@ -14,7 +14,7 @@ import * as stm from "./internal/stm/stm.js"
 import type * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
-import type * as Types from "./Types.js"
+import type { Covariant, NoInfer } from "./Types.js"
 import type * as Unify from "./Unify.js"
 
 /**
@@ -140,9 +140,9 @@ export declare namespace STM {
    */
   export interface Variance<out R, out E, out A> {
     readonly [STMTypeId]: {
-      readonly _R: Types.Covariant<R>
-      readonly _E: Types.Covariant<E>
-      readonly _A: Types.Covariant<A>
+      readonly _R: Covariant<R>
+      readonly _E: Covariant<E>
+      readonly _A: Covariant<A>
     }
   }
 }
@@ -550,7 +550,7 @@ export const eventually: <R, E, A>(self: STM<R, E, A>) => STM<R, E, A> = stm.eve
  * @category constructors
  */
 export const every: {
-  <A, R, E>(predicate: (a: A) => STM<R, E, boolean>): (iterable: Iterable<A>) => STM<R, E, boolean>
+  <A, R, E>(predicate: (a: NoInfer<A>) => STM<R, E, boolean>): (iterable: Iterable<A>) => STM<R, E, boolean>
   <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM<R, E, boolean>): STM<R, E, boolean>
 } = stm.every
 
@@ -562,7 +562,7 @@ export const every: {
  * @category constructors
  */
 export const exists: {
-  <A, R, E>(predicate: (a: A) => STM<R, E, boolean>): (iterable: Iterable<A>) => STM<R, E, boolean>
+  <A, R, E>(predicate: (a: NoInfer<A>) => STM<R, E, boolean>): (iterable: Iterable<A>) => STM<R, E, boolean>
   <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM<R, E, boolean>): STM<R, E, boolean>
 } = stm.exists
 
@@ -597,7 +597,7 @@ export const fiberId: STM<never, never, FiberId.FiberId> = stm.fiberId
  * @category constructors
  */
 export const filter: {
-  <A, R, E>(predicate: (a: A) => STM<R, E, boolean>): (iterable: Iterable<A>) => STM<R, E, Array<A>>
+  <A, R, E>(predicate: (a: NoInfer<A>) => STM<R, E, boolean>): (iterable: Iterable<A>) => STM<R, E, Array<A>>
   <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM<R, E, boolean>): STM<R, E, Array<A>>
 } = stm.filter
 
@@ -609,7 +609,7 @@ export const filter: {
  * @category constructors
  */
 export const filterNot: {
-  <A, R, E>(predicate: (a: A) => STM<R, E, boolean>): (iterable: Iterable<A>) => STM<R, E, Array<A>>
+  <A, R, E>(predicate: (a: NoInfer<A>) => STM<R, E, boolean>): (iterable: Iterable<A>) => STM<R, E, Array<A>>
   <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM<R, E, boolean>): STM<R, E, Array<A>>
 } = stm.filterNot
 
@@ -620,10 +620,13 @@ export const filterNot: {
  * @category filtering
  */
 export const filterOrDie: {
-  <A, B extends A>(refinement: Refinement<A, B>, defect: LazyArg<unknown>): <R, E>(self: STM<R, E, A>) => STM<R, E, B>
-  <A, X extends A>(predicate: Predicate<X>, defect: LazyArg<unknown>): <R, E>(self: STM<R, E, A>) => STM<R, E, A>
+  <A, B extends A>(
+    refinement: Refinement<NoInfer<A>, B>,
+    defect: LazyArg<unknown>
+  ): <R, E>(self: STM<R, E, A>) => STM<R, E, B>
+  <A>(predicate: Predicate<NoInfer<A>>, defect: LazyArg<unknown>): <R, E>(self: STM<R, E, A>) => STM<R, E, A>
   <R, E, A, B extends A>(self: STM<R, E, A>, refinement: Refinement<A, B>, defect: LazyArg<unknown>): STM<R, E, B>
-  <R, E, A, X extends A>(self: STM<R, E, A>, predicate: Predicate<X>, defect: LazyArg<unknown>): STM<R, E, A>
+  <R, E, A>(self: STM<R, E, A>, predicate: Predicate<A>, defect: LazyArg<unknown>): STM<R, E, A>
 } = stm.filterOrDie
 
 /**
@@ -634,10 +637,10 @@ export const filterOrDie: {
  * @category filtering
  */
 export const filterOrDieMessage: {
-  <A, B extends A>(refinement: Refinement<A, B>, message: string): <R, E>(self: STM<R, E, A>) => STM<R, E, B>
-  <A, X extends A>(predicate: Predicate<X>, message: string): <R, E>(self: STM<R, E, A>) => STM<R, E, A>
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>, message: string): <R, E>(self: STM<R, E, A>) => STM<R, E, B>
+  <A>(predicate: Predicate<NoInfer<A>>, message: string): <R, E>(self: STM<R, E, A>) => STM<R, E, A>
   <R, E, A, B extends A>(self: STM<R, E, A>, refinement: Refinement<A, B>, message: string): STM<R, E, B>
-  <R, E, A, X extends A>(self: STM<R, E, A>, predicate: Predicate<X>, message: string): STM<R, E, A>
+  <R, E, A>(self: STM<R, E, A>, predicate: Predicate<A>, message: string): STM<R, E, A>
 } = stm.filterOrDieMessage
 
 /**
@@ -647,24 +650,24 @@ export const filterOrDieMessage: {
  * @category filtering
  */
 export const filterOrElse: {
-  <A, B extends A, X extends A, R2, E2, A2>(
-    refinement: Refinement<A, B>,
-    orElse: (a: X) => STM<R2, E2, A2>
-  ): <R, E>(self: STM<R, E, A>) => STM<R2 | R, E2 | E, B | A2>
-  <A, X extends A, Y extends A, R2, E2, A2>(
-    predicate: Predicate<X>,
-    orElse: (a: Y) => STM<R2, E2, A2>
-  ): <R, E>(self: STM<R, E, A>) => STM<R2 | R, E2 | E, A | A2>
-  <R, E, A, B extends A, X extends A, R2, E2, A2>(
+  <A, B extends A, R2, E2, C>(
+    refinement: Refinement<NoInfer<A>, B>,
+    orElse: (a: NoInfer<A>) => STM<R2, E2, C>
+  ): <R, E>(self: STM<R, E, A>) => STM<R2 | R, E2 | E, B | C>
+  <A, R2, E2, B>(
+    predicate: Predicate<NoInfer<A>>,
+    orElse: (a: NoInfer<A>) => STM<R2, E2, B>
+  ): <R, E>(self: STM<R, E, A>) => STM<R2 | R, E2 | E, A | B>
+  <R, E, A, B extends A, R2, E2, C>(
     self: STM<R, E, A>,
     refinement: Refinement<A, B>,
-    orElse: (a: X) => STM<R2, E2, A2>
-  ): STM<R | R2, E | E2, B | A2>
-  <R, E, A, X extends A, Y extends A, R2, E2, A2>(
+    orElse: (a: A) => STM<R2, E2, C>
+  ): STM<R | R2, E | E2, B | C>
+  <R, E, A, R2, E2, B>(
     self: STM<R, E, A>,
-    predicate: Predicate<X>,
-    orElse: (a: Y) => STM<R2, E2, A2>
-  ): STM<R | R2, E | E2, A | A2>
+    predicate: Predicate<A>,
+    orElse: (a: A) => STM<R2, E2, B>
+  ): STM<R | R2, E | E2, A | B>
 } = stm.filterOrElse
 
 /**
@@ -674,24 +677,20 @@ export const filterOrElse: {
  * @category filtering
  */
 export const filterOrFail: {
-  <A, B extends A, X extends A, E2>(
-    refinement: Refinement<A, B>,
-    orFailWith: (a: X) => E2
+  <A, B extends A, E2>(
+    refinement: Refinement<NoInfer<A>, B>,
+    orFailWith: (a: NoInfer<A>) => E2
   ): <R, E>(self: STM<R, E, A>) => STM<R, E2 | E, B>
-  <A, X extends A, Y extends A, E2>(
-    predicate: Predicate<X>,
-    orFailWith: (a: Y) => E2
+  <A, E2>(
+    predicate: Predicate<NoInfer<A>>,
+    orFailWith: (a: NoInfer<A>) => E2
   ): <R, E>(self: STM<R, E, A>) => STM<R, E2 | E, A>
-  <R, E, A, B extends A, X extends A, E2>(
+  <R, E, A, B extends A, E2>(
     self: STM<R, E, A>,
     refinement: Refinement<A, B>,
-    orFailWith: (a: X) => E2
+    orFailWith: (a: A) => E2
   ): STM<R, E | E2, B>
-  <R, E, A, X extends A, Y extends A, E2>(
-    self: STM<R, E, A>,
-    predicate: Predicate<X>,
-    orFailWith: (a: Y) => E2
-  ): STM<R, E | E2, A>
+  <R, E, A, E2>(self: STM<R, E, A>, predicate: Predicate<A>, orFailWith: (a: A) => E2): STM<R, E | E2, A>
 } = stm.filterOrFail
 
 /**
@@ -1723,7 +1722,9 @@ export const retry: STM<never, never, never> = core.retry
  * @category mutations
  */
 export const retryUntil: {
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <R, E>(self: STM<R, E, A>) => STM<R, E, B>
   <A>(predicate: Predicate<A>): <R, E>(self: STM<R, E, A>) => STM<R, E, A>
+  <R, E, A, B extends A>(self: STM<R, E, A>, refinement: Refinement<A, B>): STM<R, E, B>
   <R, E, A>(self: STM<R, E, A>, predicate: Predicate<A>): STM<R, E, A>
 } = stm.retryUntil
 
@@ -1817,8 +1818,8 @@ export const sync: <A>(evaluate: () => A) => STM<never, never, A> = core.sync
  * @category sequencing
  */
 export const tap: {
-  <A, X extends A, R2, E2, _>(f: (a: X) => STM<R2, E2, _>): <R, E>(self: STM<R, E, A>) => STM<R2 | R, E2 | E, A>
-  <R, E, A, X extends A, R2, E2, _>(self: STM<R, E, A>, f: (a: X) => STM<R2, E2, _>): STM<R | R2, E | E2, A>
+  <A, R2, E2, _>(f: (a: A) => STM<R2, E2, _>): <R, E>(self: STM<R, E, A>) => STM<R2 | R, E2 | E, A>
+  <R, E, A, R2, E2, _>(self: STM<R, E, A>, f: (a: A) => STM<R2, E2, _>): STM<R | R2, E | E2, A>
 } = stm.tap
 
 /**
@@ -1850,8 +1851,8 @@ export const tapBoth: {
  * @category sequencing
  */
 export const tapError: {
-  <E, X extends E, R2, E2, _>(f: (error: X) => STM<R2, E2, _>): <R, A>(self: STM<R, E, A>) => STM<R2 | R, E | E2, A>
-  <R, A, E, X extends E, R2, E2, _>(self: STM<R, E, A>, f: (error: X) => STM<R2, E2, _>): STM<R | R2, E | E2, A>
+  <E, R2, E2, _>(f: (error: NoInfer<E>) => STM<R2, E2, _>): <R, A>(self: STM<R, E, A>) => STM<R2 | R, E | E2, A>
+  <R, A, E, R2, E2, _>(self: STM<R, E, A>, f: (error: E) => STM<R2, E2, _>): STM<R | R2, E | E2, A>
 } = stm.tapError
 
 const try_: {

package/src/SortedSet.ts

@@ -13,7 +13,7 @@ import { pipeArguments } from "./Pipeable.js"
 import type { Predicate } from "./Predicate.js"
 import { hasProperty } from "./Predicate.js"
 import * as RBT from "./RedBlackTree.js"
-import type * as Types from "./Types.js"
+import type { Invariant, NoInfer } from "./Types.js"
 
 const TypeId: unique symbol = Symbol.for("effect/SortedSet")
 
@@ -29,7 +29,7 @@ export type TypeId = typeof TypeId
  */
 export interface SortedSet<in out A> extends Iterable<A>, Equal.Equal, Pipeable, Inspectable {
   readonly [TypeId]: {
-    readonly _A: Types.Invariant<A>
+    readonly _A: Invariant<A>
   }
   /** @internal */
   readonly keyTree: RBT.RedBlackTree<A, boolean>
@@ -279,9 +279,9 @@ export const map: {
  * @category filtering
  */
 export const partition: {
-  <B extends A, A = B>(
-    predicate: (a: A) => boolean
-  ): (self: SortedSet<B>) => [excluded: SortedSet<B>, satisfying: SortedSet<B>]
+  <A>(
+    predicate: (a: NoInfer<A>) => boolean
+  ): (self: SortedSet<A>) => [excluded: SortedSet<A>, satisfying: SortedSet<A>]
   <A>(self: SortedSet<A>, predicate: (a: A) => boolean): [excluded: SortedSet<A>, satisfying: SortedSet<A>]
 } = Dual.dual(
   2,

package/src/Stream.ts

@@ -29,7 +29,7 @@ import type * as Emit from "./StreamEmit.js"
 import type * as HaltStrategy from "./StreamHaltStrategy.js"
 import type * as Take from "./Take.js"
 import type * as Tracer from "./Tracer.js"
-import type * as Types from "./Types.js"
+import type { Covariant, NoInfer } from "./Types.js"
 import type * as Unify from "./Unify.js"
 
 /**
@@ -115,9 +115,9 @@ export declare namespace Stream {
    */
   export interface Variance<out R, out E, out A> {
     readonly [StreamTypeId]: {
-      _R: Types.Covariant<R>
-      _E: Types.Covariant<E>
-      _A: Types.Covariant<A>
+      _R: Covariant<R>
+      _E: Covariant<E>
+      _A: Covariant<A>
     }
   }
 
@@ -995,7 +995,7 @@ export const dropRight: {
  * @category utils
  */
 export const dropUntil: {
-  <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>
+  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>
   <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>
 } = internal.dropUntil
 
@@ -1007,12 +1007,12 @@ export const dropUntil: {
  * @category utils
  */
 export const dropUntilEffect: {
-  <A, X extends A, R2, E2>(
-    predicate: (a: X) => Effect.Effect<R2, E2, boolean>
+  <A, R2, E2>(
+    predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
   ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
-  <R, E, A, X extends A, R2, E2>(
+  <R, E, A, R2, E2>(
     self: Stream<R, E, A>,
-    predicate: (a: X) => Effect.Effect<R2, E2, boolean>
+    predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
   ): Stream<R | R2, E | E2, A>
 } = internal.dropUntilEffect
 
@@ -1024,7 +1024,7 @@ export const dropUntilEffect: {
  * @category utils
  */
 export const dropWhile: {
-  <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>
+  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>
   <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>
 } = internal.dropWhile
 
@@ -1036,12 +1036,12 @@ export const dropWhile: {
  * @category utils
  */
 export const dropWhileEffect: {
-  <A, X extends A, R2, E2>(
-    predicate: (a: X) => Effect.Effect<R2, E2, boolean>
+  <A, R2, E2>(
+    predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
   ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
-  <R, E, A, X extends A, R2, E2>(
+  <R, E, A, R2, E2>(
     self: Stream<R, E, A>,
-    predicate: (a: X) => Effect.Effect<R2, E2, boolean>
+    predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
   ): Stream<R | R2, E | E2, A>
 } = internal.dropWhileEffect
 
@@ -1175,8 +1175,8 @@ export const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Stream<nev
  * @category filtering
  */
 export const filter: {
-  <A, B extends A>(refinement: Refinement<A, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>
-  <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>
+  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>
   <R, E, A, B extends A>(self: Stream<R, E, A>, refinement: Refinement<A, B>): Stream<R, E, B>
   <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>
 } = internal.filter
@@ -1188,12 +1188,12 @@ export const filter: {
  * @category filtering
  */
 export const filterEffect: {
-  <A, X extends A, R2, E2>(
-    f: (a: X) => Effect.Effect<R2, E2, boolean>
+  <A, R2, E2>(
+    f: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
   ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
-  <R, E, A, X extends A, R2, E2>(
+  <R, E, A, R2, E2>(
     self: Stream<R, E, A>,
-    f: (a: X) => Effect.Effect<R2, E2, boolean>
+    f: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
   ): Stream<R | R2, E | E2, A>
 } = internal.filterEffect
 
@@ -1270,8 +1270,8 @@ export const finalizer: <R, _>(finalizer: Effect.Effect<R, never, _>) => Stream<
  * @category elements
  */
 export const find: {
-  <A, B extends A>(refinement: Refinement<A, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>
-  <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>
+  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>
   <R, E, A, B extends A>(self: Stream<R, E, A>, refinement: Refinement<A, B>): Stream<R, E, B>
   <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>
 } = internal.find
@@ -1284,12 +1284,12 @@ export const find: {
  * @category elements
  */
 export const findEffect: {
-  <A, X extends A, R2, E2>(
-    predicate: (a: X) => Effect.Effect<R2, E2, boolean>
+  <A, R2, E2>(
+    predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
   ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
-  <R, E, A, X extends A, R2, E2>(
+  <R, E, A, R2, E2>(
     self: Stream<R, E, A>,
-    predicate: (a: X) => Effect.Effect<R2, E2, boolean>
+    predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
   ): Stream<R | R2, E | E2, A>
 } = internal.findEffect
 
@@ -2480,7 +2480,7 @@ export const paginateEffect: <S, R, E, A>(
  */
 export const partition: {
   <C extends A, B extends A, A = C>(
-    refinement: Refinement<A, B>,
+    refinement: Refinement<NoInfer<A>, B>,
     options?: {
       bufferSize?: number | undefined
     }
@@ -2520,7 +2520,7 @@ export const partition: {
  */
 export const partitionEither: {
   <A, R2, E2, A2, A3>(
-    predicate: (a: A) => Effect.Effect<R2, E2, Either.Either<A2, A3>>,
+    predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, Either.Either<A2, A3>>,
     options?: {
       readonly bufferSize?: number | undefined
     }
@@ -3527,7 +3527,7 @@ export const someOrFail: {
  * @category utils
  */
 export const split: {
-  <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, Chunk.Chunk<B>>
+  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>>
   <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, Chunk.Chunk<A>>
 } = internal.split
 
@@ -3605,7 +3605,7 @@ export const takeRight: {
  * @category utils
  */
 export const takeUntil: {
-  <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>
+  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>
   <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>
 } = internal.takeUntil
 
@@ -3618,7 +3618,7 @@ export const takeUntil: {
  */
 export const takeUntilEffect: {
   <A, R2, E2>(
-    predicate: (a: A) => Effect.Effect<R2, E2, boolean>
+    predicate: (a: NoInfer<A>) => Effect.Effect<R2, E2, boolean>
   ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
   <R, E, A, R2, E2>(
     self: Stream<R, E, A>,
@@ -3634,8 +3634,8 @@ export const takeUntilEffect: {
  * @category utils
  */
 export const takeWhile: {
-  <A, B extends A>(refinement: Refinement<A, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>
-  <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>
+  <A>(predicate: Predicate<NoInfer<A>>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>
   <R, E, A, B extends A>(self: Stream<R, E, A>, refinement: Refinement<A, B>): Stream<R, E, B>
   <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>
 } = internal.takeWhile
@@ -3647,12 +3647,12 @@ export const takeWhile: {
  * @category sequencing
  */
 export const tap: {
-  <A, X extends A, R2, E2, _>(
-    f: (a: X) => Effect.Effect<R2, E2, _>
+  <A, R2, E2, _>(
+    f: (a: NoInfer<A>) => Effect.Effect<R2, E2, _>
   ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E2 | E, A>
-  <R, E, A, X extends A, R2, E2, _>(
+  <R, E, A, R2, E2, _>(
     self: Stream<R, E, A>,
-    f: (a: X) => Effect.Effect<R2, E2, _>
+    f: (a: NoInfer<A>) => Effect.Effect<R2, E2, _>
   ): Stream<R | R2, E | E2, A>
 } = internal.tap
 
@@ -3664,17 +3664,17 @@ export const tap: {
  * @category sequencing
  */
 export const tapBoth: {
-  <E, XE extends E, A, XA extends A, R2, E2, X, R3, E3, X1>(
+  <E, R2, E2, X1, A, R3, E3, X2>(
     options: {
-      readonly onFailure: (e: XE) => Effect.Effect<R2, E2, X>
-      readonly onSuccess: (a: XA) => Effect.Effect<R3, E3, X1>
+      readonly onFailure: (e: NoInfer<E>) => Effect.Effect<R2, E2, X1>
+      readonly onSuccess: (a: NoInfer<A>) => Effect.Effect<R3, E3, X2>
     }
   ): <R>(self: Stream<R, E, A>) => Stream<R | R2 | R3, E | E2 | E3, A>
-  <R, E, A, XE extends E, XA extends A, R2, E2, X, R3, E3, X1>(
+  <R, E, A, R2, E2, X1, R3, E3, X2>(
     self: Stream<R, E, A>,
     options: {
-      readonly onFailure: (e: XE) => Effect.Effect<R2, E2, X>
-      readonly onSuccess: (a: XA) => Effect.Effect<R3, E3, X1>
+      readonly onFailure: (e: NoInfer<E>) => Effect.Effect<R2, E2, X1>
+      readonly onSuccess: (a: NoInfer<A>) => Effect.Effect<R3, E3, X2>
     }
   ): Stream<R | R2 | R3, E | E2 | E3, A>
 } = internal.tapBoth
@@ -3686,12 +3686,12 @@ export const tapBoth: {
  * @category sequencing
  */
 export const tapError: {
-  <E, X extends E, R2, E2, _>(
-    f: (error: X) => Effect.Effect<R2, E2, _>
+  <E, R2, E2, _>(
+    f: (error: NoInfer<E>) => Effect.Effect<R2, E2, _>
   ): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E | E2, A>
-  <R, A, E, X extends E, R2, E2, _>(
+  <R, A, E, R2, E2, _>(
     self: Stream<R, E, A>,
-    f: (error: X) => Effect.Effect<R2, E2, _>
+    f: (error: E) => Effect.Effect<R2, E2, _>
   ): Stream<R | R2, E | E2, A>
 } = internal.tapError
 
@@ -3703,12 +3703,12 @@ export const tapError: {
  * @category utils
  */
 export const tapErrorCause: {
-  <E, X extends E, R2, E2, _>(
-    f: (cause: Cause.Cause<X>) => Effect.Effect<R2, E2, _>
+  <E, R2, E2, _>(
+    f: (cause: Cause.Cause<NoInfer<E>>) => Effect.Effect<R2, E2, _>
   ): <R, A>(self: Stream<R, E, A>) => Stream<R2 | R, E | E2, A>
-  <R, A, E, X extends E, R2, E2, _>(
+  <R, A, E, R2, E2, _>(
     self: Stream<R, E, A>,
-    f: (cause: Cause.Cause<X>) => Effect.Effect<R2, E2, _>
+    f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, _>
   ): Stream<R | R2, E | E2, A>
 } = internal.tapErrorCause
 

package/src/Trie.ts

@@ -20,7 +20,7 @@ import type { Inspectable } from "./Inspectable.js"
 import * as TR from "./internal/trie.js"
 import type { Option } from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
-import type * as Types from "./Types.js"
+import type { Covariant, NoInfer } from "./Types.js"
 
 const TypeId: unique symbol = TR.TrieTypeId as TypeId
 
@@ -36,7 +36,7 @@ export type TypeId = typeof TypeId
  */
 export interface Trie<in out Value> extends Iterable<[string, Value]>, Equal, Pipeable, Inspectable {
   readonly [TypeId]: {
-    readonly _Value: Types.Covariant<Value>
+    readonly _Value: Covariant<Value>
   }
 }
 
@@ -589,8 +589,8 @@ export const map: {
  * @category filtering
  */
 export const filter: {
-  <A, B extends A>(f: (a: A, k: string) => a is B): (self: Trie<A>) => Trie<B>
-  <B extends A, A = B>(f: (a: A, k: string) => boolean): (self: Trie<B>) => Trie<B>
+  <A, B extends A>(f: (a: NoInfer<A>, k: string) => a is B): (self: Trie<A>) => Trie<B>
+  <A>(f: (a: NoInfer<A>, k: string) => boolean): (self: Trie<A>) => Trie<A>
   <A, B extends A>(self: Trie<A>, f: (a: A, k: string) => a is B): Trie<B>
   <A>(self: Trie<A>, f: (a: A, k: string) => boolean): Trie<A>
 } = TR.filter

package/src/internal/cause.ts

@@ -9,11 +9,12 @@ import * as HashSet from "../HashSet.js"
 import { NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
-import { hasProperty, isFunction, type Predicate } from "../Predicate.js"
+import { hasProperty, isFunction } from "../Predicate.js"
+import type { Predicate, Refinement } from "../Predicate.js"
 import * as ReadonlyArray from "../ReadonlyArray.js"
-import * as OpCodes from "./opCodes/cause.js"
-
 import type { ParentSpan, Span } from "../Tracer.js"
+import type { NoInfer } from "../Types.js"
+import * as OpCodes from "./opCodes/cause.js"
 
 // -----------------------------------------------------------------------------
 // Models
@@ -643,10 +644,18 @@ export const find = dual<
 // -----------------------------------------------------------------------------
 
 /** @internal */
-export const filter = dual<
-  <E>(predicate: Predicate<Cause.Cause<E>>) => (self: Cause.Cause<E>) => Cause.Cause<E>,
-  <E>(self: Cause.Cause<E>, predicate: Predicate<Cause.Cause<E>>) => Cause.Cause<E>
->(2, (self, predicate) => reduceWithContext(self, void 0, FilterCauseReducer(predicate)))
+export const filter: {
+  <E, EB extends E>(
+    refinement: Refinement<Cause.Cause<NoInfer<E>>, Cause.Cause<EB>>
+  ): (self: Cause.Cause<E>) => Cause.Cause<EB>
+  <E>(predicate: Predicate<Cause.Cause<NoInfer<E>>>): (self: Cause.Cause<E>) => Cause.Cause<E>
+  <E, EB extends E>(self: Cause.Cause<E>, refinement: Refinement<Cause.Cause<E>, Cause.Cause<EB>>): Cause.Cause<EB>
+  <E>(self: Cause.Cause<E>, predicate: Predicate<Cause.Cause<E>>): Cause.Cause<E>
+} = dual(
+  2,
+  <E>(self: Cause.Cause<E>, predicate: Predicate<Cause.Cause<E>>): Cause.Cause<E> =>
+    reduceWithContext(self, void 0, FilterCauseReducer(predicate))
+)
 
 // -----------------------------------------------------------------------------
 // Evaluation

package/src/internal/channel.ts

@@ -1246,21 +1246,25 @@ export const mergeAllWith = (
             ),
           onSuccess: Either.match({
             onLeft: (outDone) =>
-              Effect.raceWith(Deferred.await(errorSignal), withPermits(concurrencyN)(Effect.unit), {
-                onSelfDone: (_, permitAcquisition) => Effect.as(Fiber.interrupt(permitAcquisition), false),
-                onOtherDone: (_, failureAwait) =>
-                  Effect.zipRight(
-                    Fiber.interrupt(failureAwait),
-                    pipe(
-                      Ref.get(lastDone),
-                      Effect.flatMap(Option.match({
-                        onNone: () => Queue.offer(queue, Effect.succeed(Either.left(outDone))),
-                        onSome: (lastDone) => Queue.offer(queue, Effect.succeed(Either.left(f(lastDone, outDone))))
-                      })),
-                      Effect.as(false)
+              Effect.raceWith(
+                Effect.interruptible(Deferred.await(errorSignal)),
+                Effect.interruptible(withPermits(concurrencyN)(Effect.unit)),
+                {
+                  onSelfDone: (_, permitAcquisition) => Effect.as(Fiber.interrupt(permitAcquisition), false),
+                  onOtherDone: (_, failureAwait) =>
+                    Effect.zipRight(
+                      Fiber.interrupt(failureAwait),
+                      pipe(
+                        Ref.get(lastDone),
+                        Effect.flatMap(Option.match({
+                          onNone: () => Queue.offer(queue, Effect.succeed(Either.left(outDone))),
+                          onSome: (lastDone) => Queue.offer(queue, Effect.succeed(Either.left(f(lastDone, outDone))))
+                        })),
+                        Effect.as(false)
+                      )
                     )
-                  )
-              }),
+                }
+              ),
             onRight: (channel) =>
               _mergeStrategy.match(mergeStrategy, {
                 onBackPressure: () =>
@@ -1273,7 +1277,7 @@ export const mergeAllWith = (
                       Effect.flatMap((pull) =>
                         Effect.race(
                           evaluatePull(pull),
-                          Deferred.await(errorSignal)
+                          Effect.interruptible(Deferred.await(errorSignal))
                         )
                       ),
                       Effect.scoped
@@ -1306,8 +1310,8 @@ export const mergeAllWith = (
                       Effect.flatMap((pull) =>
                         pipe(
                           evaluatePull(pull),
-                          Effect.race(Deferred.await(errorSignal)),
-                          Effect.race(Deferred.await(canceler))
+                          Effect.race(Effect.interruptible(Deferred.await(errorSignal))),
+                          Effect.race(Effect.interruptible(Deferred.await(canceler)))
                         )
                       ),
                       Effect.scoped