effect 2.1.2 → 2.2.1

package/src/ReadonlyArray.ts

@@ -19,6 +19,7 @@ import type { Predicate, Refinement } from "./Predicate.js"
 import { isBoolean } from "./Predicate.js"
 import * as RR from "./ReadonlyRecord.js"
 import * as Tuple from "./Tuple.js"
+import type { NoInfer } from "./Types.js"
 
 /**
  * @category type lambdas
@@ -559,8 +560,8 @@ export const takeRight: {
  * @since 2.0.0
  */
 export const takeWhile: {
-  <A, B extends A>(refinement: (a: A, i: number) => a is B): (self: Iterable<A>) => Array<B>
-  <B extends A, A = B>(predicate: (a: A, i: number) => boolean): (self: Iterable<B>) => Array<B>
+  <A, B extends A>(refinement: (a: NoInfer<A>, i: number) => a is B): (self: Iterable<A>) => Array<B>
+  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => Array<A>
   <A, B extends A>(self: Iterable<A>, refinement: (a: A, i: number) => a is B): Array<B>
   <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Array<A>
 } = dual(2, <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Array<A> => {
@@ -597,10 +598,10 @@ const spanIndex = <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean
  * @since 2.0.0
  */
 export const span: {
-  <C extends A, B extends A, A = C>(
-    refinement: (a: A, i: number) => a is B
-  ): (self: Iterable<C>) => [init: Array<B>, rest: Array<Exclude<C, B>>]
-  <B extends A, A = B>(predicate: (a: A, i: number) => boolean): (self: Iterable<B>) => [init: Array<B>, rest: Array<B>]
+  <A, B extends A>(
+    refinement: (a: NoInfer<A>, i: number) => a is B
+  ): (self: Iterable<A>) => [init: Array<B>, rest: Array<Exclude<A, B>>]
+  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => [init: Array<A>, rest: Array<A>]
   <A, B extends A>(
     self: Iterable<A>,
     refinement: (a: A, i: number) => a is B
@@ -651,7 +652,7 @@ export const dropRight: {
  * @since 2.0.0
  */
 export const dropWhile: {
-  <B extends A, A = B>(predicate: (a: A, i: number) => boolean): (self: Iterable<B>) => Array<B>
+  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => Array<A>
   <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Array<A>
 } = dual(
   2,
@@ -666,7 +667,7 @@ export const dropWhile: {
  * @since 2.0.0
  */
 export const findFirstIndex: {
-  <A>(predicate: (a: A, i: number) => boolean): (self: Iterable<A>) => Option<number>
+  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => Option<number>
   <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option<number>
 } = dual(2, <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option<number> => {
   let i = 0
@@ -686,7 +687,7 @@ export const findFirstIndex: {
  * @since 2.0.0
  */
 export const findLastIndex: {
-  <A>(predicate: (a: A, i: number) => boolean): (self: Iterable<A>) => Option<number>
+  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => Option<number>
   <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option<number>
 } = dual(2, <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option<number> => {
   const input = fromIterable(self)
@@ -706,9 +707,9 @@ export const findLastIndex: {
  * @since 2.0.0
  */
 export const findFirst: {
-  <A, B>(f: (a: A, i: number) => Option<B>): (self: Iterable<A>) => Option<B>
-  <A, B extends A>(refinement: (a: A, i: number) => a is B): (self: Iterable<A>) => Option<B>
-  <B extends A, A = B>(predicate: (a: A, i: number) => boolean): (self: Iterable<B>) => Option<B>
+  <A, B>(f: (a: NoInfer<A>, i: number) => Option<B>): (self: Iterable<A>) => Option<B>
+  <A, B extends A>(refinement: (a: NoInfer<A>, i: number) => a is B): (self: Iterable<A>) => Option<B>
+  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => Option<A>
   <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>): Option<B>
   <A, B extends A>(self: Iterable<A>, refinement: (a: A, i: number) => a is B): Option<B>
   <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option<A>
@@ -740,9 +741,9 @@ export const findFirst: {
  * @since 2.0.0
  */
 export const findLast: {
-  <A, B>(f: (a: A, i: number) => Option<B>): (self: Iterable<A>) => Option<B>
-  <A, B extends A>(refinement: (a: A, i: number) => a is B): (self: Iterable<A>) => Option<B>
-  <B extends A, A = B>(predicate: (a: A, i: number) => boolean): (self: Iterable<B>) => Option<B>
+  <A, B>(f: (a: NoInfer<A>, i: number) => Option<B>): (self: Iterable<A>) => Option<B>
+  <A, B extends A>(refinement: (a: NoInfer<A>, i: number) => a is B): (self: Iterable<A>) => Option<B>
+  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => Option<A>
   <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>): Option<B>
   <A, B extends A>(self: Iterable<A>, refinement: (a: A, i: number) => a is B): Option<B>
   <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option<A>
@@ -896,12 +897,15 @@ export const sort: {
  * @category elements
  */
 export const sortWith: {
-  <A, B>(f: (a: A) => B, order: Order.Order<B>): (self: ReadonlyArray<A>) => Array<A>
-  <A, B>(self: ReadonlyArray<A>, f: (a: A) => B, order: Order.Order<B>): Array<A>
+  <S extends Iterable<any> | NonEmptyReadonlyArray<any>, B>(
+    f: (a: ReadonlyArray.Infer<S>) => B,
+    order: Order.Order<B>
+  ): (self: S) => ReadonlyArray.With<S, ReadonlyArray.Infer<S>>
+  <A, B>(self: NonEmptyReadonlyArray<A>, f: (a: A) => B, O: Order.Order<B>): NonEmptyArray<A>
+  <A, B>(self: Iterable<A>, f: (a: A) => B, order: Order.Order<B>): Array<A>
 } = dual(
   3,
-  <A, B>(self: ReadonlyArray<A>, f: (a: A) => B, order: Order.Order<B>): Array<A> =>
-    sort(self, Order.mapInput(order, f))
+  <A, B>(self: Iterable<A>, f: (a: A) => B, order: Order.Order<B>): Array<A> => sort(self, Order.mapInput(order, f))
 )
 
 /**
@@ -1236,9 +1240,9 @@ export const split: {
  * @since 2.0.0
  */
 export const splitWhere: {
-  <B extends A, A = B>(
-    predicate: (a: A, i: number) => boolean
-  ): (self: Iterable<B>) => [beforeMatch: Array<B>, fromMatch: Array<B>]
+  <A>(
+    predicate: (a: NoInfer<A>, i: number) => boolean
+  ): (self: Iterable<A>) => [beforeMatch: Array<A>, fromMatch: Array<A>]
   <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): [beforeMatch: Array<A>, fromMatch: Array<A>]
 } = dual(
   2,
@@ -1702,15 +1706,15 @@ export const getRights = <E, A>(self: Iterable<Either<E, A>>): Array<A> => {
  * @since 2.0.0
  */
 export const filter: {
-  <A, B extends A>(refinement: (a: A, i: number) => a is B): (self: Iterable<A>) => Array<B>
-  <A, B extends A>(predicate: (b: B, i: number) => boolean): (self: Iterable<A>) => Array<A>
+  <A, B extends A>(refinement: (a: NoInfer<A>, i: number) => a is B): (self: Iterable<A>) => Array<B>
+  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Iterable<A>) => Array<A>
   <A, B extends A>(self: Iterable<A>, refinement: (a: A, i: number) => a is B): Array<B>
   <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Array<A>
 } = dual(
   2,
-  <B extends A, A = B>(self: Iterable<B>, predicate: (a: A, i: number) => boolean): Array<B> => {
+  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Array<A> => {
     const as = fromIterable(self)
-    const out: Array<B> = []
+    const out: Array<A> = []
     for (let i = 0; i < as.length; i++) {
       if (predicate(as[i], i)) {
         out.push(as[i])
@@ -1727,12 +1731,12 @@ export const filter: {
  * @since 2.0.0
  */
 export const partition: {
-  <C extends A, B extends A, A = C>(refinement: (a: A, i: number) => a is B): (
-    self: Iterable<C>
-  ) => [excluded: Array<Exclude<C, B>>, satisfying: Array<B>]
-  <B extends A, A = B>(
-    predicate: (a: A, i: number) => boolean
-  ): (self: Iterable<B>) => [excluded: Array<B>, satisfying: Array<B>]
+  <A, B extends A>(refinement: (a: NoInfer<A>, i: number) => a is B): (
+    self: Iterable<A>
+  ) => [excluded: Array<Exclude<A, B>>, satisfying: Array<B>]
+  <A>(
+    predicate: (a: NoInfer<A>, i: number) => boolean
+  ): (self: Iterable<A>) => [excluded: Array<A>, satisfying: Array<A>]
   <A, B extends A>(
     self: Iterable<A>,
     refinement: (a: A, i: number) => a is B
@@ -1793,7 +1797,7 @@ export const reduceRight: {
  * @category lifting
  * @since 2.0.0
  */
-export const liftPredicate: {
+export const liftPredicate: { // Note: I intentionally avoid using the NoInfer pattern here.
   <A, B extends A>(refinement: Refinement<A, B>): (a: A) => Array<B>
   <A>(predicate: Predicate<A>): <B extends A>(b: B) => Array<B>
 } = <A>(predicate: Predicate<A>) => <B extends A>(b: B): Array<B> => predicate(b) ? [b] : []
@@ -1854,8 +1858,10 @@ export const liftEither = <A extends Array<unknown>, E, B>(
  * @since 2.0.0
  */
 export const every: {
-  <A, B extends A>(refinement: (a: A, i: number) => a is B): (self: ReadonlyArray<A>) => self is ReadonlyArray<B>
-  <A>(predicate: (a: A, i: number) => boolean): (self: ReadonlyArray<A>) => boolean
+  <A, B extends A>(
+    refinement: (a: NoInfer<A>, i: number) => a is B
+  ): (self: ReadonlyArray<A>) => self is ReadonlyArray<B>
+  <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: ReadonlyArray<A>) => boolean
   <A, B extends A>(self: ReadonlyArray<A>, refinement: (a: A, i: number) => a is B): self is ReadonlyArray<B>
   <A>(self: ReadonlyArray<A>, predicate: (a: A, i: number) => boolean): boolean
 } = dual(
@@ -1871,9 +1877,9 @@ export const every: {
  * @since 2.0.0
  */
 export const some: {
-  <B extends A, A = B>(
-    predicate: (a: A, i: number) => boolean
-  ): (self: ReadonlyArray<B>) => self is NonEmptyReadonlyArray<B>
+  <A>(
+    predicate: (a: NoInfer<A>, i: number) => boolean
+  ): (self: ReadonlyArray<A>) => self is NonEmptyReadonlyArray<A>
   <A>(self: ReadonlyArray<A>, predicate: (a: A, i: number) => boolean): self is NonEmptyReadonlyArray<A>
 } = dual(
   2,

package/src/ReadonlyRecord.ts

@@ -11,6 +11,7 @@ import type { Equivalence } from "./Equivalence.js"
 import { dual, identity } from "./Function.js"
 import type { TypeLambda } from "./HKT.js"
 import * as Option from "./Option.js"
+import type { NoInfer } from "./Types.js"
 
 /**
  * @category models
@@ -527,10 +528,12 @@ export const filterMap: {
  * @since 2.0.0
  */
 export const filter: {
-  <K extends string, A, B extends A>(refinement: (a: A, key: K) => a is B): (self: Record<K, A>) => Record<string, B>
-  <K extends string, B extends A, A = B>(
-    predicate: (A: A, key: K) => boolean
-  ): (self: Record<K, B>) => Record<string, B>
+  <K extends string, A, B extends A>(
+    refinement: (a: NoInfer<A>, key: K) => a is B
+  ): (self: Record<K, A>) => Record<string, B>
+  <K extends string, A>(
+    predicate: (A: NoInfer<A>, key: K) => boolean
+  ): (self: Record<K, A>) => Record<string, A>
   <K extends string, A, B extends A>(self: Record<K, A>, refinement: (a: A, key: K) => a is B): Record<string, B>
   <K extends string, A>(self: Record<K, A>, predicate: (a: A, key: K) => boolean): Record<string, A>
 } = dual(
@@ -709,12 +712,12 @@ export const separate: <A, B>(
  * @since 2.0.0
  */
 export const partition: {
-  <K extends string, C extends A, B extends A, A = C>(refinement: (a: A, key: K) => a is B): (
-    self: Record<K, C>
-  ) => [excluded: Record<string, Exclude<C, B>>, satisfying: Record<string, B>]
-  <K extends string, B extends A, A = B>(
-    predicate: (a: A, key: K) => boolean
-  ): (self: Record<K, B>) => [excluded: Record<string, B>, satisfying: Record<string, B>]
+  <K extends string, A, B extends A>(refinement: (a: NoInfer<A>, key: K) => a is B): (
+    self: Record<K, A>
+  ) => [excluded: Record<string, Exclude<A, B>>, satisfying: Record<string, B>]
+  <K extends string, A>(
+    predicate: (a: NoInfer<A>, key: K) => boolean
+  ): (self: Record<K, A>) => [excluded: Record<string, A>, satisfying: Record<string, A>]
   <K extends string, A, B extends A>(
     self: Record<K, A>,
     refinement: (a: A, key: K) => a is B

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,