retuple 1.0.0-next.10 → 1.0.0-next.12

package/dist/index.cjs

@@ -12,15 +12,10 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _ResultAsync_inner;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RetupleArrayMethodUnavailableError = exports.RetupleInvalidResultError = exports.RetupleThrownValueError = exports.RetupleFlattenFailed = exports.RetupleExpectFailed = exports.RetupleUnwrapErrFailed = exports.RetupleUnwrapFailed = void 0;
+exports.RetupleArrayMethodUnavailableError = exports.RetupleInvalidUnionError = exports.RetupleInvalidResultError = exports.RetupleThrownValueError = exports.RetupleFlattenFailed = exports.RetupleExpectFailed = exports.RetupleUnwrapErrFailed = exports.RetupleUnwrapFailed = void 0;
 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
  *
@@ -100,6 +95,22 @@ class RetupleInvalidResultError extends Error {
     }
 }
 exports.RetupleInvalidResultError = RetupleInvalidResultError;
+/**
+ * ## Retuple Invalid Union Error
+ *
+ * This error is thrown when attempting to construct a `Result` from a
+ * discriminated union, when the 'success' property is not boolean. In this
+ * case, it is impossible to determine whether the result should be `Ok` or
+ * `Err`.
+ */
+class RetupleInvalidUnionError extends Error {
+    constructor(value) {
+        super("Constructing a Result from discriminated union failed, the success " +
+            "property must be boolean");
+        this.value = value;
+    }
+}
+exports.RetupleInvalidUnionError = RetupleInvalidUnionError;
 /**
  * ## Retuple Array Method Unavailable Error
  *
@@ -130,8 +141,10 @@ function Result(resultLike) {
 }
 Result.Ok = Ok;
 Result.Err = Err;
+Result.$resolve = resolve;
 Result.$nonNullable = nonNullable;
 Result.$truthy = truthy;
+Result.$union = union;
 Result.$safe = safe;
 Result.$safeAsync = safeAsync;
 Result.$safePromise = safePromise;
@@ -142,6 +155,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);
@@ -154,6 +178,15 @@ function truthy(value, error = mapTrue) {
     }
     return Err(error());
 }
+function union(union) {
+    if (union.success === true) {
+        return Ok(union.data);
+    }
+    if (union.success === false) {
+        return Err(union.error);
+    }
+    throw new RetupleInvalidUnionError(union);
+}
 function safe(f, mapError = ensureError) {
     try {
         return Ok(f());

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 };
 /**
@@ -67,6 +62,18 @@ export declare class RetupleInvalidResultError extends Error {
     value: unknown[];
     constructor(value: unknown[]);
 }
+/**
+ * ## Retuple Invalid Union Error
+ *
+ * This error is thrown when attempting to construct a `Result` from a
+ * discriminated union, when the 'success' property is not boolean. In this
+ * case, it is impossible to determine whether the result should be `Ok` or
+ * `Err`.
+ */
+export declare class RetupleInvalidUnionError extends Error {
+    value: unknown;
+    constructor(value: unknown);
+}
 /**
  * ## Retuple Array Method Unavailable Error
  *
@@ -85,8 +92,10 @@ 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 $union: typeof union;
     var $safe: typeof safe;
     var $safeAsync: typeof safeAsync;
     var $safePromise: typeof safePromise;
@@ -133,6 +142,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 +188,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 +235,9 @@ 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>;
+declare function union<U extends ObjectUnionOk<any> | ObjectUnionErr<any>>(union: U): Result<U extends ObjectUnionOk<infer T> ? T : never, U extends ObjectUnionErr<infer E> ? E : never>;
 /**
  * Construct a {@link Result} from a synchronous function call. If the function
  * returns without throwing, the result is `Ok`.
@@ -292,8 +303,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 +370,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 +433,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
  *
@@ -942,6 +953,16 @@ type OkTuple<T> = [err: undefined, value: T];
 type ErrTuple<E> = [err: E, value: undefined];
 type ThisOk<T> = OkTuple<T> & Retuple<T, never>;
 type ThisErr<E> = ErrTuple<E> & Retuple<never, E>;
+type ObjectUnionOk<T> = {
+    success: true;
+    data: T;
+    error?: never | undefined;
+};
+type ObjectUnionErr<E> = {
+    success: false;
+    data?: never | undefined;
+    error: E;
+};
 type RetupleAwaitable<T, E> = Retuple<T, E> | PromiseLike<Retuple<T, E>>;
 interface Retuple<T, E> extends RetupleArray<T | E | undefined> {
     /**

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 };
 /**
@@ -67,6 +62,18 @@ export declare class RetupleInvalidResultError extends Error {
     value: unknown[];
     constructor(value: unknown[]);
 }
+/**
+ * ## Retuple Invalid Union Error
+ *
+ * This error is thrown when attempting to construct a `Result` from a
+ * discriminated union, when the 'success' property is not boolean. In this
+ * case, it is impossible to determine whether the result should be `Ok` or
+ * `Err`.
+ */
+export declare class RetupleInvalidUnionError extends Error {
+    value: unknown;
+    constructor(value: unknown);
+}
 /**
  * ## Retuple Array Method Unavailable Error
  *
@@ -85,8 +92,10 @@ 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 $union: typeof union;
     var $safe: typeof safe;
     var $safeAsync: typeof safeAsync;
     var $safePromise: typeof safePromise;
@@ -133,6 +142,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 +188,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 +235,9 @@ 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>;
+declare function union<U extends ObjectUnionOk<any> | ObjectUnionErr<any>>(union: U): Result<U extends ObjectUnionOk<infer T> ? T : never, U extends ObjectUnionErr<infer E> ? E : never>;
 /**
  * Construct a {@link Result} from a synchronous function call. If the function
  * returns without throwing, the result is `Ok`.
@@ -292,8 +303,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 +370,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 +433,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
  *
@@ -942,6 +953,16 @@ type OkTuple<T> = [err: undefined, value: T];
 type ErrTuple<E> = [err: E, value: undefined];
 type ThisOk<T> = OkTuple<T> & Retuple<T, never>;
 type ThisErr<E> = ErrTuple<E> & Retuple<never, E>;
+type ObjectUnionOk<T> = {
+    success: true;
+    data: T;
+    error?: never | undefined;
+};
+type ObjectUnionErr<E> = {
+    success: false;
+    data?: never | undefined;
+    error: E;
+};
 type RetupleAwaitable<T, E> = Retuple<T, E> | PromiseLike<Retuple<T, E>>;
 interface Retuple<T, E> extends RetupleArray<T | E | undefined> {
     /**

package/dist/index.js

@@ -83,6 +83,21 @@ export class RetupleInvalidResultError extends Error {
         this.value = value;
     }
 }
+/**
+ * ## Retuple Invalid Union Error
+ *
+ * This error is thrown when attempting to construct a `Result` from a
+ * discriminated union, when the 'success' property is not boolean. In this
+ * case, it is impossible to determine whether the result should be `Ok` or
+ * `Err`.
+ */
+export class RetupleInvalidUnionError extends Error {
+    constructor(value) {
+        super("Constructing a Result from discriminated union failed, the success " +
+            "property must be boolean");
+        this.value = value;
+    }
+}
 /**
  * ## Retuple Array Method Unavailable Error
  *
@@ -112,8 +127,10 @@ export function Result(resultLike) {
 }
 Result.Ok = Ok;
 Result.Err = Err;
+Result.$resolve = resolve;
 Result.$nonNullable = nonNullable;
 Result.$truthy = truthy;
+Result.$union = union;
 Result.$safe = safe;
 Result.$safeAsync = safeAsync;
 Result.$safePromise = safePromise;
@@ -124,19 +141,39 @@ 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 union(union) {
+    if (union.success === true) {
+        return Ok(union.data);
+    }
+    if (union.success === false) {
+        return Err(union.error);
+    }
+    throw new RetupleInvalidUnionError(union);
+}
+function safe(f, mapError = ensureError) {
     try {
         return Ok(f());
     }
@@ -144,7 +181,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 +191,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.12",
   "scripts": {
     "test": "vitest",
     "lint": "eslint . --ext .ts -c eslint.config.mjs --fix",