retuple 1.0.0-next.10 → 1.0.0-next.11

package/dist/index.cjs

@@ -16,11 +16,6 @@ exports.RetupleArrayMethodUnavailableError = exports.RetupleInvalidResultError =
 exports.Result = Result;
 exports.Ok = Ok;
 exports.Err = Err;
-exports.nonNullable = nonNullable;
-exports.truthy = truthy;
-exports.safe = safe;
-exports.safeAsync = safeAsync;
-exports.safePromise = safePromise;
 /**
  * ## Retuple Unwrap Failed
  *
@@ -130,6 +125,7 @@ function Result(resultLike) {
 }
 Result.Ok = Ok;
 Result.Err = Err;
+Result.$resolve = resolve;
 Result.$nonNullable = nonNullable;
 Result.$truthy = truthy;
 Result.$safe = safe;
@@ -142,6 +138,17 @@ function Ok(val) {
 function Err(err) {
     return new ResultErr(err);
 }
+function resolve(result) {
+    if (result instanceof ResultAsync) {
+        return result;
+    }
+    else if (result instanceof ResultOk || result instanceof ResultErr) {
+        return result.$async();
+    }
+    else {
+        return new ResultAsync(result);
+    }
+}
 function nonNullable(value, error = mapTrue) {
     if (value !== null && value !== undefined) {
         return Ok(value);

package/dist/index.d.cts

@@ -1,10 +1,5 @@
 export type Ok = typeof Ok;
 export type Err = typeof Err;
-export type nonNullable = typeof nonNullable;
-export type truthy = typeof truthy;
-export type safe = typeof safe;
-export type safeAsync = typeof safeAsync;
-export type safePromise = typeof safePromise;
 export type Result<T, E> = (OkTuple<T> | ErrTuple<E>) & Retuple<T, E>;
 export { type ResultAsync };
 /**
@@ -85,6 +80,7 @@ export declare function Result<R extends [err: null | undefined, value: unknown]
 export declare namespace Result {
     var Ok: typeof import(".").Ok;
     var Err: typeof import(".").Err;
+    var $resolve: typeof resolve;
     var $nonNullable: typeof nonNullable;
     var $truthy: typeof truthy;
     var $safe: typeof safe;
@@ -133,6 +129,7 @@ export declare function Ok<const T>(val: T): Result<T, never>;
  */
 export declare function Err(): Result<never, void>;
 export declare function Err<const E>(err: E): Result<never, E>;
+declare function resolve<T, E>(result: Retuple<T, E> | PromiseLike<Retuple<T, E>>): ResultAsync<T, E>;
 /**
  * Construct a {@link Result} from a value. If the value is neither null or
  * undefined, the result is `Ok`.
@@ -178,8 +175,8 @@ export declare function Err<const E>(err: E): Result<never, E>;
  * assert.equal(value, undefined);
  * ```
  */
-export declare function nonNullable<const T>(value: T): Result<NonNullable<T>, true>;
-export declare function nonNullable<const T, E>(value: T, error: () => E): Result<NonNullable<T>, E>;
+declare function nonNullable<const T>(value: T): Result<NonNullable<T>, true>;
+declare function nonNullable<const T, E>(value: T, error: () => E): Result<NonNullable<T>, E>;
 /**
  * Construct a {@link Result} from a value. If the value is truthy, the result
  * is `Ok`.
@@ -225,8 +222,8 @@ export declare function nonNullable<const T, E>(value: T, error: () => E): Resul
  * assert.equal(value, undefined);
  * ```
  */
-export declare function truthy<const T>(value: T): Result<Truthy<T>, true>;
-export declare function truthy<const T, E>(value: T, error: () => E): Result<Truthy<T>, E>;
+declare function truthy<const T>(value: T): Result<Truthy<T>, true>;
+declare function truthy<const T, E>(value: T, error: () => E): Result<Truthy<T>, E>;
 /**
  * Construct a {@link Result} from a synchronous function call. If the function
  * returns without throwing, the result is `Ok`.
@@ -292,8 +289,8 @@ export declare function truthy<const T, E>(value: T, error: () => E): Result<Tru
  * assert(err instanceof RetupleThrownValueError && err.value === "non error");
  * assert.equal(value, undefined);
  */
-export declare function safe<T>(f: () => Awaited<T>): Result<T, Error>;
-export declare function safe<T, E>(f: () => Awaited<T>, mapError: (err: unknown) => E): Result<T, E>;
+declare function safe<T>(f: () => Awaited<T>): Result<T, Error>;
+declare function safe<T, E>(f: () => Awaited<T>, mapError: (err: unknown) => E): Result<T, E>;
 /**
  * Construct a {@link ResultAsync} from a function call. If the function returns
  * without throwing, and any promise returned resolves, the result is `Ok`.
@@ -359,8 +356,8 @@ export declare function safe<T, E>(f: () => Awaited<T>, mapError: (err: unknown)
  * assert(err instanceof RetupleThrownValueError && err.value === "non error");
  * assert.equal(value, undefined);
  */
-export declare function safeAsync<T>(f: () => T | PromiseLike<T>): ResultAsync<T, Error>;
-export declare function safeAsync<T, E>(f: () => T | PromiseLike<T>, mapError: (err: unknown) => E): ResultAsync<T, E>;
+declare function safeAsync<T>(f: () => T | PromiseLike<T>): ResultAsync<T, Error>;
+declare function safeAsync<T, E>(f: () => T | PromiseLike<T>, mapError: (err: unknown) => E): ResultAsync<T, E>;
 /**
  * Construct a {@link Result} from a promise. If the promise resolves, the
  * result is `Ok`.
@@ -422,8 +419,8 @@ export declare function safeAsync<T, E>(f: () => T | PromiseLike<T>, mapError: (
  * assert(err instanceof RetupleThrownValueError && err.value === "non error");
  * assert.equal(value, undefined);
  */
-export declare function safePromise<T>(promise: PromiseLike<T>): ResultAsync<T, Error>;
-export declare function safePromise<T, E>(promise: PromiseLike<T>, mapError: (err: unknown) => E): ResultAsync<T, E>;
+declare function safePromise<T>(promise: PromiseLike<T>): ResultAsync<T, Error>;
+declare function safePromise<T, E>(promise: PromiseLike<T>, mapError: (err: unknown) => E): ResultAsync<T, E>;
 /**
  * ## RetupleArray
  *

package/dist/index.d.ts

@@ -1,10 +1,5 @@
 export type Ok = typeof Ok;
 export type Err = typeof Err;
-export type nonNullable = typeof nonNullable;
-export type truthy = typeof truthy;
-export type safe = typeof safe;
-export type safeAsync = typeof safeAsync;
-export type safePromise = typeof safePromise;
 export type Result<T, E> = (OkTuple<T> | ErrTuple<E>) & Retuple<T, E>;
 export { type ResultAsync };
 /**
@@ -85,6 +80,7 @@ export declare function Result<R extends [err: null | undefined, value: unknown]
 export declare namespace Result {
     var Ok: typeof import(".").Ok;
     var Err: typeof import(".").Err;
+    var $resolve: typeof resolve;
     var $nonNullable: typeof nonNullable;
     var $truthy: typeof truthy;
     var $safe: typeof safe;
@@ -133,6 +129,7 @@ export declare function Ok<const T>(val: T): Result<T, never>;
  */
 export declare function Err(): Result<never, void>;
 export declare function Err<const E>(err: E): Result<never, E>;
+declare function resolve<T, E>(result: Retuple<T, E> | PromiseLike<Retuple<T, E>>): ResultAsync<T, E>;
 /**
  * Construct a {@link Result} from a value. If the value is neither null or
  * undefined, the result is `Ok`.
@@ -178,8 +175,8 @@ export declare function Err<const E>(err: E): Result<never, E>;
  * assert.equal(value, undefined);
  * ```
  */
-export declare function nonNullable<const T>(value: T): Result<NonNullable<T>, true>;
-export declare function nonNullable<const T, E>(value: T, error: () => E): Result<NonNullable<T>, E>;
+declare function nonNullable<const T>(value: T): Result<NonNullable<T>, true>;
+declare function nonNullable<const T, E>(value: T, error: () => E): Result<NonNullable<T>, E>;
 /**
  * Construct a {@link Result} from a value. If the value is truthy, the result
  * is `Ok`.
@@ -225,8 +222,8 @@ export declare function nonNullable<const T, E>(value: T, error: () => E): Resul
  * assert.equal(value, undefined);
  * ```
  */
-export declare function truthy<const T>(value: T): Result<Truthy<T>, true>;
-export declare function truthy<const T, E>(value: T, error: () => E): Result<Truthy<T>, E>;
+declare function truthy<const T>(value: T): Result<Truthy<T>, true>;
+declare function truthy<const T, E>(value: T, error: () => E): Result<Truthy<T>, E>;
 /**
  * Construct a {@link Result} from a synchronous function call. If the function
  * returns without throwing, the result is `Ok`.
@@ -292,8 +289,8 @@ export declare function truthy<const T, E>(value: T, error: () => E): Result<Tru
  * assert(err instanceof RetupleThrownValueError && err.value === "non error");
  * assert.equal(value, undefined);
  */
-export declare function safe<T>(f: () => Awaited<T>): Result<T, Error>;
-export declare function safe<T, E>(f: () => Awaited<T>, mapError: (err: unknown) => E): Result<T, E>;
+declare function safe<T>(f: () => Awaited<T>): Result<T, Error>;
+declare function safe<T, E>(f: () => Awaited<T>, mapError: (err: unknown) => E): Result<T, E>;
 /**
  * Construct a {@link ResultAsync} from a function call. If the function returns
  * without throwing, and any promise returned resolves, the result is `Ok`.
@@ -359,8 +356,8 @@ export declare function safe<T, E>(f: () => Awaited<T>, mapError: (err: unknown)
  * assert(err instanceof RetupleThrownValueError && err.value === "non error");
  * assert.equal(value, undefined);
  */
-export declare function safeAsync<T>(f: () => T | PromiseLike<T>): ResultAsync<T, Error>;
-export declare function safeAsync<T, E>(f: () => T | PromiseLike<T>, mapError: (err: unknown) => E): ResultAsync<T, E>;
+declare function safeAsync<T>(f: () => T | PromiseLike<T>): ResultAsync<T, Error>;
+declare function safeAsync<T, E>(f: () => T | PromiseLike<T>, mapError: (err: unknown) => E): ResultAsync<T, E>;
 /**
  * Construct a {@link Result} from a promise. If the promise resolves, the
  * result is `Ok`.
@@ -422,8 +419,8 @@ export declare function safeAsync<T, E>(f: () => T | PromiseLike<T>, mapError: (
  * assert(err instanceof RetupleThrownValueError && err.value === "non error");
  * assert.equal(value, undefined);
  */
-export declare function safePromise<T>(promise: PromiseLike<T>): ResultAsync<T, Error>;
-export declare function safePromise<T, E>(promise: PromiseLike<T>, mapError: (err: unknown) => E): ResultAsync<T, E>;
+declare function safePromise<T>(promise: PromiseLike<T>): ResultAsync<T, Error>;
+declare function safePromise<T, E>(promise: PromiseLike<T>, mapError: (err: unknown) => E): ResultAsync<T, E>;
 /**
  * ## RetupleArray
  *

package/dist/index.js

@@ -112,6 +112,7 @@ export function Result(resultLike) {
 }
 Result.Ok = Ok;
 Result.Err = Err;
+Result.$resolve = resolve;
 Result.$nonNullable = nonNullable;
 Result.$truthy = truthy;
 Result.$safe = safe;
@@ -124,19 +125,30 @@ export function Ok(val) {
 export function Err(err) {
     return new ResultErr(err);
 }
-export function nonNullable(value, error = mapTrue) {
+function resolve(result) {
+    if (result instanceof ResultAsync) {
+        return result;
+    }
+    else if (result instanceof ResultOk || result instanceof ResultErr) {
+        return result.$async();
+    }
+    else {
+        return new ResultAsync(result);
+    }
+}
+function nonNullable(value, error = mapTrue) {
     if (value !== null && value !== undefined) {
         return Ok(value);
     }
     return Err(error());
 }
-export function truthy(value, error = mapTrue) {
+function truthy(value, error = mapTrue) {
     if (value) {
         return Ok(value);
     }
     return Err(error());
 }
-export function safe(f, mapError = ensureError) {
+function safe(f, mapError = ensureError) {
     try {
         return Ok(f());
     }
@@ -144,7 +156,7 @@ export function safe(f, mapError = ensureError) {
         return Err(mapError(err));
     }
 }
-export function safeAsync(f, mapError = ensureError) {
+function safeAsync(f, mapError = ensureError) {
     return new ResultAsync((async () => {
         try {
             return Ok(await f());
@@ -154,7 +166,7 @@ export function safeAsync(f, mapError = ensureError) {
         }
     })());
 }
-export function safePromise(promise, mapError = ensureError) {
+function safePromise(promise, mapError = ensureError) {
     return new ResultAsync(promise.then((Ok), async (err) => Err(await mapError(err))));
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "retuple",
-  "version": "1.0.0-next.10",
+  "version": "1.0.0-next.11",
   "scripts": {
     "test": "vitest",
     "lint": "eslint . --ext .ts -c eslint.config.mjs --fix",