effect 2.2.0 → 2.2.2

package/src/GroupBy.ts

@@ -7,7 +7,7 @@ import type { Predicate } from "./Predicate.js"
 import type * as Queue from "./Queue.js"
 import type * as Stream from "./Stream.js"
 import type * as Take from "./Take.js"
-import type * as Types from "./Types.js"
+import type { Covariant, NoInfer } from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -43,10 +43,10 @@ export declare namespace GroupBy {
    */
   export interface Variance<out R, out E, out K, out V> {
     readonly [GroupByTypeId]: {
-      readonly _R: Types.Covariant<R>
-      readonly _E: Types.Covariant<E>
-      readonly _K: Types.Covariant<K>
-      readonly _V: Types.Covariant<V>
+      readonly _R: Covariant<R>
+      readonly _E: Covariant<E>
+      readonly _K: Covariant<K>
+      readonly _V: Covariant<V>
     }
   }
 }
@@ -81,7 +81,7 @@ export const evaluate: {
  * @category utils
  */
 export const filter: {
-  <K>(predicate: Predicate<K>): <R, E, V>(self: GroupBy<R, E, K, V>) => GroupBy<R, E, K, V>
+  <K>(predicate: Predicate<NoInfer<K>>): <R, E, V>(self: GroupBy<R, E, K, V>) => GroupBy<R, E, K, V>
   <R, E, V, K>(self: GroupBy<R, E, K, V>, predicate: Predicate<K>): GroupBy<R, E, K, V>
 } = internal.filter
 

package/src/HashMap.ts

@@ -9,6 +9,7 @@ import * as HM from "./internal/hashMap.js"
 import * as _keySet from "./internal/hashMap/keySet.js"
 import type { Option } from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
+import type { NoInfer } from "./Types.js"
 
 const TypeId: unique symbol = HM.HashMapTypeId as TypeId
 
@@ -380,8 +381,8 @@ export const reduce: {
  * @category filtering
  */
 export const filter: {
-  <K, A, B extends A>(f: (a: A, k: K) => a is B): (self: HashMap<K, A>) => HashMap<K, B>
-  <K, B extends A, A = B>(f: (a: A, k: K) => boolean): (self: HashMap<K, B>) => HashMap<K, B>
+  <K, A, B extends A>(f: (a: NoInfer<A>, k: K) => a is B): (self: HashMap<K, A>) => HashMap<K, B>
+  <K, A>(f: (a: NoInfer<A>, k: K) => boolean): (self: HashMap<K, A>) => HashMap<K, A>
   <K, A, B extends A>(self: HashMap<K, A>, f: (a: A, k: K) => a is B): HashMap<K, B>
   <K, A>(self: HashMap<K, A>, f: (a: A, k: K) => boolean): HashMap<K, A>
 } = HM.filter
@@ -414,8 +415,8 @@ export const filterMap: {
  * @since 2.0.0
  */
 export const findFirst: {
-  <K, A, B extends A>(predicate: (a: A, k: K) => a is B): (self: HashMap<K, A>) => Option<[K, B]>
-  <K, B extends A, A = B>(predicate: (a: A, k: K) => boolean): (self: HashMap<K, B>) => Option<[K, B]>
+  <K, A, B extends A>(predicate: (a: NoInfer<A>, k: K) => a is B): (self: HashMap<K, A>) => Option<[K, B]>
+  <K, A>(predicate: (a: NoInfer<A>, k: K) => boolean): (self: HashMap<K, A>) => Option<[K, A]>
   <K, A, B extends A>(self: HashMap<K, A>, predicate: (a: A, k: K) => a is B): Option<[K, B]>
   <K, A>(self: HashMap<K, A>, predicate: (a: A, k: K) => boolean): Option<[K, A]>
 } = HM.findFirst

package/src/HashSet.ts

@@ -7,6 +7,7 @@ import type { Inspectable } from "./Inspectable.js"
 import * as HS from "./internal/hashSet.js"
 import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
+import type { NoInfer } from "./Types.js"
 
 const TypeId: unique symbol = HS.HashSetTypeId as TypeId
 
@@ -86,7 +87,7 @@ export const some: {
  * @category elements
  */
 export const every: {
-  <A, B extends A>(refinement: Refinement<A, B>): (self: HashSet<A>) => self is HashSet<B>
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: HashSet<A>) => self is HashSet<B>
   <A>(predicate: Predicate<A>): (self: HashSet<A>) => boolean
   <A, B extends A>(self: HashSet<A>, refinement: Refinement<A, B>): self is HashSet<B>
   <A>(self: HashSet<A>, predicate: Predicate<A>): boolean
@@ -271,8 +272,8 @@ export const reduce: {
  * @category filtering
  */
 export const filter: {
-  <A, B extends A>(refinement: Refinement<A, B>): (self: HashSet<A>) => HashSet<B>
-  <B extends A, A = B>(predicate: Predicate<A>): (self: HashSet<B>) => HashSet<B>
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: HashSet<A>) => HashSet<B>
+  <A>(predicate: Predicate<NoInfer<A>>): (self: HashSet<A>) => HashSet<A>
   <A, B extends A>(self: HashSet<A>, refinement: Refinement<A, B>): HashSet<B>
   <A>(self: HashSet<A>, predicate: Predicate<A>): HashSet<A>
 } = HS.filter
@@ -288,10 +289,10 @@ export const filter: {
  * @category partitioning
  */
 export const partition: {
-  <C extends A, B extends A, A = C>(
-    refinement: Refinement<A, B>
-  ): (self: HashSet<C>) => [excluded: HashSet<Exclude<C, B>>, satisfying: HashSet<B>]
-  <B extends A, A = B>(predicate: Predicate<A>): (self: HashSet<B>) => [excluded: HashSet<B>, satisfying: HashSet<B>]
+  <A, B extends A>(
+    refinement: Refinement<NoInfer<A>, B>
+  ): (self: HashSet<A>) => [excluded: HashSet<Exclude<A, B>>, satisfying: HashSet<B>]
+  <A>(predicate: Predicate<NoInfer<A>>): (self: HashSet<A>) => [excluded: HashSet<A>, satisfying: HashSet<A>]
   <A, B extends A>(
     self: HashSet<A>,
     refinement: Refinement<A, B>

package/src/List.ts

@@ -33,6 +33,7 @@ import type { Pipeable } from "./Pipeable.js"
 import { pipeArguments } from "./Pipeable.js"
 import { hasProperty, type Predicate, type Refinement } from "./Predicate.js"
 import * as ReadonlyArray from "./ReadonlyArray.js"
+import type { NoInfer } from "./Types.js"
 
 /**
  * Represents an immutable linked list of elements of type `A`.
@@ -441,7 +442,7 @@ export const drop: {
  * @category elements
  */
 export const every: {
-  <A, B extends A>(refinement: Refinement<A, B>): (self: List<A>) => self is List<B>
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: List<A>) => self is List<B>
   <A>(predicate: Predicate<A>): (self: List<A>) => boolean
   <A, B extends A>(self: List<A>, refinement: Refinement<A, B>): self is List<B>
   <A>(self: List<A>, predicate: Predicate<A>): boolean
@@ -461,7 +462,7 @@ export const every: {
  * @category elements
  */
 export const some: {
-  <B extends A, A = B>(predicate: Predicate<A>): (self: List<B>) => self is Cons<B>
+  <A>(predicate: Predicate<NoInfer<A>>): (self: List<A>) => self is Cons<A>
   <A>(self: List<A>, predicate: Predicate<A>): self is Cons<A>
 } = dual(2, <A>(self: List<A>, predicate: Predicate<A>): self is Cons<A> => {
   let these = self
@@ -481,8 +482,8 @@ export const some: {
  * @category combinators
  */
 export const filter: {
-  <A, B extends A>(refinement: Refinement<A, B>): (self: List<A>) => List<B>
-  <B extends A, A = B>(predicate: Predicate<A>): (self: List<B>) => List<B>
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: List<A>) => List<B>
+  <A>(predicate: Predicate<NoInfer<A>>): (self: List<A>) => List<A>
   <A, B extends A>(self: List<A>, refinement: Refinement<A, B>): List<B>
   <A>(self: List<A>, predicate: Predicate<A>): List<A>
 } = dual(2, <A>(self: List<A>, predicate: Predicate<A>): List<A> => noneIn(self, predicate, false))
@@ -617,8 +618,8 @@ export const compact = <A>(self: List<Option.Option<A>>): List<A> => filterMap(s
  * @since 2.0.0
  */
 export const findFirst: {
-  <A, B extends A>(refinement: Refinement<A, B>): (self: List<A>) => Option.Option<B>
-  <B extends A, A = B>(predicate: Predicate<A>): (self: List<B>) => Option.Option<B>
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: List<A>) => Option.Option<B>
+  <A>(predicate: Predicate<NoInfer<A>>): (self: List<A>) => Option.Option<A>
   <A, B extends A>(self: List<A>, refinement: Refinement<A, B>): Option.Option<B>
   <A>(self: List<A>, predicate: Predicate<A>): Option.Option<A>
 } = dual(2, <A>(self: List<A>, predicate: Predicate<A>): Option.Option<A> => {
@@ -769,10 +770,10 @@ export const map: {
  * @category combinators
  */
 export const partition: {
-  <C extends A, B extends A, A = C>(
-    refinement: Refinement<A, B>
-  ): (self: List<C>) => [excluded: List<Exclude<C, B>>, satisfying: List<B>]
-  <B extends A, A = B>(predicate: Predicate<A>): (self: List<B>) => [excluded: List<B>, satisfying: List<B>]
+  <A, B extends A>(
+    refinement: Refinement<NoInfer<A>, B>
+  ): (self: List<A>) => [excluded: List<Exclude<A, B>>, satisfying: List<B>]
+  <A>(predicate: Predicate<NoInfer<A>>): (self: List<A>) => [excluded: List<A>, satisfying: List<A>]
   <A, B extends A>(self: List<A>, refinement: Refinement<A, B>): [excluded: List<Exclude<A, B>>, satisfying: List<B>]
   <A>(self: List<A>, predicate: Predicate<A>): [excluded: List<A>, satisfying: List<A>]
 } = dual(2, <A>(self: List<A>, predicate: Predicate<A>): [excluded: List<A>, satisfying: List<A>] => {

package/src/Option.ts

@@ -15,7 +15,7 @@ import type { Order } from "./Order.js"
 import * as order from "./Order.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"
 import * as Gen from "./Utils.js"
 
@@ -45,7 +45,7 @@ export interface None<out A> extends Data.Case, Pipeable, Inspectable {
   readonly _tag: "None"
   readonly _op: "None"
   readonly [TypeId]: {
-    readonly _A: Types.Covariant<A>
+    readonly _A: Covariant<A>
   }
   [Unify.typeSymbol]?: unknown
   [Unify.unifySymbol]?: OptionUnify<this>
@@ -61,7 +61,7 @@ export interface Some<out A> extends Data.Case, Pipeable, Inspectable {
   readonly _op: "Some"
   readonly value: A
   readonly [TypeId]: {
-    readonly _A: Types.Covariant<A>
+    readonly _A: Covariant<A>
   }
   [Unify.typeSymbol]?: unknown
   [Unify.unifySymbol]?: OptionUnify<this>
@@ -983,8 +983,8 @@ export const filterMap: {
  * @since 2.0.0
  */
 export const filter: {
-  <A, B extends A>(refinement: Refinement<A, B>): (self: Option<A>) => Option<B>
-  <B extends A, A = B>(predicate: Predicate<A>): (self: Option<B>) => Option<B>
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: Option<A>) => Option<B>
+  <A>(predicate: Predicate<NoInfer<A>>): (self: Option<A>) => Option<A>
   <A, B extends A>(self: Option<A>, refinement: Refinement<A, B>): Option<B>
   <A>(self: Option<A>, predicate: Predicate<A>): Option<A>
 } = dual(
@@ -1066,7 +1066,7 @@ export const lift2 = <A, B, C>(f: (a: A, b: B) => C): {
  * @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) => Option<B>
   <B extends A, A = B>(predicate: Predicate<A>): (b: B) => Option<B>
 } = <B extends A, A = B>(predicate: Predicate<A>) => (b: B): Option<B> => predicate(b) ? some(b) : none()
@@ -1127,8 +1127,8 @@ export const contains: {
  * @since 2.0.0
  */
 export const exists: {
-  <A, B extends A>(refinement: Refinement<A, B>): (self: Option<A>) => self is Option<B>
-  <B extends A, A = B>(predicate: Predicate<A>): (self: Option<B>) => boolean
+  <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: Option<A>) => self is Option<B>
+  <A>(predicate: Predicate<NoInfer<A>>): (self: Option<A>) => boolean
   <A, B extends A>(self: Option<A>, refinement: Refinement<A, B>): self is Option<B>
   <A>(self: Option<A>, predicate: Predicate<A>): boolean
 } = dual(

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