preserve refinement types in Match.when (#4748)

Author: tim-smart

.changeset/hot-needles-film.md

@@ -0,0 +1,5 @@
+---
+"effect": patch
+---
+
+preserve refinement types in Match.when

packages/effect/dtslint/Match.tst.ts

@@ -1,5 +1,4 @@
-import type { Option } from "effect"
-import { Either, hole, Match, pipe, Predicate } from "effect"
+import { Either, hole, Match, Option, pipe, Predicate } from "effect"
 import { describe, expect, it } from "tstyche"
 
 type Value = { _tag: "A"; a: number } | { _tag: "B"; b: number }
@@ -259,7 +258,7 @@ describe("Match", () => {
         pipe(
           Match.value(hole<{ readonly a: string | Array<number> }>()),
           Match.when({ a: isArray }, (v) => {
-            expect(v).type.toBe<{ a: ReadonlyArray<number> }>()
+            expect(v).type.toBe<{ a: Array<number> }>()
             return "array"
           }),
           Match.orElse((v) => {
@@ -559,4 +558,46 @@ describe("Match", () => {
       )(value)
     ).type.toBe<string | number>()
   })
+
+  it("Option.isSome", () => {
+    expect(
+      pipe(
+        Match.type<{ maybeNumber: Option.Option<number> }>(),
+        Match.when({ maybeNumber: Option.isSome }, (v) => {
+          expect(v).type.toBe<{ maybeNumber: Option.Some<number> }>()
+          return v.maybeNumber.value
+        }),
+        Match.orElse((B) => {
+          expect(B).type.toBe<{ maybeNumber: Option.Option<number> }>()
+          return undefined
+        })
+      )({ maybeNumber: Option.some(1) })
+    ).type.toBe<number | undefined>()
+  })
+
+  it("whenOr refinement with pattern", () => {
+    class Person {
+      get contactable() {
+        return true
+      }
+    }
+    expect(
+      pipe(
+        Match.type<{ maybeNumber: Option.Option<number>; person: Person }>(),
+        Match.whenOr({
+          maybeNumber: {
+            _tag: Match.is("Some", "None")
+          },
+          person: { contactable: true }
+        }, ({ person }) => {
+          expect(person.contactable).type.toBe<true>()
+          return person.contactable
+        }),
+        Match.orElse(({ person }) => {
+          expect(person).type.toBe<Person>()
+          return false
+        })
+      )({ maybeNumber: Option.some(1), person: new Person() })
+    ).type.toBe<boolean>()
+  })
 })

packages/effect/src/Match.ts

@@ -925,7 +925,7 @@ export const not: <
   R,
   const P extends Types.PatternPrimitive<R> | Types.PatternBase<R>,
   Ret,
-  Fn extends (_: Exclude<R, Types.ExtractMatch<R, Types.PForExclude<P>>>) => Ret
+  Fn extends (_: Types.NotMatch<R, P>) => Ret
 >(
   pattern: P,
   f: Fn
@@ -956,7 +956,7 @@ export const nonEmptyString: SafeRefinement<string, never> = internal.nonEmptySt
  */
 export const is: <
   Literals extends ReadonlyArray<string | number | bigint | boolean | null>
->(...literals: Literals) => Predicate.Refinement<unknown, Literals[number]> = internal.is
+>(...literals: Literals) => SafeRefinement<Literals[number]> = internal.is
 
 /**
  * Matches values of type `string`.
@@ -1275,8 +1275,8 @@ export declare namespace Types {
    */
   export type WhenMatch<R, P> =
     // check for any
-    [0] extends [1 & R] ? PForMatch<P>
-      : P extends SafeRefinement<infer SP, never> ? SP
+    [0] extends [1 & R] ? ResolvePred<P> :
+      P extends SafeRefinement<infer SP, never> ? SP
       : P extends Predicate.Refinement<infer _R, infer RP>
       // try to narrow refinement
         ? [Extract<R, RP>] extends [infer X] ? [X] extends [never]
@@ -1285,17 +1285,20 @@ export declare namespace Types {
           : X
         : never
       : P extends PredicateA<infer PP> ? PP
-      : ExtractMatch<R, PForMatch<P>>
+      : ExtractMatch<R, P>
 
   /**
    * @since 1.0.0
    */
-  export type NotMatch<R, P> = Exclude<R, ExtractMatch<R, PForExclude<P>>>
+  export type NotMatch<R, P> = Exclude<R, ExtractMatch<R, PForNotMatch<P>>>
+
+  type PForNotMatch<P> = [ToSafeRefinement<P>] extends [infer X] ? X
+    : never
 
   /**
    * @since 1.0.0
    */
-  export type PForMatch<P> = [SafeRefinementP<ResolvePred<P>>] extends [infer X] ? X
+  export type PForMatch<P> = [ResolvePred<P>] extends [infer X] ? X
     : never
 
   /**
@@ -1307,22 +1310,16 @@ export declare namespace Types {
   // utilities
   type PredicateA<A> = Predicate.Predicate<A> | Predicate.Refinement<A, A>
 
-  type SafeRefinementP<A> = A extends never ? never
-    : A extends SafeRefinement<infer S, infer _> ? S
-    : A extends Function ? A
-    : A extends Record<string, any> ? { [K in keyof A]: SafeRefinementP<A[K]> }
-    : A
-
   type SafeRefinementR<A> = A extends never ? never
     : A extends SafeRefinement<infer _, infer R> ? R
     : A extends Function ? A
     : A extends Record<string, any> ? { [K in keyof A]: SafeRefinementR<A[K]> }
     : A
 
   type ResolvePred<A> = A extends never ? never
+    : A extends SafeRefinement<infer _A, infer _R> ? _R
     : A extends Predicate.Refinement<any, infer P> ? P
     : A extends Predicate.Predicate<infer P> ? P
-    : A extends SafeRefinement<any> ? A
     : A extends Record<string, any> ? { [K in keyof A]: ResolvePred<A[K]> }
     : A
 
@@ -1433,33 +1430,36 @@ export declare namespace Types {
 
   type Simplify<A> = { [K in keyof A]: A[K] } & {}
 
-  type ExtractAndNarrow<Input, P> =
-    // unknown is a wildcard pattern
-    unknown extends P ? Input
-      : Input extends infer I ? Exclude<
-          I extends ReadonlyArray<any> ? P extends ReadonlyArray<any> ? {
-                readonly [K in keyof I]: K extends keyof P ? ExtractAndNarrow<I[K], P[K]>
-                  : I[K]
-              } extends infer R ? Fail extends R[keyof R] ? never
-                : R
-              : never
+  type ExtractAndNarrow<Input, P> = Input extends infer I ?
+    P extends SafeRefinement<infer _In, infer _R> | Predicate.Refinement<infer _In, infer _R> ?
+      P extends SafeRefinement<I & {}, infer _R> | Predicate.Refinement<I & {}, infer _R> ?
+        [0] extends [1 & _R] ? I : _R
+      : Extract<I, _R> :
+    P extends Predicate.Predicate<infer _In> ? P extends Predicate.Predicate<I & {}> ? _In : never :
+    Exclude<
+      I extends ReadonlyArray<any> ? P extends ReadonlyArray<any> ? {
+            readonly [K in keyof I]: K extends keyof P ? ExtractAndNarrow<I[K], P[K]>
+              : I[K]
+          } extends infer R ? Fail extends R[keyof R] ? never
+            : R
+          : never
+        : never
+        : IsPlainObject<I> extends true ? string extends keyof I ? I extends P ? I
+            : never
+          : symbol extends keyof I ? I extends P ? I
             : never
-            : IsPlainObject<I> extends true ? string extends keyof I ? I extends P ? I
-                : never
-              : symbol extends keyof I ? I extends P ? I
-                : never
-              : Simplify<
-                & { [RK in Extract<keyof I, keyof P>]-?: ExtractAndNarrow<I[RK], P[RK]> }
-                & Omit<I, keyof P>
-              > extends infer R ? keyof P extends NonFailKeys<R> ? R
-                : never
-              : never
-            : MaybeReplace<I, P> extends infer R ? [I] extends [R] ? I
-              : R
-            : never,
-          Fail
-        > :
-      never
+          : Simplify<
+            & { [RK in Extract<keyof I, keyof P>]-?: ExtractAndNarrow<I[RK], P[RK]> }
+            & Omit<I, keyof P>
+          > extends infer R ? keyof P extends NonFailKeys<R> ? R
+            : never
+          : never
+        : MaybeReplace<I, P> extends infer R ? [I] extends [R] ? I
+          : R
+        : never,
+      Fail
+    > :
+    never
 
   type NonFailKeys<A> = keyof A & {} extends infer K ? K extends keyof A ? A[K] extends Fail ? never : K
     : never :

packages/effect/src/internal/matcher.ts

@@ -509,7 +509,7 @@ export const is: <
   Literals extends ReadonlyArray<string | number | boolean | null | bigint>
 >(
   ...literals: Literals
-) => Predicate.Refinement<unknown, Literals[number]> = (...literals): any => {
+) => SafeRefinement<Literals[number]> = (...literals): any => {
   const len = literals.length
   return (u: unknown) => {
     for (let i = 0; i < len; i++) {