@praha/byethrow 0.3.0 → 0.4.1

package/dist/cjs/exports.cjs

@@ -27,6 +27,9 @@ var __webpack_modules__ = {
     "./functions/is-failure": function(module) {
         module.exports = require("./functions/is-failure.cjs");
     },
+    "./functions/is-result": function(module) {
+        module.exports = require("./functions/is-result.cjs");
+    },
     "./functions/is-success": function(module) {
         module.exports = require("./functions/is-success.cjs");
     },
@@ -161,58 +164,64 @@ var __webpack_exports__ = {};
         return _functions_is_failure__WEBPACK_IMPORTED_MODULE_9__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _functions_is_success__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__("./functions/is-success");
+    var _functions_is_result__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__("./functions/is-result");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_is_result__WEBPACK_IMPORTED_MODULE_10__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_is_result__WEBPACK_IMPORTED_MODULE_10__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _functions_is_success__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__("./functions/is-success");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _functions_is_success__WEBPACK_IMPORTED_MODULE_10__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _functions_is_success__WEBPACK_IMPORTED_MODULE_10__[key];
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_is_success__WEBPACK_IMPORTED_MODULE_11__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_is_success__WEBPACK_IMPORTED_MODULE_11__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _functions_map__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__("./functions/map");
+    var _functions_map__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__("./functions/map");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _functions_map__WEBPACK_IMPORTED_MODULE_11__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _functions_map__WEBPACK_IMPORTED_MODULE_11__[key];
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_map__WEBPACK_IMPORTED_MODULE_12__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_map__WEBPACK_IMPORTED_MODULE_12__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _functions_map_error__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__("./functions/map-error");
+    var _functions_map_error__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__("./functions/map-error");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _functions_map_error__WEBPACK_IMPORTED_MODULE_12__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _functions_map_error__WEBPACK_IMPORTED_MODULE_12__[key];
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_map_error__WEBPACK_IMPORTED_MODULE_13__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_map_error__WEBPACK_IMPORTED_MODULE_13__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _functions_or_else__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__("./functions/or-else");
+    var _functions_or_else__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__("./functions/or-else");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _functions_or_else__WEBPACK_IMPORTED_MODULE_13__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _functions_or_else__WEBPACK_IMPORTED_MODULE_13__[key];
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_or_else__WEBPACK_IMPORTED_MODULE_14__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_or_else__WEBPACK_IMPORTED_MODULE_14__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _functions_pipe__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__("./functions/pipe");
+    var _functions_pipe__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__("./functions/pipe");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _functions_pipe__WEBPACK_IMPORTED_MODULE_14__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _functions_pipe__WEBPACK_IMPORTED_MODULE_14__[key];
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_pipe__WEBPACK_IMPORTED_MODULE_15__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_pipe__WEBPACK_IMPORTED_MODULE_15__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _functions_succeed__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__("./functions/succeed");
+    var _functions_succeed__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__("./functions/succeed");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _functions_succeed__WEBPACK_IMPORTED_MODULE_15__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _functions_succeed__WEBPACK_IMPORTED_MODULE_15__[key];
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_succeed__WEBPACK_IMPORTED_MODULE_16__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_succeed__WEBPACK_IMPORTED_MODULE_16__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _functions_try__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__("./functions/try");
+    var _functions_try__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__("./functions/try");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _functions_try__WEBPACK_IMPORTED_MODULE_16__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _functions_try__WEBPACK_IMPORTED_MODULE_16__[key];
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_try__WEBPACK_IMPORTED_MODULE_17__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_try__WEBPACK_IMPORTED_MODULE_17__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _functions_unwrap__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__("./functions/unwrap");
+    var _functions_unwrap__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__("./functions/unwrap");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _functions_unwrap__WEBPACK_IMPORTED_MODULE_17__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _functions_unwrap__WEBPACK_IMPORTED_MODULE_17__[key];
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_unwrap__WEBPACK_IMPORTED_MODULE_18__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_unwrap__WEBPACK_IMPORTED_MODULE_18__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _functions_unwrap_error__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__("./functions/unwrap-error");
+    var _functions_unwrap_error__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__("./functions/unwrap-error");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _functions_unwrap_error__WEBPACK_IMPORTED_MODULE_18__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _functions_unwrap_error__WEBPACK_IMPORTED_MODULE_18__[key];
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_unwrap_error__WEBPACK_IMPORTED_MODULE_19__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_unwrap_error__WEBPACK_IMPORTED_MODULE_19__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
 })();

package/dist/cjs/exports.d.ts

@@ -8,6 +8,7 @@ export * from './functions/fail';
 export * from './functions/inspect';
 export * from './functions/inspect-error';
 export * from './functions/is-failure';
+export * from './functions/is-result';
 export * from './functions/is-success';
 export * from './functions/map';
 export * from './functions/map-error';

package/dist/cjs/functions/is-result.cjs

@@ -0,0 +1,36 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    isResult: ()=>isResult
+});
+const isResult = (result)=>'object' == typeof result && null !== result && 'type' in result && ('Success' === result.type && 'value' in result || 'Failure' === result.type && 'error' in result);
+exports.isResult = __webpack_exports__.isResult;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "isResult"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/functions/is-result.d.ts

@@ -0,0 +1,24 @@
+import type { Result } from '../result';
+/**
+ * Type guard to check if a value is a {@link Result}.
+ *
+ * @function
+ * @typeParam T - The type of the success value.
+ * @typeParam E - The type of the error value.
+ * @param result - The value to check.
+ * @returns `true` if the value is a {@link Result}, otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const value: unknown = { type: 'Success', value: 42 };
+ * if (Result.isResult(value)) {
+ *   // value is now typed as Result<unknown, unknown>
+ *   console.log(value.type); // 'Success' or 'Failure'
+ * }
+ * ```
+ *
+ * @category Type Guards
+ */
+export declare const isResult: <T, E>(result: unknown) => result is Result<T, E>;

package/dist/cjs/functions/try.cjs

@@ -29,7 +29,12 @@ __webpack_require__.d(__webpack_exports__, {
 const external_fail_cjs_namespaceObject = require("./fail.cjs");
 const external_succeed_cjs_namespaceObject = require("./succeed.cjs");
 const is_promise_cjs_namespaceObject = require("../internals/helpers/is-promise.cjs");
-const try_ = (options)=>(...args)=>{
+const try_ = (options)=>{
+    if ((0, is_promise_cjs_namespaceObject.isPromise)(options.try)) {
+        if ('safe' in options && options.safe) return (0, external_succeed_cjs_namespaceObject.succeed)(options.try);
+        return options.try.then((value)=>(0, external_succeed_cjs_namespaceObject.succeed)(value), (error)=>(0, external_fail_cjs_namespaceObject.fail)(options.catch(error)));
+    }
+    return (...args)=>{
         try {
             const output = options.try(...args);
             if ((0, is_promise_cjs_namespaceObject.isPromise)(output)) {
@@ -43,6 +48,7 @@ const try_ = (options)=>(...args)=>{
             return (0, external_fail_cjs_namespaceObject.fail)(options.catch(error));
         }
     };
+};
 exports["try"] = __webpack_exports__["try"];
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "try"

package/dist/cjs/functions/try.d.ts

@@ -1,15 +1,39 @@
 import type { Result, ResultAsync } from '../result';
 /**
- * Wraps a function execution (sync or async) in a {@link Result} or {@link ResultAsync} type,
+ * Wraps a function execution (sync or async) or a Promise in a {@link Result} or {@link ResultAsync} type,
  * capturing errors and returning them in a structured way.
  *
  * You can use either a custom `catch` handler or rely on the `safe: true` option
  * to assume the function cannot throw.
  *
  * @function
- * @typeParam T - The function type to execute (sync or async).
+ * @typeParam T - The function type to execute (sync or async) or a Promise type.
  * @typeParam E - The error type to return if `catch` is used.
  *
+ * @example Promise Try-Catch
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.try({
+ *   try: fetch('/api/data'),
+ *   catch: (error) => new Error('Fetch failed', { cause: error }),
+ * });
+ *
+ * // result is ResultAsync<Response, Error>
+ * ```
+ *
+ * @example Promise Safe
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.try({
+ *   safe: true,
+ *   try: Promise.resolve('ok'),
+ * });
+ *
+ * // result is ResultAsync<string, never>
+ * ```
+ *
  * @example Sync Try-Catch
  * ```ts
  * import { Result } from '@praha/byethrow';
@@ -37,7 +61,7 @@ import type { Result, ResultAsync } from '../result';
  * const result = fn(1); // Result.Result<number, never>
  * ```
  *
- * @example Async Try-Catch
+ * @example Async Function Try-Catch
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
@@ -49,7 +73,7 @@ import type { Result, ResultAsync } from '../result';
  * const result = await fn('abc'); // Result.ResultAsync<Response, Error>
  * ```
  *
- * @example Async Safe
+ * @example Async Function Safe
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
@@ -64,6 +88,14 @@ import type { Result, ResultAsync } from '../result';
  * @category Creators
  */
 declare const try_: {
+    <T extends Promise<any>, E>(options: {
+        try: T;
+        catch: (error: unknown) => E;
+    }): ResultAsync<Awaited<T>, E>;
+    <T extends Promise<any>>(options: {
+        try: T;
+        safe: true;
+    }): ResultAsync<Awaited<T>, never>;
     <T extends (...args: readonly any[]) => Promise<any>, E>(options: {
         try: T;
         catch: (error: unknown) => E;

package/dist/cjs/functions/unwrap-error.cjs

@@ -26,15 +26,36 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     unwrapError: ()=>unwrapError
 });
+const external_is_result_cjs_namespaceObject = require("./is-result.cjs");
 const external_is_success_cjs_namespaceObject = require("./is-success.cjs");
 const is_promise_cjs_namespaceObject = require("../internals/helpers/is-promise.cjs");
-const unwrapError = (result)=>{
-    if ((0, is_promise_cjs_namespaceObject.isPromise)(result)) return result.then((r)=>{
-        if ((0, external_is_success_cjs_namespaceObject.isSuccess)(r)) throw r.value;
-        return r.error;
-    });
-    if ((0, external_is_success_cjs_namespaceObject.isSuccess)(result)) throw result.value;
-    return result.error;
+const unwrapError = (...args)=>{
+    const firstArgument = args[0];
+    if ((0, external_is_result_cjs_namespaceObject.isResult)(firstArgument) || (0, is_promise_cjs_namespaceObject.isPromise)(firstArgument)) {
+        const result = firstArgument;
+        const hasDefault = 2 === args.length;
+        const defaultValue = hasDefault ? args[1] : void 0;
+        const apply = (r)=>{
+            if ((0, external_is_success_cjs_namespaceObject.isSuccess)(r)) {
+                if (hasDefault) return defaultValue;
+                throw new Error(String(r.value));
+            }
+            return r.error;
+        };
+        return (0, is_promise_cjs_namespaceObject.isPromise)(result) ? result.then(apply) : apply(result);
+    }
+    const hasDefault = 1 === args.length;
+    const defaultValue = hasDefault ? args[0] : void 0;
+    return (result)=>{
+        const apply = (r)=>{
+            if ((0, external_is_success_cjs_namespaceObject.isSuccess)(r)) {
+                if (hasDefault) return defaultValue;
+                throw new Error(String(r.value));
+            }
+            return r.error;
+        };
+        return (0, is_promise_cjs_namespaceObject.isPromise)(result) ? result.then(apply) : apply(result);
+    };
 };
 exports.unwrapError = __webpack_exports__.unwrapError;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [

package/dist/cjs/functions/unwrap-error.d.ts

@@ -1,18 +1,15 @@
 import type { HasPromise } from '../internals/types/has-promise';
 import type { InferFailure, ResultMaybeAsync } from '../result';
 /**
- * Extracts the error value from a {@link Result}, {@link ResultAsync}.
+ * Extracts the error value from a {@link Result} or {@link ResultAsync}.
  *
- * If the result is a {@link Success}, it throws the success value (this is rare but symmetric to `unwrap`).
- * For {@link ResultAsync}, it returns a Promise that resolves to the error value or rejects with the success value.
+ * If the input is a {@link Success}, it will throw the success value or return the default value if provided.
  *
  * @function
- * @typeParam R - The type of the result to unwrap.
- * @param result - The {@link Result}, {@link ResultAsync}.
- * @returns The error value, or a Promise of the error value for async results.
- * @throws The success value if the result is a {@link Success}.
+ * @typeParam R - The input {@link Result} or {@link ResultAsync}.
+ * @typeParam T - The default value type (optional).
  *
- * @example Failure Case
+ * @example Failure Case (without default)
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
@@ -20,30 +17,35 @@ import type { InferFailure, ResultMaybeAsync } from '../result';
  * const error = Result.unwrapError(result); // 'Oops'
  * ```
  *
- * @example Success Case
+ * @example Failure Case (with default)
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = Result.succeed(100);
- * const error = Result.unwrapError(result); // throws 100
+ * const result: Result.Result<number, string> = Result.fail('Oops');
+ * const error = Result.unwrapError(result, 'default'); // 'Oops'
  * ```
  *
- * @example Async Failure Case
+ * @example Success Case (without default)
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = Result,fail(Promise.resolve('Oops'));
- * const error = Result.unwrapError(result); // 'Oops'
+ * const result: Result.Result<number, string> = Result.succeed(100);
+ * const error = Result.unwrapError(result); // throws 100
  * ```
  *
- * @example Async Success Case
+ * @example Success Case (with default)
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = Result.succeed(Promise.resolve(100));
- * const error = Result.unwrapError(result); // throws 100
+ * const result: Result.Result<number, string> = Result.succeed(100);
+ * const error = Result.unwrapError(result, 0); // 0
  * ```
  *
  * @category Unwraps
  */
-export declare const unwrapError: <R extends ResultMaybeAsync<any, any>>(result: R) => true extends HasPromise<R> ? Promise<InferFailure<R>> : InferFailure<R>;
+export declare const unwrapError: {
+    <R extends ResultMaybeAsync<any, any>>(result: R): true extends HasPromise<R> ? Promise<InferFailure<R>> : InferFailure<R>;
+    <R extends ResultMaybeAsync<any, any>, T>(result: R, defaultValue: T): true extends HasPromise<R> ? Promise<InferFailure<R> | T> : InferFailure<R> | T;
+    <R extends ResultMaybeAsync<any, any>>(): (result: R) => true extends HasPromise<R> ? Promise<InferFailure<R>> : InferFailure<R>;
+    <R extends ResultMaybeAsync<any, any>, T>(defaultValue: T): (result: R) => true extends HasPromise<R> ? Promise<InferFailure<R> | T> : InferFailure<R> | T;
+};

package/dist/cjs/functions/unwrap.cjs

@@ -27,14 +27,35 @@ __webpack_require__.d(__webpack_exports__, {
     unwrap: ()=>unwrap
 });
 const external_is_failure_cjs_namespaceObject = require("./is-failure.cjs");
+const external_is_result_cjs_namespaceObject = require("./is-result.cjs");
 const is_promise_cjs_namespaceObject = require("../internals/helpers/is-promise.cjs");
-const unwrap = (result)=>{
-    if ((0, is_promise_cjs_namespaceObject.isPromise)(result)) return result.then((r)=>{
-        if ((0, external_is_failure_cjs_namespaceObject.isFailure)(r)) throw r.error;
-        return r.value;
-    });
-    if ((0, external_is_failure_cjs_namespaceObject.isFailure)(result)) throw result.error;
-    return result.value;
+const unwrap = (...args)=>{
+    const firstArgument = args[0];
+    if ((0, external_is_result_cjs_namespaceObject.isResult)(firstArgument) || (0, is_promise_cjs_namespaceObject.isPromise)(firstArgument)) {
+        const result = firstArgument;
+        const hasDefault = 2 === args.length;
+        const defaultValue = hasDefault ? args[1] : void 0;
+        const apply = (r)=>{
+            if ((0, external_is_failure_cjs_namespaceObject.isFailure)(r)) {
+                if (hasDefault) return defaultValue;
+                throw new Error(String(r.error));
+            }
+            return r.value;
+        };
+        return (0, is_promise_cjs_namespaceObject.isPromise)(result) ? result.then(apply) : apply(result);
+    }
+    const hasDefault = 1 === args.length;
+    const defaultValue = hasDefault ? args[0] : void 0;
+    return (result)=>{
+        const apply = (r)=>{
+            if ((0, external_is_failure_cjs_namespaceObject.isFailure)(r)) {
+                if (hasDefault) return defaultValue;
+                throw new Error(String(r.error));
+            }
+            return r.value;
+        };
+        return (0, is_promise_cjs_namespaceObject.isPromise)(result) ? result.then(apply) : apply(result);
+    };
 };
 exports.unwrap = __webpack_exports__.unwrap;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [

package/dist/cjs/functions/unwrap.d.ts

@@ -1,49 +1,51 @@
 import type { HasPromise } from '../internals/types/has-promise';
 import type { InferSuccess, ResultMaybeAsync } from '../result';
 /**
- * Extracts the success value from a {@link Result}, {@link ResultAsync}.
+ * Extracts the success value from a {@link Result} or {@link ResultAsync}.
  *
- * If the result is a {@link Failure}, it throws the contained error.
- * For {@link ResultAsync}, it returns a Promise that resolves to the success value or rejects with the error.
+ * If the input is a {@link Failure}, it will throw the error or return the default value if provided.
  *
  * @function
- * @typeParam R - The type of the result to unwrap.
- * @param result - The {@link Result}, {@link ResultAsync}.
- * @returns The success value, or a Promise of the success value for async results.
- * @throws The error value if the result is a {@link Failure}.
+ * @typeParam R - The input {@link Result} or {@link ResultAsync}.
+ * @typeParam T - The default value type (optional).
  *
- * @example Success Case
+ * @example Success Case (without default)
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = Result.succeed(100);
- * const value = Result.unwrap(result); // 100
+ * const result = Result.succeed(42);
+ * const value = Result.unwrap(result); // 42
  * ```
  *
- * @example Failure Case
+ * @example Success Case (with default)
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = Result.fail('Oops');
- * const value = Result.unwrap(result); // throws 'Oops'
+ * const result = Result.succeed(42);
+ * const value = Result.unwrap(result, 0); // 42
  * ```
  *
- * @example Async Success Case
+ * @example Failure Case (without default) - throws error
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.ResultAsync<number, string> = Result.succeed(Promise.resolve(100));
- * const value = await Result.unwrap(result); // 100
+ * const result = Result.fail('error');
+ * Result.unwrap(result); // throws 'error'
  * ```
  *
- * @example Async Failure Case
+ * @example Failure Case (with default)
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.ResultAsync<number, string> = Result.fail(Promise.resolve('Oops'));
- * const value = await Result.unwrap(result); // throws 'Oops'
+ * const result = Result.fail('error');
+ * const value = Result.unwrap(result, 0); // 0
  * ```
  *
  * @category Unwraps
  */
-export declare const unwrap: <R extends ResultMaybeAsync<any, any>>(result: R) => true extends HasPromise<R> ? Promise<InferSuccess<R>> : InferSuccess<R>;
+export declare const unwrap: {
+    <R extends ResultMaybeAsync<any, any>>(result: R): true extends HasPromise<R> ? Promise<InferSuccess<R>> : InferSuccess<R>;
+    <R extends ResultMaybeAsync<any, any>, T>(result: R, defaultValue: T): true extends HasPromise<R> ? Promise<InferSuccess<R> | T> : InferSuccess<R> | T;
+    <R extends ResultMaybeAsync<any, any>>(): (result: R) => true extends HasPromise<R> ? Promise<InferSuccess<R>> : InferSuccess<R>;
+    <R extends ResultMaybeAsync<any, any>, T>(defaultValue: T): (result: R) => true extends HasPromise<R> ? Promise<InferSuccess<R> | T> : InferSuccess<R> | T;
+};

package/dist/esm/exports.d.ts

@@ -8,6 +8,7 @@ export * from './functions/fail';
 export * from './functions/inspect';
 export * from './functions/inspect-error';
 export * from './functions/is-failure';
+export * from './functions/is-result';
 export * from './functions/is-success';
 export * from './functions/map';
 export * from './functions/map-error';

package/dist/esm/exports.js

@@ -8,6 +8,7 @@ export * from "./functions/fail.js";
 export * from "./functions/inspect.js";
 export * from "./functions/inspect-error.js";
 export * from "./functions/is-failure.js";
+export * from "./functions/is-result.js";
 export * from "./functions/is-success.js";
 export * from "./functions/map.js";
 export * from "./functions/map-error.js";

package/dist/esm/functions/is-result.d.ts

@@ -0,0 +1,24 @@
+import type { Result } from '../result';
+/**
+ * Type guard to check if a value is a {@link Result}.
+ *
+ * @function
+ * @typeParam T - The type of the success value.
+ * @typeParam E - The type of the error value.
+ * @param result - The value to check.
+ * @returns `true` if the value is a {@link Result}, otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const value: unknown = { type: 'Success', value: 42 };
+ * if (Result.isResult(value)) {
+ *   // value is now typed as Result<unknown, unknown>
+ *   console.log(value.type); // 'Success' or 'Failure'
+ * }
+ * ```
+ *
+ * @category Type Guards
+ */
+export declare const isResult: <T, E>(result: unknown) => result is Result<T, E>;

package/dist/esm/functions/is-result.js

@@ -0,0 +1,2 @@
+const isResult = (result)=>'object' == typeof result && null !== result && 'type' in result && ('Success' === result.type && 'value' in result || 'Failure' === result.type && 'error' in result);
+export { isResult };

package/dist/esm/functions/try.d.ts

@@ -1,15 +1,39 @@
 import type { Result, ResultAsync } from '../result';
 /**
- * Wraps a function execution (sync or async) in a {@link Result} or {@link ResultAsync} type,
+ * Wraps a function execution (sync or async) or a Promise in a {@link Result} or {@link ResultAsync} type,
  * capturing errors and returning them in a structured way.
  *
  * You can use either a custom `catch` handler or rely on the `safe: true` option
  * to assume the function cannot throw.
  *
  * @function
- * @typeParam T - The function type to execute (sync or async).
+ * @typeParam T - The function type to execute (sync or async) or a Promise type.
  * @typeParam E - The error type to return if `catch` is used.
  *
+ * @example Promise Try-Catch
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.try({
+ *   try: fetch('/api/data'),
+ *   catch: (error) => new Error('Fetch failed', { cause: error }),
+ * });
+ *
+ * // result is ResultAsync<Response, Error>
+ * ```
+ *
+ * @example Promise Safe
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.try({
+ *   safe: true,
+ *   try: Promise.resolve('ok'),
+ * });
+ *
+ * // result is ResultAsync<string, never>
+ * ```
+ *
  * @example Sync Try-Catch
  * ```ts
  * import { Result } from '@praha/byethrow';
@@ -37,7 +61,7 @@ import type { Result, ResultAsync } from '../result';
  * const result = fn(1); // Result.Result<number, never>
  * ```
  *
- * @example Async Try-Catch
+ * @example Async Function Try-Catch
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
@@ -49,7 +73,7 @@ import type { Result, ResultAsync } from '../result';
  * const result = await fn('abc'); // Result.ResultAsync<Response, Error>
  * ```
  *
- * @example Async Safe
+ * @example Async Function Safe
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
@@ -64,6 +88,14 @@ import type { Result, ResultAsync } from '../result';
  * @category Creators
  */
 declare const try_: {
+    <T extends Promise<any>, E>(options: {
+        try: T;
+        catch: (error: unknown) => E;
+    }): ResultAsync<Awaited<T>, E>;
+    <T extends Promise<any>>(options: {
+        try: T;
+        safe: true;
+    }): ResultAsync<Awaited<T>, never>;
     <T extends (...args: readonly any[]) => Promise<any>, E>(options: {
         try: T;
         catch: (error: unknown) => E;

package/dist/esm/functions/try.js

@@ -1,7 +1,12 @@
 import { fail } from "./fail.js";
 import { succeed } from "./succeed.js";
 import { isPromise } from "../internals/helpers/is-promise.js";
-const try_ = (options)=>(...args)=>{
+const try_ = (options)=>{
+    if (isPromise(options.try)) {
+        if ('safe' in options && options.safe) return succeed(options.try);
+        return options.try.then((value)=>succeed(value), (error)=>fail(options.catch(error)));
+    }
+    return (...args)=>{
         try {
             const output = options.try(...args);
             if (isPromise(output)) {
@@ -15,4 +20,5 @@ const try_ = (options)=>(...args)=>{
             return fail(options.catch(error));
         }
     };
+};
 export { try_ as try };

package/dist/esm/functions/unwrap-error.d.ts

@@ -1,18 +1,15 @@
 import type { HasPromise } from '../internals/types/has-promise';
 import type { InferFailure, ResultMaybeAsync } from '../result';
 /**
- * Extracts the error value from a {@link Result}, {@link ResultAsync}.
+ * Extracts the error value from a {@link Result} or {@link ResultAsync}.
  *
- * If the result is a {@link Success}, it throws the success value (this is rare but symmetric to `unwrap`).
- * For {@link ResultAsync}, it returns a Promise that resolves to the error value or rejects with the success value.
+ * If the input is a {@link Success}, it will throw the success value or return the default value if provided.
  *
  * @function
- * @typeParam R - The type of the result to unwrap.
- * @param result - The {@link Result}, {@link ResultAsync}.
- * @returns The error value, or a Promise of the error value for async results.
- * @throws The success value if the result is a {@link Success}.
+ * @typeParam R - The input {@link Result} or {@link ResultAsync}.
+ * @typeParam T - The default value type (optional).
  *
- * @example Failure Case
+ * @example Failure Case (without default)
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
@@ -20,30 +17,35 @@ import type { InferFailure, ResultMaybeAsync } from '../result';
  * const error = Result.unwrapError(result); // 'Oops'
  * ```
  *
- * @example Success Case
+ * @example Failure Case (with default)
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = Result.succeed(100);
- * const error = Result.unwrapError(result); // throws 100
+ * const result: Result.Result<number, string> = Result.fail('Oops');
+ * const error = Result.unwrapError(result, 'default'); // 'Oops'
  * ```
  *
- * @example Async Failure Case
+ * @example Success Case (without default)
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = Result,fail(Promise.resolve('Oops'));
- * const error = Result.unwrapError(result); // 'Oops'
+ * const result: Result.Result<number, string> = Result.succeed(100);
+ * const error = Result.unwrapError(result); // throws 100
  * ```
  *
- * @example Async Success Case
+ * @example Success Case (with default)
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = Result.succeed(Promise.resolve(100));
- * const error = Result.unwrapError(result); // throws 100
+ * const result: Result.Result<number, string> = Result.succeed(100);
+ * const error = Result.unwrapError(result, 0); // 0
  * ```
  *
  * @category Unwraps
  */
-export declare const unwrapError: <R extends ResultMaybeAsync<any, any>>(result: R) => true extends HasPromise<R> ? Promise<InferFailure<R>> : InferFailure<R>;
+export declare const unwrapError: {
+    <R extends ResultMaybeAsync<any, any>>(result: R): true extends HasPromise<R> ? Promise<InferFailure<R>> : InferFailure<R>;
+    <R extends ResultMaybeAsync<any, any>, T>(result: R, defaultValue: T): true extends HasPromise<R> ? Promise<InferFailure<R> | T> : InferFailure<R> | T;
+    <R extends ResultMaybeAsync<any, any>>(): (result: R) => true extends HasPromise<R> ? Promise<InferFailure<R>> : InferFailure<R>;
+    <R extends ResultMaybeAsync<any, any>, T>(defaultValue: T): (result: R) => true extends HasPromise<R> ? Promise<InferFailure<R> | T> : InferFailure<R> | T;
+};

package/dist/esm/functions/unwrap-error.js

@@ -1,11 +1,32 @@
+import { isResult } from "./is-result.js";
 import { isSuccess } from "./is-success.js";
 import { isPromise } from "../internals/helpers/is-promise.js";
-const unwrapError = (result)=>{
-    if (isPromise(result)) return result.then((r)=>{
-        if (isSuccess(r)) throw r.value;
-        return r.error;
-    });
-    if (isSuccess(result)) throw result.value;
-    return result.error;
+const unwrapError = (...args)=>{
+    const firstArgument = args[0];
+    if (isResult(firstArgument) || isPromise(firstArgument)) {
+        const result = firstArgument;
+        const hasDefault = 2 === args.length;
+        const defaultValue = hasDefault ? args[1] : void 0;
+        const apply = (r)=>{
+            if (isSuccess(r)) {
+                if (hasDefault) return defaultValue;
+                throw new Error(String(r.value));
+            }
+            return r.error;
+        };
+        return isPromise(result) ? result.then(apply) : apply(result);
+    }
+    const hasDefault = 1 === args.length;
+    const defaultValue = hasDefault ? args[0] : void 0;
+    return (result)=>{
+        const apply = (r)=>{
+            if (isSuccess(r)) {
+                if (hasDefault) return defaultValue;
+                throw new Error(String(r.value));
+            }
+            return r.error;
+        };
+        return isPromise(result) ? result.then(apply) : apply(result);
+    };
 };
 export { unwrapError };

package/dist/esm/functions/unwrap.d.ts

@@ -1,49 +1,51 @@
 import type { HasPromise } from '../internals/types/has-promise';
 import type { InferSuccess, ResultMaybeAsync } from '../result';
 /**
- * Extracts the success value from a {@link Result}, {@link ResultAsync}.
+ * Extracts the success value from a {@link Result} or {@link ResultAsync}.
  *
- * If the result is a {@link Failure}, it throws the contained error.
- * For {@link ResultAsync}, it returns a Promise that resolves to the success value or rejects with the error.
+ * If the input is a {@link Failure}, it will throw the error or return the default value if provided.
  *
  * @function
- * @typeParam R - The type of the result to unwrap.
- * @param result - The {@link Result}, {@link ResultAsync}.
- * @returns The success value, or a Promise of the success value for async results.
- * @throws The error value if the result is a {@link Failure}.
+ * @typeParam R - The input {@link Result} or {@link ResultAsync}.
+ * @typeParam T - The default value type (optional).
  *
- * @example Success Case
+ * @example Success Case (without default)
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = Result.succeed(100);
- * const value = Result.unwrap(result); // 100
+ * const result = Result.succeed(42);
+ * const value = Result.unwrap(result); // 42
  * ```
  *
- * @example Failure Case
+ * @example Success Case (with default)
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = Result.fail('Oops');
- * const value = Result.unwrap(result); // throws 'Oops'
+ * const result = Result.succeed(42);
+ * const value = Result.unwrap(result, 0); // 42
  * ```
  *
- * @example Async Success Case
+ * @example Failure Case (without default) - throws error
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.ResultAsync<number, string> = Result.succeed(Promise.resolve(100));
- * const value = await Result.unwrap(result); // 100
+ * const result = Result.fail('error');
+ * Result.unwrap(result); // throws 'error'
  * ```
  *
- * @example Async Failure Case
+ * @example Failure Case (with default)
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.ResultAsync<number, string> = Result.fail(Promise.resolve('Oops'));
- * const value = await Result.unwrap(result); // throws 'Oops'
+ * const result = Result.fail('error');
+ * const value = Result.unwrap(result, 0); // 0
  * ```
  *
  * @category Unwraps
  */
-export declare const unwrap: <R extends ResultMaybeAsync<any, any>>(result: R) => true extends HasPromise<R> ? Promise<InferSuccess<R>> : InferSuccess<R>;
+export declare const unwrap: {
+    <R extends ResultMaybeAsync<any, any>>(result: R): true extends HasPromise<R> ? Promise<InferSuccess<R>> : InferSuccess<R>;
+    <R extends ResultMaybeAsync<any, any>, T>(result: R, defaultValue: T): true extends HasPromise<R> ? Promise<InferSuccess<R> | T> : InferSuccess<R> | T;
+    <R extends ResultMaybeAsync<any, any>>(): (result: R) => true extends HasPromise<R> ? Promise<InferSuccess<R>> : InferSuccess<R>;
+    <R extends ResultMaybeAsync<any, any>, T>(defaultValue: T): (result: R) => true extends HasPromise<R> ? Promise<InferSuccess<R> | T> : InferSuccess<R> | T;
+};

package/dist/esm/functions/unwrap.js

@@ -1,11 +1,32 @@
 import { isFailure } from "./is-failure.js";
+import { isResult } from "./is-result.js";
 import { isPromise } from "../internals/helpers/is-promise.js";
-const unwrap = (result)=>{
-    if (isPromise(result)) return result.then((r)=>{
-        if (isFailure(r)) throw r.error;
-        return r.value;
-    });
-    if (isFailure(result)) throw result.error;
-    return result.value;
+const unwrap = (...args)=>{
+    const firstArgument = args[0];
+    if (isResult(firstArgument) || isPromise(firstArgument)) {
+        const result = firstArgument;
+        const hasDefault = 2 === args.length;
+        const defaultValue = hasDefault ? args[1] : void 0;
+        const apply = (r)=>{
+            if (isFailure(r)) {
+                if (hasDefault) return defaultValue;
+                throw new Error(String(r.error));
+            }
+            return r.value;
+        };
+        return isPromise(result) ? result.then(apply) : apply(result);
+    }
+    const hasDefault = 1 === args.length;
+    const defaultValue = hasDefault ? args[0] : void 0;
+    return (result)=>{
+        const apply = (r)=>{
+            if (isFailure(r)) {
+                if (hasDefault) return defaultValue;
+                throw new Error(String(r.error));
+            }
+            return r.value;
+        };
+        return isPromise(result) ? result.then(apply) : apply(result);
+    };
 };
 export { unwrap };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@praha/byethrow",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "A lightweight, tree-shakable Result type package with a simple, consistent API designed",
   "keywords": [
     "javascript",
@@ -41,9 +41,9 @@
     "README.md"
   ],
   "devDependencies": {
-    "@rslib/core": "0.10.2",
-    "eslint": "9.29.0",
-    "typedoc": "0.28.5",
+    "@rslib/core": "0.10.4",
+    "eslint": "9.30.1",
+    "typedoc": "0.28.7",
     "typescript": "5.8.3",
     "vitest": "3.2.4"
   },