Make Effect.liftPredicate and Either.liftPredicate reusable (#4687)

Author: KhraksMamtsov

.changeset/happy-steaks-work.md

@@ -0,0 +1,5 @@
+---
+"effect": patch
+---
+
+Modify the signatures of `Either.liftPredicate` and `Effect.predicate` to make them reusable.

packages/effect/dtslint/Effect.tst.ts

@@ -1256,7 +1256,7 @@ describe("Effect", () => {
     expect(pipe(
       primitiveNumberOrString,
       Effect.liftPredicate(Predicate.isString, (sn) => {
-        expect(sn).type.toBe<string | number>()
+        expect(sn).type.toBe<unknown>()
         return "b" as const
       })
     )).type.toBe<Effect.Effect<string, "b">>()
@@ -1265,6 +1265,15 @@ describe("Effect", () => {
       return "b" as const
     })).type.toBe<Effect.Effect<string, "b">>()
 
+    expect(Effect.liftPredicate(hole<Predicate.Refinement<string | number, number>>(), (sn) => {
+      expect(sn).type.toBe<string | number>()
+      return "b" as const
+    })).type.toBe<(a: string | number) => Effect.Effect<number, "b">>()
+    expect(Effect.liftPredicate(Predicate.isString, (sn) => {
+      expect(sn).type.toBe<unknown>()
+      return "b" as const
+    })).type.toBe<(a: unknown) => Effect.Effect<string, "b">>()
+
     expect(pipe(
       primitiveNumberOrString,
       Effect.liftPredicate(
@@ -1301,12 +1310,12 @@ describe("Effect", () => {
     expect(pipe(
       primitiveNumber,
       Effect.liftPredicate(predicateNumbersOrStrings, (n) => {
-        expect(n).type.toBe<number>()
+        expect(n).type.toBe<string | number>()
         return "b" as const
       })
     )).type.toBe<Effect.Effect<number, "b">>()
     expect(Effect.liftPredicate(primitiveNumber, predicateNumbersOrStrings, (n) => {
-      expect(n).type.toBe<number>()
+      expect(n).type.toBe<string | number>()
       return "b" as const
     })).type.toBe<Effect.Effect<number, "b">>()
 

packages/effect/dtslint/Either.tst.ts

@@ -74,6 +74,20 @@ describe("Either", () => {
     const primitiveNumber = hole<number>()
     const stringOrNumber = hole<string | number>()
     const predicateNumberOrString = hole<Predicate.Predicate<number | string>>()
+    const refinementNumberOrStringToNumber = hole<Predicate.Refinement<number | string, number>>()
+
+    expect(
+      Either.liftPredicate(predicateNumberOrString, (sn) => {
+        expect(sn).type.toBe<string | number>()
+        return "b" as const
+      })
+    ).type.toBe<(a: string | number) => Either.Either<string | number, "b">>()
+    expect(
+      Either.liftPredicate(refinementNumberOrStringToNumber, (sn) => {
+        expect(sn).type.toBe<string | number>()
+        return "b" as const
+      })
+    ).type.toBe<(a: string | number) => Either.Either<number, "b">>()
 
     expect(
       Either.liftPredicate(
@@ -121,16 +135,16 @@ describe("Either", () => {
     ).type.toBe<Either.Either<string | number, "b">>()
 
     expect(
-      Either.liftPredicate(primitiveNumber, predicateNumberOrString, (n) => {
-        expect(n).type.toBe<number>()
+      Either.liftPredicate(primitiveNumber, predicateNumberOrString, (sn) => {
+        expect(sn).type.toBe<string | number>()
         return "b" as const
       })
     ).type.toBe<Either.Either<number, "b">>()
     expect(
       pipe(
         primitiveNumber,
-        Either.liftPredicate(predicateNumberOrString, (n) => {
-          expect(n).type.toBe<number>()
+        Either.liftPredicate(predicateNumberOrString, (sn) => {
+          expect(sn).type.toBe<string | number>()
           return "b" as const
         })
       )

packages/effect/src/Effect.ts

@@ -4971,12 +4971,12 @@ export const uninterruptibleMask: <A, E, R>(
  */
 export const liftPredicate: {
   <A, B extends A, E>(
-    refinement: Refinement<NoInfer<A>, B>,
-    orFailWith: (a: NoInfer<A>) => E
+    refinement: Refinement<A, B>,
+    orFailWith: (a: A) => E
   ): (a: A) => Effect<B, E>
-  <A, E>(predicate: Predicate<NoInfer<A>>, orFailWith: (a: NoInfer<A>) => E): (a: A) => Effect<A, E>
+  <B extends A, E, A = B>(predicate: Predicate<A>, orFailWith: (a: A) => E): (a: B) => Effect<B, E>
   <A, E, B extends A>(self: A, refinement: Refinement<A, B>, orFailWith: (a: A) => E): Effect<B, E>
-  <A, E>(self: A, predicate: Predicate<NoInfer<A>>, orFailWith: (a: NoInfer<A>) => E): Effect<A, E>
+  <B extends A, E, A = B>(self: B, predicate: Predicate<A>, orFailWith: (a: A) => E): Effect<B, E>
 } = effect.liftPredicate
 
 /**

packages/effect/src/Either.ts

@@ -421,19 +421,14 @@ export const match: {
  * import { pipe, Either } from "effect"
  *
  * const isPositive = (n: number): boolean => n > 0
+ * const isPositiveEither = Either.liftPredicate(isPositive, n => `${n} is not positive`)
  *
  * assert.deepStrictEqual(
- *   pipe(
- *     1,
- *     Either.liftPredicate(isPositive, n => `${n} is not positive`)
- *   ),
+ *   isPositiveEither(1),
  *   Either.right(1)
  * )
  * assert.deepStrictEqual(
- *   pipe(
- *     0,
- *     Either.liftPredicate(isPositive, n => `${n} is not positive`)
- *   ),
+ *   isPositiveEither(0),
  *   Either.left("0 is not positive")
  * )
  * ```
@@ -442,21 +437,21 @@ export const match: {
  * @since 3.4.0
  */
 export const liftPredicate: {
-  <A, B extends A, E>(refinement: Refinement<NoInfer<A>, B>, orLeftWith: (a: NoInfer<A>) => E): (a: A) => Either<B, E>
-  <A, E>(
-    predicate: Predicate<NoInfer<A>>,
-    orLeftWith: (a: NoInfer<A>) => E
-  ): (a: A) => Either<A, E>
+  <A, B extends A, E>(refinement: Refinement<A, B>, orLeftWith: (a: A) => E): (a: A) => Either<B, E>
+  <B extends A, E, A = B>(
+    predicate: Predicate<A>,
+    orLeftWith: (a: A) => E
+  ): (a: B) => Either<B, E>
   <A, E, B extends A>(
     self: A,
     refinement: Refinement<A, B>,
     orLeftWith: (a: A) => E
   ): Either<B, E>
-  <A, E>(
-    self: A,
-    predicate: Predicate<NoInfer<A>>,
-    orLeftWith: (a: NoInfer<A>) => E
-  ): Either<A, E>
+  <B extends A, E, A = B>(
+    self: B,
+    predicate: Predicate<A>,
+    orLeftWith: (a: A) => E
+  ): Either<B, E>
 } = dual(
   3,
   <A, E>(a: A, predicate: Predicate<A>, orLeftWith: (a: A) => E): Either<A, E> =>