Improve Exhaustive matching performances

src/index.ts

@@ -132,7 +132,7 @@ const builder = <a, b>(
    * that **all cases are handled**. `when` predicates
    * aren't supported on exhaustive matches.
    **/
-  exhaustive: (): ExhaustiveMatch<DistributeUnions<a>, b> =>
+  exhaustive: (): ExhaustiveMatch<DistributeUnions<a>, a, b> =>
     builder(value, patterns) as any,
 });
 

src/types/Match.ts

@@ -116,7 +116,7 @@ export type EmptyMatch<i, o> = Match<i, o> & {
    * that **all cases are handled**. `when` predicates
    * aren't supported on exhaustive matches.
    **/
-  exhaustive: () => ExhaustiveMatch<DistributeUnions<i>, o>;
+  exhaustive: () => ExhaustiveMatch<DistributeUnions<i>, i, o>;
 };
 
 type NonExhaustivePattern<i> = { __nonExhaustive: never } & i;
@@ -125,7 +125,7 @@ type NonExhaustivePattern<i> = { __nonExhaustive: never } & i;
  * ### ExhaustiveMatch
  * An interface to create an exhaustive pattern matching clause.
  */
-export type ExhaustiveMatch<i, o> = {
+export type ExhaustiveMatch<distributedInput, i, o> = {
   /**
    * ### Match.with
    * If the data matches the pattern provided as first argument,
@@ -138,7 +138,12 @@ export type ExhaustiveMatch<i, o> = {
       selections: ExtractSelections<i, p>
     ) => PickReturnValue<o, c>
   ): ExhaustiveMatch<
-    Exclude<i, ExtractPreciseValue<i, InvertPattern<p>>>,
+    // For performances, we pass both the original input and
+    // the distributedInput to ExhaustiveMatch, so we can compute the pattern
+    // from the original input, which is much faster than computing it
+    // from the distributed one.
+    Exclude<distributedInput, ExtractPreciseValue<i, InvertPattern<p>>>,
+    i,
     PickReturnValue<o, c>
   >;
 
@@ -159,5 +164,7 @@ export type ExhaustiveMatch<i, o> = {
    * every cases, and you should probably add a  another `.with(...)` clause
    * to prevent potential runtime errors.
    * */
-  run: [i] extends [never] ? () => o : NonExhaustivePattern<i>;
+  run: [distributedInput] extends [never]
+    ? () => o
+    : NonExhaustivePattern<distributedInput>;
 };

tests/exhaustive-match.test.ts

@@ -45,9 +45,7 @@ describe('exhaustive()', () => {
         .exhaustive()
         .with('a', (x) => 1)
         .with('b', (x) => 1)
-        // twice the same match.exhaustive()
         // @ts-expect-error
-        .with('b', (x) => 1)
         .run();
 
       match(input)
@@ -97,9 +95,7 @@ describe('exhaustive()', () => {
         .exhaustive()
         .with(1, (x) => 1)
         .with(2, () => 3)
-        // twice the same match.exhaustive()
         // @ts-expect-error
-        .with(2, () => 3)
         .run();
 
       match(input)
@@ -515,12 +511,35 @@ describe('exhaustive()', () => {
     });
 
     it('should work with generics', () => {
-      const f = <a>(xs: a[]) =>
+      const last = <a>(xs: a[]) =>
         match<a[], Option<a>>(xs)
           .exhaustive()
           .with([], () => none)
           .with(__, (xs) => some(xs[xs.length - 1]))
           .run();
+
+      expect(last([1, 2, 3])).toEqual(some(3));
+    });
+
+    it('should work with inputs of varying shapes', () => {
+      type Input = { type: 'test' } | ['hello', Option<string>] | 'hello'[];
+      type Output = ['hello', Option<string>];
+      const input = { type: 'test' } as Input;
+
+      const output = match(input)
+        .exhaustive()
+        .with(
+          ['hello', { kind: 'some' }],
+          (x): Output => {
+            return x;
+          }
+        )
+        .with(['hello'], (x) => {
+          return ['hello', none];
+        })
+        .with({ type: __ }, () => ['hello', none])
+        .with([__], () => ['hello', none])
+        .run();
     });
   });
 });