added a safe exhaustiveness check

src/match.ts

@@ -126,6 +126,28 @@ class MatchExpression<input, output> {
     );
   }
 
+  safeExhaustive(
+    handler: (value: input) => output,
+    handleErrorMessage?: (input: string) => unknown
+  ): output {
+    if (this.state.matched) return this.state.value;
+
+    let displayedValue;
+    try {
+      displayedValue = JSON.stringify(this.input);
+    } catch (e) {
+      displayedValue = this.input;
+    }
+    const errorMessage = `Pattern matching error: no pattern matches value ${displayedValue}`;
+    if (handleErrorMessage) {
+      handleErrorMessage(errorMessage);
+    } else {
+      console.error(errorMessage);
+    }
+
+    return handler(this.input);
+  }
+
   run(): output {
     return this.exhaustive();
   }

src/types/Match.ts

@@ -197,6 +197,23 @@ export type Match<
       : NonExhaustiveError<remainingCases>
     : never;
 
+  /**
+   * `.safeExhaustive()` checks that all cases are handled, and returns the result value, but does not throw an error.
+   *  instead you can supply a default value like you can with `.otherwise()` and also can provide an `error message handler` optionally
+   *  as a second argument
+   *
+   * [Read the documentation for `.exhaustive()` on GitHub](https://github.com/gvergnaud/ts-pattern#exhaustive)
+   *
+   * */
+  safeExhaustive: DeepExcludeAll<i, handledCases> extends infer remainingCases
+    ? [remainingCases] extends [never]
+      ? (
+          handler: (input: i) => inferredOutput,
+          errorMessageHandler?: (input: string) => unknown
+        ) => PickReturnValue<o, inferredOutput>
+      : NonExhaustiveError<remainingCases>
+    : never;
+
   /**
    * `.run()` return the resulting value.
    *

tests/safeExhaustive.test.ts

@@ -0,0 +1,52 @@
+import { match } from '../src';
+
+type Input = 1 | 2;
+
+describe('safeExhaustive', () => {
+  let consoleSpy: ReturnType<
+    ReturnType<(typeof jest)['spyOn']>['mockImplementation']
+  >;
+
+  beforeEach(() => {
+    consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  it('should not throw an error when exhaustiveness check fails', () => {
+    const getAnswer = () =>
+      match(3 as Input)
+        .with(1, () => 1)
+        .with(2, () => 2)
+        .safeExhaustive(() => 3);
+
+    expect(getAnswer).not.toThrowError();
+  });
+
+  it('should return the default value returned from the handler if no pattern matches', () => {
+    const result = match(3 as Input)
+      .with(1, () => 1)
+      .with(2, () => 2)
+      .safeExhaustive(() => 3);
+
+    expect(result).toEqual(3);
+  });
+
+  it('should run console.error if no errorMessageHandler provided', () => {
+    match(3 as Input)
+      .with(1, () => 1)
+      .with(2, () => 2)
+      .safeExhaustive(() => 3);
+
+    expect(consoleSpy).toHaveBeenCalled();
+  });
+
+  it('should run a custom handler if provided', () => {
+    const handler = jest.fn();
+
+    match(3 as Input)
+      .with(1, () => 1)
+      .with(2, () => 2)
+      .safeExhaustive(() => 3, handler);
+
+    expect(handler).toHaveBeenCalled();
+  });
+});