errore 0.4.0 → 0.5.0

package/README.md

@@ -180,11 +180,13 @@ async function processOrder(orderId: string): Promise<OrderError | Receipt> {
 // Caller gets union of all possible errors
 const receipt = await processOrder('123')
 if (isError(receipt)) {
-  matchError(receipt, {
+  const message = matchError(receipt, {
     NotFoundError: e => `Order ${e.id} not found`,
     ValidationError: e => `Invalid: ${e.field}`,
     PaymentError: e => `Payment failed: ${e.reason}`,
   })
+  console.log(message)
+  return
 }
 ```
 
@@ -229,15 +231,25 @@ class NetworkError extends TaggedError('NetworkError')<{
 type AppError = ValidationError | NetworkError
 
 // Exhaustive matching (TypeScript ensures all cases handled)
-matchError(error, {
+const message = matchError(error, {
   ValidationError: e => `Invalid ${e.field}`,
   NetworkError: e => `Failed to fetch ${e.url}`
 })
+console.log(message)
+
+// Handle plain Error with _ (underscore) handler
+function riskyOp(): ValidationError | Error { ... }
+const err = riskyOp()
+const msg = matchError(err, {
+  ValidationError: e => `Invalid ${e.field}`,
+  _: e => `Plain error: ${e.message}`  // catches non-tagged Error
+})
 
 // Partial matching with fallback
-matchErrorPartial(error, {
+const fallbackMsg = matchErrorPartial(error, {
   ValidationError: e => `Invalid ${e.field}`
 }, e => `Unknown error: ${e.message}`)
+console.log(fallbackMsg)
 
 // Type guards
 ValidationError.is(value)  // specific class

package/dist/index.d.mts

@@ -71,23 +71,34 @@ declare const TaggedError: {
  */
 declare const isTaggedError: (value: unknown) => value is AnyTaggedError;
 /**
- * Handler map for exhaustive matching
+ * Handler map that includes `_` for plain Error (untagged)
  */
-type MatchHandlers<E extends AnyTaggedError, R> = {
-    [K in E['_tag']]: (err: Extract<E, {
+type MatchHandlersWithPlain<E extends Error, R> = {
+    [K in Extract<E, AnyTaggedError>['_tag']]: (err: Extract<E, {
         _tag: K;
     }>) => R;
-};
+} & (Exclude<E, AnyTaggedError> extends never ? {} : {
+    _: (err: Exclude<E, AnyTaggedError>) => R;
+});
 /**
- * Exhaustive pattern match on tagged error union by _tag.
+ * Exhaustive pattern match on error union by _tag.
+ * Use `_` handler for plain Error instances without _tag.
  *
  * @example
+ * // Tagged errors only
  * matchError(err, {
  *   NotFoundError: (e) => `Missing: ${e.id}`,
  *   ValidationError: (e) => `Invalid: ${e.field}`,
  * });
+ *
+ * @example
+ * // Mixed tagged and plain Error
+ * matchError(err, {
+ *   NotFoundError: (e) => `Missing: ${e.id}`,
+ *   _: (e) => `Unknown error: ${e.message}`,
+ * });
  */
-declare function matchError<E extends AnyTaggedError, R>(err: E, handlers: MatchHandlers<E, R>): R;
+declare function matchError<E extends Error, R>(err: E, handlers: MatchHandlersWithPlain<E, R>): R;
 /**
  * Partial pattern match with fallback for unhandled tags.
  *
@@ -96,7 +107,7 @@ declare function matchError<E extends AnyTaggedError, R>(err: E, handlers: Match
  *   NotFoundError: (e) => `Missing: ${e.id}`,
  * }, (e) => `Unknown: ${e.message}`);
  */
-declare function matchErrorPartial<E extends AnyTaggedError, R>(err: E, handlers: Partial<MatchHandlers<E, R>>, fallback: (e: E) => R): R;
+declare function matchErrorPartial<E extends Error, R>(err: E, handlers: Partial<MatchHandlersWithPlain<E, R>>, fallback: (e: E) => R): R;
 declare const UnhandledError_base: TaggedErrorClass<"UnhandledError", {
     message: string;
     cause: unknown;

package/dist/index.d.ts

@@ -71,23 +71,34 @@ declare const TaggedError: {
  */
 declare const isTaggedError: (value: unknown) => value is AnyTaggedError;
 /**
- * Handler map for exhaustive matching
+ * Handler map that includes `_` for plain Error (untagged)
  */
-type MatchHandlers<E extends AnyTaggedError, R> = {
-    [K in E['_tag']]: (err: Extract<E, {
+type MatchHandlersWithPlain<E extends Error, R> = {
+    [K in Extract<E, AnyTaggedError>['_tag']]: (err: Extract<E, {
         _tag: K;
     }>) => R;
-};
+} & (Exclude<E, AnyTaggedError> extends never ? {} : {
+    _: (err: Exclude<E, AnyTaggedError>) => R;
+});
 /**
- * Exhaustive pattern match on tagged error union by _tag.
+ * Exhaustive pattern match on error union by _tag.
+ * Use `_` handler for plain Error instances without _tag.
  *
  * @example
+ * // Tagged errors only
  * matchError(err, {
  *   NotFoundError: (e) => `Missing: ${e.id}`,
  *   ValidationError: (e) => `Invalid: ${e.field}`,
  * });
+ *
+ * @example
+ * // Mixed tagged and plain Error
+ * matchError(err, {
+ *   NotFoundError: (e) => `Missing: ${e.id}`,
+ *   _: (e) => `Unknown error: ${e.message}`,
+ * });
  */
-declare function matchError<E extends AnyTaggedError, R>(err: E, handlers: MatchHandlers<E, R>): R;
+declare function matchError<E extends Error, R>(err: E, handlers: MatchHandlersWithPlain<E, R>): R;
 /**
  * Partial pattern match with fallback for unhandled tags.
  *
@@ -96,7 +107,7 @@ declare function matchError<E extends AnyTaggedError, R>(err: E, handlers: Match
  *   NotFoundError: (e) => `Missing: ${e.id}`,
  * }, (e) => `Unknown: ${e.message}`);
  */
-declare function matchErrorPartial<E extends AnyTaggedError, R>(err: E, handlers: Partial<MatchHandlers<E, R>>, fallback: (e: E) => R): R;
+declare function matchErrorPartial<E extends Error, R>(err: E, handlers: Partial<MatchHandlersWithPlain<E, R>>, fallback: (e: E) => R): R;
 declare const UnhandledError_base: TaggedErrorClass<"UnhandledError", {
     message: string;
     cause: unknown;

package/dist/index.js

@@ -93,13 +93,30 @@ Caused by: ${indented}`;
 );
 var isTaggedError = isAnyTaggedError;
 function matchError(err, handlers) {
-  const handler = handlers[err._tag];
-  return handler(err);
+  const h = handlers;
+  if ("_tag" in err && typeof err._tag === "string") {
+    const handler = h[err._tag];
+    if (handler) {
+      return handler(err);
+    }
+  }
+  const fallbackHandler = h["_"];
+  if (fallbackHandler) {
+    return fallbackHandler(err);
+  }
+  throw new Error(`No handler for error: ${err.message}`);
 }
 function matchErrorPartial(err, handlers, fallback) {
-  const handler = handlers[err._tag];
-  if (handler) {
-    return handler(err);
+  const h = handlers;
+  if ("_tag" in err && typeof err._tag === "string") {
+    const handler = h[err._tag];
+    if (handler) {
+      return handler(err);
+    }
+  }
+  const underscoreHandler = h["_"];
+  if (underscoreHandler) {
+    return underscoreHandler(err);
   }
   return fallback(err);
 }

package/dist/index.mjs

@@ -48,13 +48,30 @@ Caused by: ${indented}`;
 );
 var isTaggedError = isAnyTaggedError;
 function matchError(err, handlers) {
-  const handler = handlers[err._tag];
-  return handler(err);
+  const h = handlers;
+  if ("_tag" in err && typeof err._tag === "string") {
+    const handler = h[err._tag];
+    if (handler) {
+      return handler(err);
+    }
+  }
+  const fallbackHandler = h["_"];
+  if (fallbackHandler) {
+    return fallbackHandler(err);
+  }
+  throw new Error(`No handler for error: ${err.message}`);
 }
 function matchErrorPartial(err, handlers, fallback) {
-  const handler = handlers[err._tag];
-  if (handler) {
-    return handler(err);
+  const h = handlers;
+  if ("_tag" in err && typeof err._tag === "string") {
+    const handler = h[err._tag];
+    if (handler) {
+      return handler(err);
+    }
+  }
+  const underscoreHandler = h["_"];
+  if (underscoreHandler) {
+    return underscoreHandler(err);
   }
   return fallback(err);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "errore",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Type-safe errors as values for TypeScript. Like Go, but with full type inference.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",