@praha/byethrow 0.6.3 → 0.7.0

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

@@ -21,6 +21,8 @@ import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '..
  *
  * @example Failure Case (input is a Failure)
  * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
  * const result = Result.pipe(
  *   Result.fail('error'),
  *   Result.andThen((x) => Result.succeed(x * 2)),
@@ -30,6 +32,8 @@ import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '..
  *
  * @example Failure Case (function returns a Failure)
  * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
  * const result = Result.pipe(
  *   Result.succeed(3),
  *   Result.andThen((x) => Result.fail('error: ' + x)),

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

@@ -28,7 +28,7 @@ import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '..
  * import { Result } from '@praha/byethrow';
  *
  * const result = Result.pipe(
- *   Result.fail('error),
+ *   Result.fail('error'),
  *   Result.andThrough((x) => {
  *     return x > 0 ? Result.succeed(null) : Result.fail('Must be > 0');
  *   }),

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

@@ -13,16 +13,17 @@ import type { Failure, InferFailure, Result, ResultAsync } from '../result';
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = Result.fail('error');
+ * const result = Result.fail('error');
  * const failure = Result.assertFailure(result);
  * // failure: { type: 'Failure', error: 'error' }
  * ```
  *
  * @example Throws on Success
  * ```ts
+ * // @errors: 2769
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = Result.succeed(42);
+ * const result = Result.succeed(42);
  * Result.assertFailure(result); // throws Error
  * ```
  *
@@ -30,9 +31,9 @@ import type { Failure, InferFailure, Result, ResultAsync } from '../result';
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = getResult();
+ * const getResult = (): Result.Result<number, string> => Result.fail('error');
  * const value = Result.pipe(
- *   result,
+ *   getResult(),
  *   Result.andThen(() => Result.fail('die')),
  *   Result.assertFailure,
  *   Result.unwrapError(), // Safe unwrap after assertion

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

@@ -13,16 +13,17 @@ import type { InferSuccess, Result, ResultAsync, Success } from '../result';
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = Result.succeed(42);
+ * const result = Result.succeed(42);
  * const success = Result.assertSuccess(result);
  * // success: { type: 'Success', value: 42 }
  * ```
  *
  * @example Throws on Failure
  * ```ts
+ * // @errors: 2769
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = Result.fail('error');
+ * const result = Result.fail('error');
  * Result.assertSuccess(result); // throws Error
  * ```
  *
@@ -30,9 +31,9 @@ import type { InferSuccess, Result, ResultAsync, Success } from '../result';
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<string, string> = getResult();
+ * const getResult = (): Result.Result<number, string> => Result.succeed(42);
  * const value = Result.pipe(
- *   result,
+ *   getResult(),
  *   Result.orElse(() => Result.succeed('fallback')),
  *   Result.assertSuccess,
  *   Result.unwrap(), // Safe unwrap after assertion

package/dist/cjs/functions/or-else.d.ts

@@ -21,6 +21,8 @@ import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '..
  *
  * @example Failure Case (function returns a Success)
  * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
  * const result = Result.pipe(
  *   Result.fail('original error'),
  *   Result.orElse((error) => Result.succeed('default value')),
@@ -30,6 +32,8 @@ import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '..
  *
  * @example Failure Case (function returns a Failure)
  * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
  * const result = Result.pipe(
  *   Result.fail('original error'),
  *   Result.orElse((error) => Result.fail('new error: ' + error)),

package/dist/cjs/functions/try.cjs

@@ -30,11 +30,7 @@ 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)=>{
-    if ((0, is_promise_cjs_namespaceObject.isPromise)(options.try)) {
-        if ('safe' in options && options.safe) return (0, external_succeed_cjs_namespaceObject.succeed)(options.try);
-        return options.try.then((value)=>(0, external_succeed_cjs_namespaceObject.succeed)(value), (error)=>(0, external_fail_cjs_namespaceObject.fail)(options.catch(error)));
-    }
-    return (...args)=>{
+    const fn = (...args)=>{
         try {
             const output = options.try(...args);
             if ((0, is_promise_cjs_namespaceObject.isPromise)(output)) {
@@ -48,6 +44,8 @@ const try_ = (options)=>{
             return (0, external_fail_cjs_namespaceObject.fail)(options.catch(error));
         }
     };
+    if ('immediate' in options && options.immediate) return fn();
+    return fn;
 };
 exports["try"] = __webpack_exports__["try"];
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [

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

@@ -10,58 +10,64 @@ import type { Result, ResultAsync } from '../result';
  * @typeParam T - The function type to execute (sync or async) or a Promise type.
  * @typeParam E - The error type to return if `catch` is used.
  *
- * @example Promise Try-Catch
+ * @example Sync try-catch
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result = Result.try({
- *   try: fetch('/api/data'),
- *   catch: (error) => new Error('Fetch failed', { cause: error }),
+ * const fn = Result.try({
+ *   try: (x: number) => {
+ *     if (x < 0) throw new Error('Negative!');
+ *     return x * 2;
+ *   },
+ *   catch: (error) => new Error('Oops!', { cause: error }),
  * });
  *
- * // result is ResultAsync<Response, Error>
+ * const result = fn(5); // Result.Result<number, Error>
  * ```
  *
- * @example Promise Safe
+ * @example Sync try-catch with immediate execution
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
  * const result = Result.try({
- *   safe: true,
- *   try: Promise.resolve('ok'),
+ *   immediate: true,
+ *   try: () => {
+ *     const x = Math.random() * 10 - 5;
+ *     if (x < 0) throw new Error('Negative!');
+ *     return x * 2;
+ *   },
+ *   catch: (error) => new Error('Oops!', { cause: error }),
  * });
  *
- * // result is ResultAsync<string, never>
+ * // result is Result<number, Error>
  * ```
  *
- * @example Sync Try-Catch
+ * @example Sync safe
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
  * const fn = Result.try({
- *   try: (x: number) => {
- *     if (x < 0) throw new Error('Negative!');
- *     return x * 2;
- *   },
- *   catch: (error) => new Error('Oops!', { cause: error }),
+ *   safe: true,
+ *   try: (x: number) => x + 1,
  * });
  *
- * const result = fn(5); // Result.Result<number, Error>
+ * const result = fn(1); // Result.Result<number, never>
  * ```
  *
- * @example Sync Safe
+ * @example Sync safe with immediate execution
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const fn = Result.try({
+ * const result = Result.try({
  *   safe: true,
- *   try: (x: number) => x + 1,
+ *   immediate: true,
+ *   try: () => Math.random() + 1,
  * });
  *
- * const result = fn(1); // Result.Result<number, never>
+ * // result is Result<number, never>
  * ```
  *
- * @example Async Function Try-Catch
+ * @example Async try-catch
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
@@ -73,7 +79,20 @@ import type { Result, ResultAsync } from '../result';
  * const result = await fn('abc'); // Result.ResultAsync<Response, Error>
  * ```
  *
- * @example Async Function Safe
+ * @example Async try-catch with immediate execution
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.try({
+ *   immediate: true,
+ *   try: () => fetch('/api/data'),
+ *   catch: (error) => new Error('Fetch failed', { cause: error }),
+ * });
+ *
+ * // result is ResultAsync<Response, Error>
+ * ```
+ *
+ * @example Async safe
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
@@ -85,32 +104,57 @@ import type { Result, ResultAsync } from '../result';
  * const result = await fn(); // Result.ResultAsync<string, never>
  * ```
  *
+ * @example Async safe with immediate execution
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.try({
+ *   safe: true,
+ *   immediate: true,
+ *   try: () => Promise.resolve('ok'),
+ * });
+ *
+ * // result is ResultAsync<string, never>
+ * ```
+ *
  * @category Creators
  */
 declare const try_: {
-    <T extends Promise<any>, E>(options: {
-        try: T;
-        catch: (error: unknown) => E;
-    }): ResultAsync<Awaited<T>, E>;
-    <T extends Promise<any>>(options: {
-        try: T;
-        safe: true;
-    }): ResultAsync<Awaited<T>, never>;
     <T extends (...args: readonly any[]) => Promise<any>, E>(options: {
         try: T;
         catch: (error: unknown) => E;
     }): (...args: Parameters<T>) => ResultAsync<Awaited<ReturnType<T>>, E>;
-    <T extends (...args: readonly any[]) => Promise<any>>(options: {
+    <T extends () => Promise<any>, E>(options: {
+        immediate: true;
         try: T;
+        catch: (error: unknown) => E;
+    }): ResultAsync<Awaited<ReturnType<T>>, E>;
+    <T extends (...args: readonly any[]) => Promise<any>>(options: {
         safe: true;
+        try: T;
     }): (...args: Parameters<T>) => ResultAsync<Awaited<ReturnType<T>>, never>;
+    <T extends () => Promise<any>>(options: {
+        safe: true;
+        immediate: true;
+        try: T;
+    }): ResultAsync<Awaited<ReturnType<T>>, never>;
     <T extends (...args: readonly any[]) => any, E>(options: {
         try: T;
         catch: (error: unknown) => E;
     }): (...args: Parameters<T>) => Result<ReturnType<T>, E>;
-    <T extends (...args: readonly any[]) => any>(options: {
+    <T extends () => any, E>(options: {
+        immediate: true;
         try: T;
+        catch: (error: unknown) => E;
+    }): Result<ReturnType<T>, E>;
+    <T extends (...args: readonly any[]) => any>(options: {
         safe: true;
+        try: T;
     }): (...args: Parameters<T>) => Result<ReturnType<T>, never>;
+    <T extends () => any>(options: {
+        safe: true;
+        immediate: true;
+        try: T;
+    }): Result<ReturnType<T>, never>;
 };
 export { try_ as try };

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

@@ -21,6 +21,8 @@ import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '..
  *
  * @example Failure Case (input is a Failure)
  * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
  * const result = Result.pipe(
  *   Result.fail('error'),
  *   Result.andThen((x) => Result.succeed(x * 2)),
@@ -30,6 +32,8 @@ import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '..
  *
  * @example Failure Case (function returns a Failure)
  * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
  * const result = Result.pipe(
  *   Result.succeed(3),
  *   Result.andThen((x) => Result.fail('error: ' + x)),

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

@@ -28,7 +28,7 @@ import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '..
  * import { Result } from '@praha/byethrow';
  *
  * const result = Result.pipe(
- *   Result.fail('error),
+ *   Result.fail('error'),
  *   Result.andThrough((x) => {
  *     return x > 0 ? Result.succeed(null) : Result.fail('Must be > 0');
  *   }),

package/dist/esm/functions/assert-failure.d.ts

@@ -13,16 +13,17 @@ import type { Failure, InferFailure, Result, ResultAsync } from '../result';
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = Result.fail('error');
+ * const result = Result.fail('error');
  * const failure = Result.assertFailure(result);
  * // failure: { type: 'Failure', error: 'error' }
  * ```
  *
  * @example Throws on Success
  * ```ts
+ * // @errors: 2769
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = Result.succeed(42);
+ * const result = Result.succeed(42);
  * Result.assertFailure(result); // throws Error
  * ```
  *
@@ -30,9 +31,9 @@ import type { Failure, InferFailure, Result, ResultAsync } from '../result';
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = getResult();
+ * const getResult = (): Result.Result<number, string> => Result.fail('error');
  * const value = Result.pipe(
- *   result,
+ *   getResult(),
  *   Result.andThen(() => Result.fail('die')),
  *   Result.assertFailure,
  *   Result.unwrapError(), // Safe unwrap after assertion

package/dist/esm/functions/assert-success.d.ts

@@ -13,16 +13,17 @@ import type { InferSuccess, Result, ResultAsync, Success } from '../result';
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = Result.succeed(42);
+ * const result = Result.succeed(42);
  * const success = Result.assertSuccess(result);
  * // success: { type: 'Success', value: 42 }
  * ```
  *
  * @example Throws on Failure
  * ```ts
+ * // @errors: 2769
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<number, string> = Result.fail('error');
+ * const result = Result.fail('error');
  * Result.assertSuccess(result); // throws Error
  * ```
  *
@@ -30,9 +31,9 @@ import type { InferSuccess, Result, ResultAsync, Success } from '../result';
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result: Result.Result<string, string> = getResult();
+ * const getResult = (): Result.Result<number, string> => Result.succeed(42);
  * const value = Result.pipe(
- *   result,
+ *   getResult(),
  *   Result.orElse(() => Result.succeed('fallback')),
  *   Result.assertSuccess,
  *   Result.unwrap(), // Safe unwrap after assertion

package/dist/esm/functions/or-else.d.ts

@@ -21,6 +21,8 @@ import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '..
  *
  * @example Failure Case (function returns a Success)
  * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
  * const result = Result.pipe(
  *   Result.fail('original error'),
  *   Result.orElse((error) => Result.succeed('default value')),
@@ -30,6 +32,8 @@ import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '..
  *
  * @example Failure Case (function returns a Failure)
  * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
  * const result = Result.pipe(
  *   Result.fail('original error'),
  *   Result.orElse((error) => Result.fail('new error: ' + error)),

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

@@ -10,58 +10,64 @@ import type { Result, ResultAsync } from '../result';
  * @typeParam T - The function type to execute (sync or async) or a Promise type.
  * @typeParam E - The error type to return if `catch` is used.
  *
- * @example Promise Try-Catch
+ * @example Sync try-catch
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const result = Result.try({
- *   try: fetch('/api/data'),
- *   catch: (error) => new Error('Fetch failed', { cause: error }),
+ * const fn = Result.try({
+ *   try: (x: number) => {
+ *     if (x < 0) throw new Error('Negative!');
+ *     return x * 2;
+ *   },
+ *   catch: (error) => new Error('Oops!', { cause: error }),
  * });
  *
- * // result is ResultAsync<Response, Error>
+ * const result = fn(5); // Result.Result<number, Error>
  * ```
  *
- * @example Promise Safe
+ * @example Sync try-catch with immediate execution
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
  * const result = Result.try({
- *   safe: true,
- *   try: Promise.resolve('ok'),
+ *   immediate: true,
+ *   try: () => {
+ *     const x = Math.random() * 10 - 5;
+ *     if (x < 0) throw new Error('Negative!');
+ *     return x * 2;
+ *   },
+ *   catch: (error) => new Error('Oops!', { cause: error }),
  * });
  *
- * // result is ResultAsync<string, never>
+ * // result is Result<number, Error>
  * ```
  *
- * @example Sync Try-Catch
+ * @example Sync safe
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
  * const fn = Result.try({
- *   try: (x: number) => {
- *     if (x < 0) throw new Error('Negative!');
- *     return x * 2;
- *   },
- *   catch: (error) => new Error('Oops!', { cause: error }),
+ *   safe: true,
+ *   try: (x: number) => x + 1,
  * });
  *
- * const result = fn(5); // Result.Result<number, Error>
+ * const result = fn(1); // Result.Result<number, never>
  * ```
  *
- * @example Sync Safe
+ * @example Sync safe with immediate execution
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
- * const fn = Result.try({
+ * const result = Result.try({
  *   safe: true,
- *   try: (x: number) => x + 1,
+ *   immediate: true,
+ *   try: () => Math.random() + 1,
  * });
  *
- * const result = fn(1); // Result.Result<number, never>
+ * // result is Result<number, never>
  * ```
  *
- * @example Async Function Try-Catch
+ * @example Async try-catch
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
@@ -73,7 +79,20 @@ import type { Result, ResultAsync } from '../result';
  * const result = await fn('abc'); // Result.ResultAsync<Response, Error>
  * ```
  *
- * @example Async Function Safe
+ * @example Async try-catch with immediate execution
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.try({
+ *   immediate: true,
+ *   try: () => fetch('/api/data'),
+ *   catch: (error) => new Error('Fetch failed', { cause: error }),
+ * });
+ *
+ * // result is ResultAsync<Response, Error>
+ * ```
+ *
+ * @example Async safe
  * ```ts
  * import { Result } from '@praha/byethrow';
  *
@@ -85,32 +104,57 @@ import type { Result, ResultAsync } from '../result';
  * const result = await fn(); // Result.ResultAsync<string, never>
  * ```
  *
+ * @example Async safe with immediate execution
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.try({
+ *   safe: true,
+ *   immediate: true,
+ *   try: () => Promise.resolve('ok'),
+ * });
+ *
+ * // result is ResultAsync<string, never>
+ * ```
+ *
  * @category Creators
  */
 declare const try_: {
-    <T extends Promise<any>, E>(options: {
-        try: T;
-        catch: (error: unknown) => E;
-    }): ResultAsync<Awaited<T>, E>;
-    <T extends Promise<any>>(options: {
-        try: T;
-        safe: true;
-    }): ResultAsync<Awaited<T>, never>;
     <T extends (...args: readonly any[]) => Promise<any>, E>(options: {
         try: T;
         catch: (error: unknown) => E;
     }): (...args: Parameters<T>) => ResultAsync<Awaited<ReturnType<T>>, E>;
-    <T extends (...args: readonly any[]) => Promise<any>>(options: {
+    <T extends () => Promise<any>, E>(options: {
+        immediate: true;
         try: T;
+        catch: (error: unknown) => E;
+    }): ResultAsync<Awaited<ReturnType<T>>, E>;
+    <T extends (...args: readonly any[]) => Promise<any>>(options: {
         safe: true;
+        try: T;
     }): (...args: Parameters<T>) => ResultAsync<Awaited<ReturnType<T>>, never>;
+    <T extends () => Promise<any>>(options: {
+        safe: true;
+        immediate: true;
+        try: T;
+    }): ResultAsync<Awaited<ReturnType<T>>, never>;
     <T extends (...args: readonly any[]) => any, E>(options: {
         try: T;
         catch: (error: unknown) => E;
     }): (...args: Parameters<T>) => Result<ReturnType<T>, E>;
-    <T extends (...args: readonly any[]) => any>(options: {
+    <T extends () => any, E>(options: {
+        immediate: true;
         try: T;
+        catch: (error: unknown) => E;
+    }): Result<ReturnType<T>, E>;
+    <T extends (...args: readonly any[]) => any>(options: {
         safe: true;
+        try: T;
     }): (...args: Parameters<T>) => Result<ReturnType<T>, never>;
+    <T extends () => any>(options: {
+        safe: true;
+        immediate: true;
+        try: T;
+    }): Result<ReturnType<T>, never>;
 };
 export { try_ as try };

package/dist/esm/functions/try.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@praha/byethrow",
-  "version": "0.6.3",
+  "version": "0.7.0",
   "description": "A lightweight, tree-shakable Result type package with a simple, consistent API designed",
   "keywords": [
     "javascript",
@@ -44,11 +44,11 @@
     "@standard-schema/spec": "^1.0.0"
   },
   "devDependencies": {
-    "@rslib/core": "0.11.2",
-    "eslint": "9.32.0",
-    "typedoc": "0.28.10",
-    "typedoc-plugin-markdown": "4.8.0",
-    "typescript": "5.8.3",
+    "@rslib/core": "0.13.0",
+    "eslint": "9.35.0",
+    "typedoc": "0.28.12",
+    "typedoc-plugin-markdown": "4.8.1",
+    "typescript": "5.9.2",
     "vitest": "3.2.4"
   },
   "publishConfig": {