@praha/byethrow 0.2.0 → 0.3.0

package/dist/cjs/exports.cjs

@@ -18,6 +18,12 @@ var __webpack_modules__ = {
     "./functions/fail": function(module) {
         module.exports = require("./functions/fail.cjs");
     },
+    "./functions/inspect-error": function(module) {
+        module.exports = require("./functions/inspect-error.cjs");
+    },
+    "./functions/inspect": function(module) {
+        module.exports = require("./functions/inspect.cjs");
+    },
     "./functions/is-failure": function(module) {
         module.exports = require("./functions/is-failure.cjs");
     },
@@ -137,64 +143,76 @@ var __webpack_exports__ = {};
         return _functions_fail__WEBPACK_IMPORTED_MODULE_6__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _functions_is_failure__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__("./functions/is-failure");
+    var _functions_inspect__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__("./functions/inspect");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_inspect__WEBPACK_IMPORTED_MODULE_7__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_inspect__WEBPACK_IMPORTED_MODULE_7__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _functions_inspect_error__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__("./functions/inspect-error");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_inspect_error__WEBPACK_IMPORTED_MODULE_8__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_inspect_error__WEBPACK_IMPORTED_MODULE_8__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _functions_is_failure__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__("./functions/is-failure");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _functions_is_failure__WEBPACK_IMPORTED_MODULE_7__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _functions_is_failure__WEBPACK_IMPORTED_MODULE_7__[key];
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_is_failure__WEBPACK_IMPORTED_MODULE_9__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        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_8__ = __webpack_require__("./functions/is-success");
+    var _functions_is_success__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__("./functions/is-success");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _functions_is_success__WEBPACK_IMPORTED_MODULE_8__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _functions_is_success__WEBPACK_IMPORTED_MODULE_8__[key];
+    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];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _functions_map__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__("./functions/map");
+    var _functions_map__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__("./functions/map");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _functions_map__WEBPACK_IMPORTED_MODULE_9__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _functions_map__WEBPACK_IMPORTED_MODULE_9__[key];
+    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];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _functions_map_error__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__("./functions/map-error");
+    var _functions_map_error__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__("./functions/map-error");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _functions_map_error__WEBPACK_IMPORTED_MODULE_10__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _functions_map_error__WEBPACK_IMPORTED_MODULE_10__[key];
+    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];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _functions_or_else__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__("./functions/or-else");
+    var _functions_or_else__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__("./functions/or-else");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _functions_or_else__WEBPACK_IMPORTED_MODULE_11__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _functions_or_else__WEBPACK_IMPORTED_MODULE_11__[key];
+    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];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _functions_pipe__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__("./functions/pipe");
+    var _functions_pipe__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__("./functions/pipe");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _functions_pipe__WEBPACK_IMPORTED_MODULE_12__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _functions_pipe__WEBPACK_IMPORTED_MODULE_12__[key];
+    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];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _functions_succeed__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__("./functions/succeed");
+    var _functions_succeed__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__("./functions/succeed");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _functions_succeed__WEBPACK_IMPORTED_MODULE_13__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _functions_succeed__WEBPACK_IMPORTED_MODULE_13__[key];
+    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];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _functions_try__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__("./functions/try");
+    var _functions_try__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__("./functions/try");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _functions_try__WEBPACK_IMPORTED_MODULE_14__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _functions_try__WEBPACK_IMPORTED_MODULE_14__[key];
+    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];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _functions_unwrap__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__("./functions/unwrap");
+    var _functions_unwrap__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__("./functions/unwrap");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _functions_unwrap__WEBPACK_IMPORTED_MODULE_15__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _functions_unwrap__WEBPACK_IMPORTED_MODULE_15__[key];
+    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];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _functions_unwrap_error__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__("./functions/unwrap-error");
+    var _functions_unwrap_error__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__("./functions/unwrap-error");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _functions_unwrap_error__WEBPACK_IMPORTED_MODULE_16__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _functions_unwrap_error__WEBPACK_IMPORTED_MODULE_16__[key];
+    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];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
 })();

package/dist/cjs/exports.d.ts

@@ -5,6 +5,8 @@ export * from './functions/bind';
 export * from './functions/combine';
 export * from './functions/do';
 export * from './functions/fail';
+export * from './functions/inspect';
+export * from './functions/inspect-error';
 export * from './functions/is-failure';
 export * from './functions/is-success';
 export * from './functions/map';

package/dist/cjs/functions/and-through.cjs

@@ -32,7 +32,7 @@ const andThrough = (fn)=>(result)=>{
         const apply = (r)=>{
             if ((0, external_is_failure_cjs_namespaceObject.isFailure)(r)) return r;
             const next = fn(r.value);
-            if (next instanceof Promise) return next.then((n)=>{
+            if ((0, is_promise_cjs_namespaceObject.isPromise)(next)) return next.then((n)=>{
                 if ((0, external_is_failure_cjs_namespaceObject.isFailure)(n)) return n;
                 return r;
             });

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

@@ -0,0 +1,44 @@
+"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__, {
+    inspectError: ()=>inspectError
+});
+const external_is_failure_cjs_namespaceObject = require("./is-failure.cjs");
+const is_promise_cjs_namespaceObject = require("../internals/helpers/is-promise.cjs");
+const inspectError = (fn)=>(result)=>{
+        const apply = (r)=>{
+            if ((0, external_is_failure_cjs_namespaceObject.isFailure)(r)) fn(r.error);
+            return r;
+        };
+        return (0, is_promise_cjs_namespaceObject.isPromise)(result) ? result.then(apply) : apply(result);
+    };
+exports.inspectError = __webpack_exports__.inspectError;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "inspectError"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,42 @@
+import type { InferFailure, ResultMaybeAsync } from '../result';
+/**
+ * Executes a side effect function on the error value of a {@link Result} or {@link ResultAsync},
+ * without modifying the original result. This is useful for debugging, logging, or performing
+ * other side effects while maintaining the original value and error state.
+ *
+ * @function
+ * @typeParam R1 - The input {@link Result} or {@link ResultAsync}.
+ * @typeParam R2 - The return type of the inspection function.
+ *
+ * @example Failure Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   Result.fail('error'),
+ *   Result.inspectError((error) => console.log('Debug error:', error)),
+ * );
+ * // Console output: "Debug error: error"
+ * // Result: { type: 'Failure', error: 'error' }
+ * ```
+ *
+ * @example Success Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   Result.succeed(42),
+ *   Result.inspectError((error) => console.log('Debug error:', error)),
+ * );
+ * // No console output
+ * // Result: { type: 'Success', value: 42 }
+ * ```
+ *
+ * @see {@link pipe} - It is recommended to use this function with the {@link pipe} function for better readability and composability.
+ *
+ * @category Combinators
+ */
+export declare const inspectError: {
+    <R1 extends ResultMaybeAsync<any, any>>(fn: (a: InferFailure<R1>) => unknown): (result: R1) => R1;
+    <F extends (a: any) => unknown>(fn: F): <R1 extends ResultMaybeAsync<any, Parameters<F>[0]>>(result: R1) => R1;
+};

package/dist/cjs/functions/inspect.cjs

@@ -0,0 +1,44 @@
+"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__, {
+    inspect: ()=>inspect
+});
+const external_is_success_cjs_namespaceObject = require("./is-success.cjs");
+const is_promise_cjs_namespaceObject = require("../internals/helpers/is-promise.cjs");
+const inspect = (fn)=>(result)=>{
+        const apply = (r)=>{
+            if ((0, external_is_success_cjs_namespaceObject.isSuccess)(r)) fn(r.value);
+            return r;
+        };
+        return (0, is_promise_cjs_namespaceObject.isPromise)(result) ? result.then(apply) : apply(result);
+    };
+exports.inspect = __webpack_exports__.inspect;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "inspect"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,42 @@
+import type { InferSuccess, ResultMaybeAsync } from '../result';
+/**
+ * Executes a side effect function on the success value of a {@link Result} or {@link ResultAsync},
+ * without modifying the original result. This is useful for debugging, logging, or performing
+ * other side effects while maintaining the original value and error state.
+ *
+ * @function
+ * @typeParam R1 - The input {@link Result} or {@link ResultAsync}.
+ * @typeParam R2 - The return type of the inspection function.
+ *
+ * @example Success Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   Result.succeed(42),
+ *   Result.inspect((value) => console.log('Debug:', value)),
+ * );
+ * // Console output: "Debug: 42"
+ * // Result: { type: 'Success', value: 42 }
+ * ```
+ *
+ * @example Failure Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   Result.fail('error'),
+ *   Result.inspect((value) => console.log('Debug:', value)),
+ * );
+ * // No console output
+ * // Result: { type: 'Failure', error: 'error' }
+ * ```
+ *
+ * @see {@link pipe} - It is recommended to use this function with the {@link pipe} function for better readability and composability.
+ *
+ * @category Combinators
+ */
+export declare const inspect: {
+    <R1 extends ResultMaybeAsync<any, any>>(fn: (a: InferSuccess<R1>) => unknown): (result: R1) => R1;
+    <F extends (a: any) => unknown>(fn: F): <R1 extends ResultMaybeAsync<Parameters<F>[0], any>>(result: R1) => R1;
+};

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

@@ -27,7 +27,12 @@ __webpack_require__.d(__webpack_exports__, {
     unwrapError: ()=>unwrapError
 });
 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;
 };

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

@@ -1,31 +1,49 @@
-import type { Result } from '../result';
+import type { HasPromise } from '../internals/types/has-promise';
+import type { InferFailure, ResultMaybeAsync } from '../result';
 /**
- * Extracts the error value from a {@link Result}.
+ * Extracts the error value from a {@link Result}, {@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.
  *
  * @function
- * @typeParam E - The type of the error value.
- * @param result - The {@link Result} to unwrap the error from.
- * @returns The error value.
+ * @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}.
  *
  * @example Failure Case
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = { type: 'Failure', error: 'Something went wrong' };
- * const error = Result.unwrapError(result); // 'Something went wrong'
+ * const result: Result.Result<number, string> = Result.fail('Oops');
+ * const error = Result.unwrapError(result); // 'Oops'
  * ```
  *
  * @example Success Case
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = { type: 'Success', value: 123 };
- * const error = Result.unwrapError(result); // throws 123
+ * const result: Result.Result<number, string> = Result.succeed(100);
+ * const error = Result.unwrapError(result); // throws 100
+ * ```
+ *
+ * @example Async Failure Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result: Result.Result<number, string> = Result,fail(Promise.resolve('Oops'));
+ * const error = Result.unwrapError(result); // 'Oops'
+ * ```
+ *
+ * @example Async Success Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result: Result.Result<number, string> = Result.succeed(Promise.resolve(100));
+ * const error = Result.unwrapError(result); // throws 100
  * ```
  *
  * @category Unwraps
  */
-export declare const unwrapError: <E>(result: Result<unknown, E>) => E;
+export declare const unwrapError: <R extends ResultMaybeAsync<any, any>>(result: R) => true extends HasPromise<R> ? Promise<InferFailure<R>> : InferFailure<R>;

package/dist/cjs/functions/unwrap.cjs

@@ -27,7 +27,12 @@ __webpack_require__.d(__webpack_exports__, {
     unwrap: ()=>unwrap
 });
 const external_is_failure_cjs_namespaceObject = require("./is-failure.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;
 };

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

@@ -1,20 +1,22 @@
-import type { Result } from '../result';
+import type { HasPromise } from '../internals/types/has-promise';
+import type { InferSuccess, ResultMaybeAsync } from '../result';
 /**
- * Extracts the success value from a {@link Result}.
+ * Extracts the success value from a {@link Result}, {@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.
  *
  * @function
- * @typeParam T - The type of the success value.
- * @param result - The {@link Result} to unwrap.
- * @returns The success value.
+ * @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}.
  *
  * @example Success Case
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = { type: 'Success', value: 100 };
+ * const result: Result.Result<number, string> = Result.succeed(100);
  * const value = Result.unwrap(result); // 100
  * ```
  *
@@ -22,10 +24,26 @@ import type { Result } from '../result';
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = { type: 'Failure', error: 'Oops' };
+ * const result: Result.Result<number, string> = Result.fail('Oops');
  * const value = Result.unwrap(result); // throws 'Oops'
  * ```
  *
+ * @example Async Success Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result: Result.ResultAsync<number, string> = Result.succeed(Promise.resolve(100));
+ * const value = await Result.unwrap(result); // 100
+ * ```
+ *
+ * @example Async Failure Case
+ * ```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'
+ * ```
+ *
  * @category Unwraps
  */
-export declare const unwrap: <T>(result: Result<T, unknown>) => T;
+export declare const unwrap: <R extends ResultMaybeAsync<any, any>>(result: R) => true extends HasPromise<R> ? Promise<InferSuccess<R>> : InferSuccess<R>;

package/dist/esm/exports.d.ts

@@ -5,6 +5,8 @@ export * from './functions/bind';
 export * from './functions/combine';
 export * from './functions/do';
 export * from './functions/fail';
+export * from './functions/inspect';
+export * from './functions/inspect-error';
 export * from './functions/is-failure';
 export * from './functions/is-success';
 export * from './functions/map';

package/dist/esm/exports.js

@@ -5,6 +5,8 @@ export * from "./functions/bind.js";
 export * from "./functions/combine.js";
 export * from "./functions/do.js";
 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-success.js";
 export * from "./functions/map.js";

package/dist/esm/functions/and-through.js

@@ -4,7 +4,7 @@ const andThrough = (fn)=>(result)=>{
         const apply = (r)=>{
             if (isFailure(r)) return r;
             const next = fn(r.value);
-            if (next instanceof Promise) return next.then((n)=>{
+            if (isPromise(next)) return next.then((n)=>{
                 if (isFailure(n)) return n;
                 return r;
             });

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

@@ -0,0 +1,42 @@
+import type { InferFailure, ResultMaybeAsync } from '../result';
+/**
+ * Executes a side effect function on the error value of a {@link Result} or {@link ResultAsync},
+ * without modifying the original result. This is useful for debugging, logging, or performing
+ * other side effects while maintaining the original value and error state.
+ *
+ * @function
+ * @typeParam R1 - The input {@link Result} or {@link ResultAsync}.
+ * @typeParam R2 - The return type of the inspection function.
+ *
+ * @example Failure Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   Result.fail('error'),
+ *   Result.inspectError((error) => console.log('Debug error:', error)),
+ * );
+ * // Console output: "Debug error: error"
+ * // Result: { type: 'Failure', error: 'error' }
+ * ```
+ *
+ * @example Success Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   Result.succeed(42),
+ *   Result.inspectError((error) => console.log('Debug error:', error)),
+ * );
+ * // No console output
+ * // Result: { type: 'Success', value: 42 }
+ * ```
+ *
+ * @see {@link pipe} - It is recommended to use this function with the {@link pipe} function for better readability and composability.
+ *
+ * @category Combinators
+ */
+export declare const inspectError: {
+    <R1 extends ResultMaybeAsync<any, any>>(fn: (a: InferFailure<R1>) => unknown): (result: R1) => R1;
+    <F extends (a: any) => unknown>(fn: F): <R1 extends ResultMaybeAsync<any, Parameters<F>[0]>>(result: R1) => R1;
+};

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

@@ -0,0 +1,10 @@
+import { isFailure } from "./is-failure.js";
+import { isPromise } from "../internals/helpers/is-promise.js";
+const inspectError = (fn)=>(result)=>{
+        const apply = (r)=>{
+            if (isFailure(r)) fn(r.error);
+            return r;
+        };
+        return isPromise(result) ? result.then(apply) : apply(result);
+    };
+export { inspectError };

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

@@ -0,0 +1,42 @@
+import type { InferSuccess, ResultMaybeAsync } from '../result';
+/**
+ * Executes a side effect function on the success value of a {@link Result} or {@link ResultAsync},
+ * without modifying the original result. This is useful for debugging, logging, or performing
+ * other side effects while maintaining the original value and error state.
+ *
+ * @function
+ * @typeParam R1 - The input {@link Result} or {@link ResultAsync}.
+ * @typeParam R2 - The return type of the inspection function.
+ *
+ * @example Success Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   Result.succeed(42),
+ *   Result.inspect((value) => console.log('Debug:', value)),
+ * );
+ * // Console output: "Debug: 42"
+ * // Result: { type: 'Success', value: 42 }
+ * ```
+ *
+ * @example Failure Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   Result.fail('error'),
+ *   Result.inspect((value) => console.log('Debug:', value)),
+ * );
+ * // No console output
+ * // Result: { type: 'Failure', error: 'error' }
+ * ```
+ *
+ * @see {@link pipe} - It is recommended to use this function with the {@link pipe} function for better readability and composability.
+ *
+ * @category Combinators
+ */
+export declare const inspect: {
+    <R1 extends ResultMaybeAsync<any, any>>(fn: (a: InferSuccess<R1>) => unknown): (result: R1) => R1;
+    <F extends (a: any) => unknown>(fn: F): <R1 extends ResultMaybeAsync<Parameters<F>[0], any>>(result: R1) => R1;
+};

package/dist/esm/functions/inspect.js

@@ -0,0 +1,10 @@
+import { isSuccess } from "./is-success.js";
+import { isPromise } from "../internals/helpers/is-promise.js";
+const inspect = (fn)=>(result)=>{
+        const apply = (r)=>{
+            if (isSuccess(r)) fn(r.value);
+            return r;
+        };
+        return isPromise(result) ? result.then(apply) : apply(result);
+    };
+export { inspect };

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

@@ -1,31 +1,49 @@
-import type { Result } from '../result';
+import type { HasPromise } from '../internals/types/has-promise';
+import type { InferFailure, ResultMaybeAsync } from '../result';
 /**
- * Extracts the error value from a {@link Result}.
+ * Extracts the error value from a {@link Result}, {@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.
  *
  * @function
- * @typeParam E - The type of the error value.
- * @param result - The {@link Result} to unwrap the error from.
- * @returns The error value.
+ * @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}.
  *
  * @example Failure Case
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = { type: 'Failure', error: 'Something went wrong' };
- * const error = Result.unwrapError(result); // 'Something went wrong'
+ * const result: Result.Result<number, string> = Result.fail('Oops');
+ * const error = Result.unwrapError(result); // 'Oops'
  * ```
  *
  * @example Success Case
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = { type: 'Success', value: 123 };
- * const error = Result.unwrapError(result); // throws 123
+ * const result: Result.Result<number, string> = Result.succeed(100);
+ * const error = Result.unwrapError(result); // throws 100
+ * ```
+ *
+ * @example Async Failure Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result: Result.Result<number, string> = Result,fail(Promise.resolve('Oops'));
+ * const error = Result.unwrapError(result); // 'Oops'
+ * ```
+ *
+ * @example Async Success Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result: Result.Result<number, string> = Result.succeed(Promise.resolve(100));
+ * const error = Result.unwrapError(result); // throws 100
  * ```
  *
  * @category Unwraps
  */
-export declare const unwrapError: <E>(result: Result<unknown, E>) => E;
+export declare const unwrapError: <R extends ResultMaybeAsync<any, any>>(result: R) => true extends HasPromise<R> ? Promise<InferFailure<R>> : InferFailure<R>;

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

@@ -1,5 +1,10 @@
 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;
 };

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

@@ -1,20 +1,22 @@
-import type { Result } from '../result';
+import type { HasPromise } from '../internals/types/has-promise';
+import type { InferSuccess, ResultMaybeAsync } from '../result';
 /**
- * Extracts the success value from a {@link Result}.
+ * Extracts the success value from a {@link Result}, {@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.
  *
  * @function
- * @typeParam T - The type of the success value.
- * @param result - The {@link Result} to unwrap.
- * @returns The success value.
+ * @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}.
  *
  * @example Success Case
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = { type: 'Success', value: 100 };
+ * const result: Result.Result<number, string> = Result.succeed(100);
  * const value = Result.unwrap(result); // 100
  * ```
  *
@@ -22,10 +24,26 @@ import type { Result } from '../result';
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = { type: 'Failure', error: 'Oops' };
+ * const result: Result.Result<number, string> = Result.fail('Oops');
  * const value = Result.unwrap(result); // throws 'Oops'
  * ```
  *
+ * @example Async Success Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result: Result.ResultAsync<number, string> = Result.succeed(Promise.resolve(100));
+ * const value = await Result.unwrap(result); // 100
+ * ```
+ *
+ * @example Async Failure Case
+ * ```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'
+ * ```
+ *
  * @category Unwraps
  */
-export declare const unwrap: <T>(result: Result<T, unknown>) => T;
+export declare const unwrap: <R extends ResultMaybeAsync<any, any>>(result: R) => true extends HasPromise<R> ? Promise<InferSuccess<R>> : InferSuccess<R>;

package/dist/esm/functions/unwrap.js

@@ -1,5 +1,10 @@
 import { isFailure } from "./is-failure.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;
 };

package/package.json

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