@praha/byethrow 0.0.1

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

@@ -0,0 +1,17 @@
+/**
+ * Alias for `succeed({})`. Commonly used as a neutral base value in functional chains or monadic pipelines.
+ *
+ * @function
+ *
+ * @example
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.do();
+ * // Result.Result<{}, never>
+ * ```
+ *
+ * @category Creators
+ */
+declare const do_: () => import("../result").Result<{}, never>;
+export { do_ as do };

package/dist/cjs/functions/fail.cjs

@@ -0,0 +1,50 @@
+"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__, {
+    fail: ()=>fail
+});
+const is_promise_cjs_namespaceObject = require("../internals/helpers/is-promise.cjs");
+const fail = (...args)=>{
+    const error = args[0];
+    if (void 0 === error) return {
+        type: 'Failure'
+    };
+    if ((0, is_promise_cjs_namespaceObject.isPromise)(error)) return error.then((error)=>({
+            type: 'Failure',
+            error: error
+        }));
+    return {
+        type: 'Failure',
+        error
+    };
+};
+exports.fail = __webpack_exports__.fail;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "fail"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,38 @@
+import type { ResultFor } from '../result';
+/**
+ * Creates a {@link Failure} result from a given error.
+ * Automatically wraps the error in a `Promise` if it is asynchronous.
+ *
+ * @function
+ * @typeParam E - The type of the error to wrap.
+ * @returns A {@link Result} or {@link ResultAsync} depending on whether the input is a promise.
+ *
+ * @example Synchronous Usage
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.fail('Something went wrong');
+ * // Result.Result<never, string>
+ * ```
+ *
+ * @example Asynchronous Usage
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.fail(Promise.resolve('Async error'));
+ * // Result.ResultAsync<never, string>
+ * ```
+ *
+ * @example With No Value
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.fail();
+ * // Result.Result<never, void>
+ * ```
+ * @category Creators
+ */
+export declare const fail: {
+    (): ResultFor<never, never, void>;
+    <E>(error: E): ResultFor<E, never, Awaited<E>>;
+};

package/dist/cjs/functions/is-failure.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__, {
+    isFailure: ()=>isFailure
+});
+const isFailure = (result)=>'Failure' === result.type;
+exports.isFailure = __webpack_exports__.isFailure;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "isFailure"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,22 @@
+import type { Failure, Result } from '../result';
+/**
+ * Type guard to check if a {@link Result} is a {@link Failure}.
+ *
+ * @function
+ * @typeParam E - The type of the error value.
+ * @param result - The {@link Result} to check.
+ * @returns `true` if the result is a {@link Failure}, otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result: Result.Result<number, string> = { type: 'Failure', error: 'Something went wrong' };
+ * if (Result.isFailure(result)) {
+ *   console.error(result.error); // Safe access to error
+ * }
+ * ```
+ *
+ * @category Type Guards
+ */
+export declare const isFailure: <E>(result: Result<unknown, E>) => result is Failure<E>;

package/dist/cjs/functions/is-success.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__, {
+    isSuccess: ()=>isSuccess
+});
+const isSuccess = (result)=>'Success' === result.type;
+exports.isSuccess = __webpack_exports__.isSuccess;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "isSuccess"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,22 @@
+import type { Result, Success } from '../result';
+/**
+ * Type guard to check if a {@link Result} is a {@link Success}.
+ *
+ * @function
+ * @typeParam T - The type of the success value.
+ * @param result - The {@link Result} to check.
+ * @returns `true` if the result is a {@link Success}, otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result: Result.Result<number, string> = { type: 'Success', value: 10 };
+ * if (Result.isSuccess(result)) {
+ *   console.log(result.value); // Safe access to value
+ * }
+ * ```
+ *
+ * @category Type Guards
+ */
+export declare const isSuccess: <T>(result: Result<T, unknown>) => result is Success<T>;

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

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

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

@@ -0,0 +1,37 @@
+import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result';
+/**
+ * Applies a transformation function to the error value of a {@link Result} or {@link ResultAsync}.
+ * If the input is a {@link Success}, it will be returned unchanged.
+ *
+ * @function
+ * @typeParam R1 - The input {@link Result} or {@link ResultAsync}.
+ * @typeParam E2 - The transformed error value type.
+ *
+ * @example Failure Case (unchanged)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   Result.fail('NotFound'),
+ *   Result.mapError((error) => new Error(error)),
+ * );
+ * // { type: 'Failure', error: Error('NotFound') }
+ * ```
+ *
+ * @example Success Case (unchanged)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   Result.succeed(123),
+ *   Result.mapError((error) => new Error(error)),
+ * );
+ * // { type: 'Success', value: 123 }
+ * ```
+ *
+ * @category Combinators
+ */
+export declare const mapError: {
+    <R1 extends ResultMaybeAsync<any, any>, E2>(fn: (a: InferFailure<R1>) => E2): (result: R1) => ResultFor<R1, InferSuccess<R1>, E2>;
+    <E1, E2>(fn: (a: E1) => E2): <R1 extends ResultMaybeAsync<any, E1>>(result: R1) => ResultFor<R1, InferSuccess<R1>, E2>;
+};

package/dist/cjs/functions/map.cjs

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

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

@@ -0,0 +1,37 @@
+import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result';
+/**
+ * Applies a transformation function to the success value of a {@link Result} or {@link ResultAsync}.
+ * If the input is a {@link Failure}, it will be returned unchanged.
+ *
+ * @function
+ * @typeParam R1 - The input {@link Result} or {@link ResultAsync}.
+ * @typeParam T2 - The transformed success value type.
+ *
+ * @example Success Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   Result.succeed(2),
+ *   Result.map((x) => x * 10),
+ * );
+ * // { type: 'Success', value: 20 }
+ * ```
+ *
+ * @example Failure Case (unchanged)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   Result.fail('error'),
+ *   Result.map((x) => x * 10),
+ * );
+ * // { type: 'Failure', error: 'error' }
+ * ```
+ *
+ * @category Combinators
+ */
+export declare const map: {
+    <R1 extends ResultMaybeAsync<any, any>, T2>(fn: (a: InferSuccess<R1>) => T2): (result: R1) => ResultFor<R1, T2, InferFailure<R1>>;
+    <T1, T2>(fn: (a: T1) => T2): <R1 extends ResultMaybeAsync<T1, any>>(result: R1) => ResultFor<R1, T2, InferFailure<R1>>;
+};

package/dist/cjs/functions/pipe.cjs

@@ -0,0 +1,40 @@
+"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__, {
+    pipe: ()=>pipe
+});
+const pipe = (value, ...functions)=>{
+    let next = value;
+    for (const func of functions)next = func(next);
+    return next;
+};
+exports.pipe = __webpack_exports__.pipe;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "pipe"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,58 @@
+/**
+ * Applies a sequence of functions to a value, from left to right.
+ *
+ * This utility enables function composition in a left-to-right manner.
+ * It supports up to 26 chained functions from `A` through `Z`.
+ *
+ * @function
+ * @typeParam A - The initial input value type.
+ * @typeParam B-Z - Intermediate and final function return types.
+ *
+ * @param value - The initial input value.
+ * @param functions - Additional unary functions composing of the previous result.
+ *
+ * @returns The final result after applying all functions.
+ *
+ * @example
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   2,
+ *   x => x + 1,
+ *   x => x * 3,
+ *   x => `Result: ${x}`
+ * );
+ * // Result: 9
+ * ```
+ *
+ * @category Utilities
+ */
+export declare const pipe: {
+    <A>(a: A): A;
+    <A, B = never>(a: A, ab: (a: A) => B): B;
+    <A, B = never, C = never>(a: A, ab: (a: A) => B, bc: (b: B) => C): C;
+    <A, B = never, C = never, D = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;
+    <A, B = never, C = never, D = never, E = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E;
+    <A, B = never, C = never, D = never, E = never, F = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): F;
+    <A, B = never, C = never, D = never, E = never, F = never, G = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): G;
+    <A, B = never, C = never, D = never, E = never, F = never, G = never, H = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H): H;
+    <A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I): I;
+    <A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J): J;
+    <A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K): K;
+    <A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L): L;
+    <A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M): M;
+    <A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N): N;
+    <A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O): O;
+    <A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P): P;
+    <A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q): Q;
+    <A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R): R;
+    <A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S): S;
+    <A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T): T;
+    <A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T, tu: (t: T) => U): U;
+    <A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never, V = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T, tu: (t: T) => U, uv: (u: U) => V): V;
+    <A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never, V = never, W = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T, tu: (t: T) => U, uv: (u: U) => V, vw: (v: V) => W): W;
+    <A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never, V = never, W = never, X = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T, tu: (t: T) => U, uv: (u: U) => V, vw: (v: V) => W, wx: (w: W) => X): X;
+    <A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never, V = never, W = never, X = never, Y = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T, tu: (t: T) => U, uv: (u: U) => V, vw: (v: V) => W, wx: (w: W) => X, xy: (x: X) => Y): Y;
+    <A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never, V = never, W = never, X = never, Y = never, Z = never>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T, tu: (t: T) => U, uv: (u: U) => V, vw: (v: V) => W, wx: (w: W) => X, xy: (x: X) => Y, yz: (y: Y) => Z): Z;
+};

package/dist/cjs/functions/succeed.cjs

@@ -0,0 +1,50 @@
+"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__, {
+    succeed: ()=>succeed
+});
+const is_promise_cjs_namespaceObject = require("../internals/helpers/is-promise.cjs");
+const succeed = (...args)=>{
+    const value = args[0];
+    if (void 0 === value) return {
+        type: 'Success'
+    };
+    if ((0, is_promise_cjs_namespaceObject.isPromise)(value)) return value.then((value)=>({
+            type: 'Success',
+            value: value
+        }));
+    return {
+        type: 'Success',
+        value
+    };
+};
+exports.succeed = __webpack_exports__.succeed;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "succeed"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,39 @@
+import type { ResultFor } from '../result';
+/**
+ * Creates a {@link Success} result from a given value.
+ * Automatically wraps the value in a `Promise` if it is asynchronous.
+ *
+ * @function
+ * @typeParam T - The type of the value to wrap.
+ * @returns A {@link Result} or {@link ResultAsync} depending on whether the input is a promise.
+ *
+ * @example Synchronous Usage
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.succeed(42);
+ * // Result.Result<number, never>
+ * ```
+ *
+ * @example Asynchronous Usage
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.succeed(Promise.resolve(42));
+ * // Result.ResultAsync<number, never>
+ * ```
+ *
+ * @example With No Value
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.succeed();
+ * // Result.Result<void, never>
+ * ```
+ *
+ * @category Creators
+ */
+export declare const succeed: {
+    (): ResultFor<never, void, never>;
+    <T>(value: T): ResultFor<T, Awaited<T>, never>;
+};

package/dist/cjs/functions/try.cjs

@@ -0,0 +1,52 @@
+"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__, {
+    try: ()=>try_
+});
+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)=>{
+        try {
+            const output = options.try(...args);
+            if ((0, is_promise_cjs_namespaceObject.isPromise)(output)) {
+                const promise = (0, external_succeed_cjs_namespaceObject.succeed)(output);
+                if ('safe' in options && options.safe) return promise;
+                return promise.catch((error)=>(0, external_fail_cjs_namespaceObject.fail)(options.catch(error)));
+            }
+            return (0, external_succeed_cjs_namespaceObject.succeed)(output);
+        } catch (error) {
+            if ('safe' in options && options.safe) throw error;
+            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"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});