From a047af99447dfffc729e9c8ef0ca143537927e91 Mon Sep 17 00:00:00 2001
From: Tim <hello@timsmart.co>
Date: Thu, 27 Jun 2024 14:32:13 +1200
Subject: [PATCH] fix using unions with Match.withReturnType (#3099)

---
 .changeset/brown-wasps-exist.md         |  5 ++++
 packages/effect/src/Match.ts            |  8 ++---
 packages/effect/src/internal/matcher.ts | 39 +++++++++++++------------
 packages/effect/test/Match.test.ts      | 21 +++++++++++++
 4 files changed, 50 insertions(+), 23 deletions(-)
 create mode 100644 .changeset/brown-wasps-exist.md

diff --git a/.changeset/brown-wasps-exist.md b/.changeset/brown-wasps-exist.md
new file mode 100644
index 0000000000..7e6a2dd126
--- /dev/null
+++ b/.changeset/brown-wasps-exist.md
@@ -0,0 +1,5 @@
+---
+"effect": patch
+---
+
+fix using unions with Match.withReturnType
diff --git a/packages/effect/src/Match.ts b/packages/effect/src/Match.ts
index e134cc3e5e..28c7f94f7f 100644
--- a/packages/effect/src/Match.ts
+++ b/packages/effect/src/Match.ts
@@ -140,7 +140,7 @@ export const typeTags: <I>() => <
  */
 export const withReturnType: <Ret>() => <I, F, R, A, Pr, _>(
   self: Matcher<I, F, R, A, Pr, _>
-) => Ret extends ([A] extends [never] ? any : A) ? Matcher<I, F, R, A, Pr, Ret>
+) => [Ret] extends [[A] extends [never] ? any : A] ? Matcher<I, F, R, A, Pr, Ret>
   : "withReturnType constraint does not extend Result type" = internal.withReturnType
 
 /**
@@ -496,11 +496,11 @@ export const instanceOfUnsafe: <A extends abstract new(...args: any) => any>(
  * @category conversions
  * @since 1.0.0
  */
-export const orElse: <RA, Ret, B extends Ret>(
-  f: (b: RA) => B
+export const orElse: <RA, Ret, F extends (_: RA) => Ret>(
+  f: F
 ) => <I, R, A, Pr>(
   self: Matcher<I, R, RA, A, Pr, Ret>
-) => [Pr] extends [never] ? (input: I) => Unify<B | A> : Unify<B | A> = internal.orElse
+) => [Pr] extends [never] ? (input: I) => Unify<ReturnType<F> | A> : Unify<ReturnType<F> | A> = internal.orElse
 
 /**
  * @category conversions
diff --git a/packages/effect/src/internal/matcher.ts b/packages/effect/src/internal/matcher.ts
index b9e06b8b44..3ba748ebd4 100644
--- a/packages/effect/src/internal/matcher.ts
+++ b/packages/effect/src/internal/matcher.ts
@@ -239,11 +239,11 @@ export const typeTags = <I>() =>
 }
 
 /** @internal */
-export const withReturnType =
-  <Ret>() =>
-  <I, F, R, A, Pr, _>(self: Matcher<I, F, R, A, Pr, _>): Ret extends ([A] extends [never] ? any
-    : A) ? Matcher<I, F, R, A, Pr, Ret>
-    : "withReturnType constraint does not extend Result type" => self as any
+export const withReturnType = <Ret>() =>
+<I, F, R, A, Pr, _>(self: Matcher<I, F, R, A, Pr, _>): [Ret] extends [
+  [A] extends [never] ? any : A
+] ? Matcher<I, F, R, A, Pr, Ret>
+  : "withReturnType constraint does not extend Result type" => self as any
 
 /** @internal */
 export const when = <
@@ -512,23 +512,24 @@ export const instanceOfUnsafe: <A extends abstract new(...args: any) => any>(
 ) => SafeRefinement<InstanceType<A>, InstanceType<A>> = instanceOf
 
 /** @internal */
-export const orElse = <RA, Ret, B extends Ret>(f: (b: RA) => B) =>
-<I, R, A, Pr>(
-  self: Matcher<I, R, RA, A, Pr, Ret>
-): [Pr] extends [never] ? (input: I) => Unify<A | B> : Unify<A | B> => {
-  const result = either(self)
+export const orElse =
+  <RA, Ret, F extends (_: RA) => Ret>(f: F) =>
+  <I, R, A, Pr>(self: Matcher<I, R, RA, A, Pr, Ret>): [Pr] extends [never] ? (input: I) => Unify<ReturnType<F> | A>
+    : Unify<ReturnType<F> | A> =>
+  {
+    const result = either(self)
+
+    if (Either.isEither(result)) {
+      // @ts-expect-error
+      return result._tag === "Right" ? result.right : f(result.left)
+    }
 
-  if (Either.isEither(result)) {
     // @ts-expect-error
-    return result._tag === "Right" ? result.right : f(result.left)
-  }
-
-  // @ts-expect-error
-  return (input: I) => {
-    const a = result(input)
-    return a._tag === "Right" ? a.right : f(a.left)
+    return (input: I) => {
+      const a = result(input)
+      return a._tag === "Right" ? a.right : f(a.left)
+    }
   }
-}
 
 /** @internal */
 export const orElseAbsurd = <I, R, RA, A, Pr, Ret>(
diff --git a/packages/effect/test/Match.test.ts b/packages/effect/test/Match.test.ts
index 0884aa5bd8..9f4af93743 100644
--- a/packages/effect/test/Match.test.ts
+++ b/packages/effect/test/Match.test.ts
@@ -819,4 +819,25 @@ describe("Match", () => {
       M.orElse(() => "else")
     )
   })
+
+  it("withReturnType union", () => {
+    const match = pipe(
+      M.type<string>(),
+      M.withReturnType<"a" | "b">(),
+      M.when("A", (_) => "a"),
+      M.orElse((_) => "b")
+    )
+    expect(match("A")).toEqual("a")
+    expect(match("a")).toEqual("b")
+  })
+
+  it("withReturnType union mismatch", () => {
+    pipe(
+      M.type<string>(),
+      M.withReturnType<"a" | "b">(),
+      M.when("A", (_) => "a"),
+      // @ts-expect-error
+      M.orElse((_) => "c")
+    )
+  })
 })