@praha/byethrow 0.0.1

package/dist/esm/functions/and-then.d.ts

@@ -0,0 +1,45 @@
+import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result';
+/**
+ * Chains the next computation using the success value of a {@link Result} or {@link ResultAsync}.
+ * If the original result is a {@link Failure}, it is returned unchanged.
+ * Otherwise, the provided function is called, and its result is returned as-is.
+ *
+ * @function
+ * @typeParam R1 - The input {@link Result} or {@link ResultAsync}.
+ * @typeParam R2 - The result type returned by `fn`.
+ *
+ * @example Success Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   Result.succeed(3),
+ *   Result.andThen((x) => Result.succeed(x * 2)),
+ * );
+ * // { type: 'Success', value: 6 }
+ * ```
+ *
+ * @example Failure Case (input is a Failure)
+ * ```ts
+ * const result = Result.pipe(
+ *   Result.fail('error'),
+ *   Result.andThen((x) => Result.succeed(x * 2)),
+ * );
+ * // result: { type: 'Failure', error: 'error' }
+ * ```
+ *
+ * @example Failure Case (function returns a Failure)
+ * ```ts
+ * const result = Result.pipe(
+ *   Result.succeed(3),
+ *   Result.andThen((x) => Result.fail('error: ' + x)),
+ * );
+ * // result: { type: 'Failure', error: 'error: 3' }
+ * ```
+ *
+ * @category Combinators
+ */
+export declare const andThen: {
+    <R1 extends ResultMaybeAsync<any, any>, R2 extends ResultMaybeAsync<any, any>>(fn: (a: InferSuccess<R1>) => R2): (result: R1) => ResultFor<R1 | R2, InferSuccess<R2>, InferFailure<R1> | InferFailure<R2>>;
+    <F extends (a: any) => ResultMaybeAsync<any, any>>(fn: F): <R1 extends ResultMaybeAsync<Parameters<F>[0], any>>(result: R1) => ResultFor<R1 | ReturnType<F>, InferSuccess<F>, InferFailure<R1> | InferFailure<F>>;
+};

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

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

package/dist/esm/functions/and-through.d.ts

@@ -0,0 +1,57 @@
+import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result';
+/**
+ * Runs an additional computation using the success value of a {@link Result} or {@link ResultAsync},
+ * but **returns the original result** if the additional computation is successful.
+ *
+ * If either the original result or the side effect result is a {@link Failure}, that failure is returned.
+ * Useful for running validations or side effects without altering the main result on success.
+ *
+ * @function
+ * @typeParam R1 - The input {@link Result} or {@link ResultAsync}.
+ * @typeParam R2 - The result type returned by `fn`.
+ *
+ * @example Success Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   Result.succeed(5),
+ *   Result.andThrough((x) => {
+ *     return x > 0 ? Result.succeed(null) : Result.fail('Must be > 0');
+ *   }),
+ * );
+ * // { type: 'Success', value: 5 }
+ * ```
+ *
+ * @example Failure Case (input is a Failure)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   Result.fail('error),
+ *   Result.andThrough((x) => {
+ *     return x > 0 ? Result.succeed(null) : Result.fail('Must be > 0');
+ *   }),
+ * );
+ * // { type: 'Failure', error: 'error' }
+ * ```
+ *
+ * @example Failure Case (function returns a Failure)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   Result.succeed(-10),
+ *   Result.andThrough((x) => {
+ *     return x > 0 ? Result.succeed(null) : Result.fail('Must be > 0');
+ *   }),
+ * );
+ * // { type: 'Failure', error: 'Must be > 0' }
+ * ```
+ *
+ * @category Combinators
+ */
+export declare const andThrough: {
+    <R1 extends ResultMaybeAsync<any, any>, R2 extends ResultMaybeAsync<any, any>>(fn: (a: InferSuccess<R1>) => R2): (result: R1) => ResultFor<R1 | R2, InferSuccess<R1>, InferFailure<R1> | InferFailure<R2>>;
+    <F extends (a: any) => ResultMaybeAsync<any, any>>(fn: F): <R1 extends ResultMaybeAsync<Parameters<F>[0], any>>(result: R1) => ResultFor<R1 | ReturnType<F>, InferSuccess<R1>, InferFailure<R1> | InferFailure<F>>;
+};

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

@@ -0,0 +1,16 @@
+import { isFailure } from "./is-failure.js";
+import { isPromise } from "../internals/helpers/is-promise.js";
+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 (isFailure(n)) return n;
+                return r;
+            });
+            if (isFailure(next)) return next;
+            return r;
+        };
+        return isPromise(result) ? result.then(apply) : apply(result);
+    };
+export { andThrough };

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

@@ -0,0 +1,61 @@
+import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result';
+/**
+ * Chains another {@link Result}-producing computation and **merges its success value**
+ * into the existing object under the specified key.
+ *
+ * - If the original result is a {@link Failure}, it is returned as-is.
+ * - If the next result is a {@link Failure}, it is returned as-is.
+ * - If both are {@link Success}, a new object is returned by shallow-merging:
+ *   the original success object and `{ [name]: nextSuccess }`.
+ *
+ * This is useful for building up objects in a compositional and type-safe way,
+ * especially in validation or data-fetching pipelines.
+ *
+ * @function
+ * @typeParam N - The key to assign the result of the `fn` computation.
+ * @typeParam R1 - The input {@link Result} or {@link ResultAsync}.
+ * @typeParam R2 - The result type returned by `fn`.
+ *
+ * @example Success Case
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   Result.succeed({ name: 'Alice' }),
+ *   Result.bind('age', (user) => Result.succeed(20)),
+ * );
+ * // { type: 'Success', value: { name: 1, age: 20 } }
+ * ```
+ *
+ * @example Failure Case (input is a Failure)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   Result.fail('error'),
+ *   Result.bind('age', (user) => Result.succeed(20)),
+ * );
+ * // { type: 'Failure', error: 'error' }
+ * ```
+ *
+ * @example Failure Case (function returns a Failure)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.pipe(
+ *   Result.succeed({ name: 'Alice' }),
+ *   Result.bind('age', (user) => Result.fail('error')),
+ * );
+ * // { type: 'Failure', error: 'error' }
+ * ```
+ *
+ * @category Combinators
+ */
+export declare const bind: {
+    <N extends string, R1 extends ResultMaybeAsync<any, any>, R2 extends ResultMaybeAsync<any, any>>(name: N, fn: (a: InferSuccess<R1>) => R2): (result: R1) => InferSuccess<R1> extends object ? ResultFor<R1 | R2, {
+        [K in N | keyof InferSuccess<R1>]: K extends keyof InferSuccess<R1> ? InferSuccess<R1>[K] : InferSuccess<R2>;
+    }, InferFailure<R1> | InferFailure<R2>> : unknown;
+    <N extends string, F extends (a: any) => ResultMaybeAsync<any, any>>(name: N, fn: F): <R1 extends ResultMaybeAsync<Parameters<F>[0], any>>(result: R1) => Parameters<F>[0] extends object ? ResultFor<R1 | ReturnType<F>, {
+        [K in N | keyof Parameters<F>[0]]: K extends keyof Parameters<F>[0] ? Parameters<F>[0][K] : InferSuccess<F>;
+    }, InferFailure<R1> | InferFailure<F>> : unknown;
+};

package/dist/esm/functions/bind.js

@@ -0,0 +1,16 @@
+import { isFailure } from "./is-failure.js";
+import { succeed } from "./succeed.js";
+import { isPromise } from "../internals/helpers/is-promise.js";
+const bind = (name, fn)=>(result)=>{
+        const apply = (r)=>{
+            if (isFailure(r)) return r;
+            const fr = fn(r.value);
+            const attach = (fr)=>isFailure(fr) ? fr : succeed({
+                    ...r.value,
+                    [name]: fr.value
+                });
+            return isPromise(fr) ? fr.then(attach) : attach(fr);
+        };
+        return isPromise(result) ? result.then(apply) : apply(result);
+    };
+export { bind };

package/dist/esm/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/esm/functions/do.js

@@ -0,0 +1,3 @@
+import { succeed } from "./succeed.js";
+const do_ = ()=>succeed({});
+export { do_ as do };

package/dist/esm/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/esm/functions/fail.js

@@ -0,0 +1,16 @@
+import { isPromise } from "../internals/helpers/is-promise.js";
+const fail = (...args)=>{
+    const error = args[0];
+    if (void 0 === error) return {
+        type: 'Failure'
+    };
+    if (isPromise(error)) return error.then((error)=>({
+            type: 'Failure',
+            error: error
+        }));
+    return {
+        type: 'Failure',
+        error
+    };
+};
+export { fail };

package/dist/esm/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/esm/functions/is-failure.js

@@ -0,0 +1,2 @@
+const isFailure = (result)=>'Failure' === result.type;
+export { isFailure };

package/dist/esm/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/esm/functions/is-success.js

@@ -0,0 +1,2 @@
+const isSuccess = (result)=>'Success' === result.type;
+export { isSuccess };

package/dist/esm/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/esm/functions/map-error.js

@@ -0,0 +1,12 @@
+import { fail } from "./fail.js";
+import { isSuccess } from "./is-success.js";
+import { isPromise } from "../internals/helpers/is-promise.js";
+const mapError = (fn)=>(result)=>{
+        const apply = (r)=>{
+            if (isSuccess(r)) return r;
+            return fail(fn(r.error));
+        };
+        if (isPromise(result)) return result.then(apply);
+        return apply(result);
+    };
+export { mapError };

package/dist/esm/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/esm/functions/map.js

@@ -0,0 +1,12 @@
+import { isFailure } from "./is-failure.js";
+import { succeed } from "./succeed.js";
+import { isPromise } from "../internals/helpers/is-promise.js";
+const map = (fn)=>(result)=>{
+        const apply = (r)=>{
+            if (isFailure(r)) return r;
+            return succeed(fn(r.value));
+        };
+        if (isPromise(result)) return result.then(apply);
+        return apply(result);
+    };
+export { map };

package/dist/esm/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/esm/functions/pipe.js

@@ -0,0 +1,6 @@
+const pipe = (value, ...functions)=>{
+    let next = value;
+    for (const func of functions)next = func(next);
+    return next;
+};
+export { pipe };

package/dist/esm/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/esm/functions/succeed.js

@@ -0,0 +1,16 @@
+import { isPromise } from "../internals/helpers/is-promise.js";
+const succeed = (...args)=>{
+    const value = args[0];
+    if (void 0 === value) return {
+        type: 'Success'
+    };
+    if (isPromise(value)) return value.then((value)=>({
+            type: 'Success',
+            value: value
+        }));
+    return {
+        type: 'Success',
+        value
+    };
+};
+export { succeed };