retuple 1.0.0-next.12 → 1.0.0-next.14

package/dist/index.d.cts

@@ -1,7 +1,16 @@
+import { ResultLikeSymbol } from "./symbol.cjs";
 export type Ok = typeof Ok;
 export type Err = typeof Err;
 export type Result<T, E> = (OkTuple<T> | ErrTuple<E>) & Retuple<T, E>;
-export { type ResultAsync };
+export type ResultLike<T, E> = {
+    [ResultLikeSymbol](): Result<T, E>;
+};
+export { type ResultAsync, type ResultRetry };
+export interface ResultRetryController<E> {
+    error: E;
+    attempt: number;
+    abort: () => void;
+}
 /**
  * ## Retuple Unwrap Failed
  *
@@ -30,16 +39,6 @@ export declare class RetupleExpectFailed<const E = unknown> extends Error {
     value: E;
     constructor(value: E);
 }
-/**
- * ## Retuple Expect Failed
- *
- * An error which occurs when calling `$flatten` on `Ok`, when the value
- * contained in the `Ok` is not an `Ok` or `Err`.
- */
-export declare class RetupleFlattenFailed<const T = unknown> extends Error {
-    value: T;
-    constructor(value: T);
-}
 /**
  * ## Retuple Thrown Value Error
  *
@@ -47,21 +46,10 @@ export declare class RetupleFlattenFailed<const T = unknown> extends Error {
  * thrown error or rejected value is not an instance of `Error`, and when no
  * map error function is provided.
  */
-export declare class RetupleThrownValueError extends Error {
+export declare class RetupleCaughtValueError extends Error {
     value: unknown;
     constructor(value: unknown);
 }
-/**
- * ## Retuple Invalid Result Error
- *
- * This error is thrown when attempting to construct a `Result` from a tuple,
- * when neither index 0 or 1 are null or undefined. In this case, it is
- * impossible to determine whether the result should be `Ok` or `Err`.
- */
-export declare class RetupleInvalidResultError extends Error {
-    value: unknown[];
-    constructor(value: unknown[]);
-}
 /**
  * ## Retuple Invalid Union Error
  *
@@ -88,17 +76,38 @@ export declare class RetupleArrayMethodUnavailableError extends Error {
  *
  * @TODO
  */
-export declare function Result<R extends [err: null | undefined, value: unknown] | [err: unknown, value: null | undefined]>(resultLike: R): (R extends [null | undefined, infer T] ? ThisOk<T> : R extends [infer E, null | undefined] ? ThisErr<E> : never) extends ThisOk<infer T> | ThisErr<infer E> ? Result<T, NonNullable<E>> : never;
+export declare function Result<T, E>(resultLike: ResultLike<T, E>): Result<T, E>;
 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;
+    var Ok: typeof import("./index.js").Ok;
+    var Err: typeof import("./index.js").Err;
+    var $from: <T, E>(result: ResultLike<T, E>) => Result<T, E>;
+    var $resolve: <T, E>(result: ResultLikeAwaitable<T, E>) => ResultAsync<T, E>;
+    var $nonNullable: {
+        <const T>(value: T): Result<NonNullable<T>, true>;
+        <const T, E>(value: T, error: () => E): Result<NonNullable<T>, E>;
+    };
+    var $truthy: {
+        <const T>(value: T): Result<Truthy<T>, true>;
+        <const T, E>(value: T, error: () => E): Result<Truthy<T>, E>;
+    };
+    var $fromUnion: <U extends ObjectUnionOk<any> | ObjectUnionErr<any>>(union: U) => Result<U extends ObjectUnionOk<infer T> ? T : never, U extends ObjectUnionErr<infer E> ? E : never>;
+    var $safe: {
+        <T>(f: () => Awaited<T>): Result<T, Error>;
+        <T, E>(f: () => Awaited<T>, mapError: (err: unknown) => E): Result<T, E>;
+    };
+    var $safeAsync: {
+        <T>(f: () => T | PromiseLike<T>): ResultAsync<T, Error>;
+        <T, E>(f: () => T | PromiseLike<T>, mapError: (err: unknown) => E): ResultAsync<T, E>;
+    };
+    var $safePromise: {
+        <T>(promise: PromiseLike<T>): ResultAsync<T, Error>;
+        <T, E>(promise: PromiseLike<T>, mapError: (err: unknown) => E): ResultAsync<T, E>;
+    };
+    var $retry: <T, E>(f: () => ResultLike<T, E> | PromiseLike<ResultLike<T, E>>) => ResultRetry<T, E>;
+    var $safeRetry: {
+        <T>(f: () => T | PromiseLike<T>): ResultRetry<T, Error>;
+        <T, E>(f: () => T | PromiseLike<T>, mapError: (err: unknown) => E): ResultRetry<T, E>;
+    };
 }
 /**
  * Create a new {@link Result} with the `Ok` variant. When called without
@@ -142,299 +151,6 @@ 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`.
- *
- * Otherwise, the result is `Err` containing:
-
- * - the returned value from the error function when provided;
- * - or `true` otherwise.
- *
- * @example
- *
- * ```ts
- * const result: Result<User, Error> = Result.$nonNullable(
- *    users.find((user) => user.id === currentUserId),
- *    () => new Error("User not found"),
- * );
- * ```
- *
- * @example
- *
- * ```ts
- * const [err, value] = Result.$nonNullable("test");
- *
- * assert.equal(err, undefined);
- * assert.equal(value, "test");
- * ```
- *
- * @example
- *
- * ```ts
- * const [err, value] = Result.$nonNullable(null);
- *
- * assert.equal(err, true);
- * assert.equal(value, undefined);
- * ```
- *
- * @example
- *
- * ```ts
- * const [err, value] = Result.$nonNullable(null, () => "error");
- *
- * assert.equal(err, "error");
- * assert.equal(value, undefined);
- * ```
- */
-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`.
- *
- * Otherwise, the result is `Err` containing:
- *
- * - the returned value from the error function when provided;
- * - or `true` otherwise.
- *
- * @example
- *
- * ```ts
- * const result: Result<string, Error> = Result.$truthy(
- *    username.trim(),
- *    () => new Error("Username is empty"),
- * );
- * ```
- *
- * @example
- *
- * ```ts
- * const [err, value] = Result.$truthy("test");
- *
- * assert.equal(err, undefined);
- * assert.equal(value, "test");
- * ```
- *
- * @example
- *
- * ```ts
- * const [err, value] = Result.$truthy("");
- *
- * assert.equal(err, true);
- * assert.equal(value, undefined);
- * ```
- *
- * @example
- *
- * ```ts
- * const [err, value] = Result.$truthy(0, () => "error");
- *
- * assert.equal(err, "error");
- * assert.equal(value, undefined);
- * ```
- */
-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`.
- *
- * Otherwise, the result is `Err` containing (in priority order):
- *
- * - the returned value from the map error function when provided;
- * - the thrown error when it is an instance of `Error`;
- * - `RetupleThrownValueError` when a non `Error` instance is thrown.
- *
- * @example
- *
- * ```ts
- * const result: Result<URL, Error> = Result.$safe(
- *    () => new URL(user.url),
- *    () => new Error("Invalid URL"),
- * );
- * ```
- *
- * @example
- *
- * ```ts
- * const [err, value] = Result.$safe(() => "test");
- *
- * assert.equal(err, undefined);
- * assert.equal(value, "test");
- * ```
- *
- * @example
- *
- * ```ts
- * const [err, value] = Result.$safe(
- *    () => {
- *       throw new Error("throws");
- *    },
- *    () => "error",
- * );
- *
- * assert.equal(err, "error");
- * assert.equal(value, undefined);
- * ```
- *
- * @example
- *
- * ```ts
- * const [err, value] = Result.$safe(
- *    () => {
- *       throw new Error("throws")
- *    },
- * );
- *
- * assert(err instanceof Error && err.message === "throws");
- * assert.equal(value, undefined);
- * ```
- *
- * @example
- *
- * ```ts
- * const [err, value] = Result.$safe(() => {
- *    throw "non error";
- * });
- *
- * assert(err instanceof RetupleThrownValueError && err.value === "non error");
- * assert.equal(value, undefined);
- */
-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`.
- *
- * Otherwise, the result is `Err` containing (in priority order):
- *
- * - the returned value from the map error function when provided;
- * - the thrown/rejected error when it is an instance of `Error`;
- * - `RetupleThrownValueError` when throwing/rejecting with a non `Error`.
- *
- * @example
- *
- * ```ts
- * const result: Result<Response, Error> = await Result.$safeAsync(
- *    () => fetch("http://example.com/api"),
- *    () => new Error("Fetch failed"),
- * );
- * ```
- *
- * @example
- *
- * ```ts
- * const [err, value] = await Result.$safeAsync(async () => "test");
- *
- * assert.equal(err, undefined);
- * assert.equal(value, "test");
- * ```
- *
- * @example
- *
- * ```ts
- * const [err, value] = await Result.$safeAsync(
- *    async () => {
- *       throw new Error("throws");
- *    },
- *    () => "error",
- * );
- *
- * assert.equal(err, "error");
- * assert.equal(value, undefined);
- * ```
- *
- * @example
- *
- * ```ts
- * const [err, value] = await Result.$safeAsync(
- *    async () => {
- *       throw new Error("throws")
- *    },
- * );
- *
- * assert(err instanceof Error && err.message === "throws");
- * assert.equal(value, undefined);
- * ```
- *
- * @example
- *
- * ```ts
- * const [err, value] = await Result.$safeAsync(async () => {
- *    throw "non error";
- * });
- *
- * assert(err instanceof RetupleThrownValueError && err.value === "non error");
- * assert.equal(value, undefined);
- */
-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`.
- *
- * Otherwise, the result is `Err` containing (in priority order):
- *
- * - the returned value from the map error function when provided;
- * - the rejected error when it is an instance of `Error`;
- * - `RetupleThrownValueError` when rejecting with a non `Error`.
- *
- * @example
- *
- * ```ts
- * const result: Result<Response, Error> = await Result.$safePromise(
- *    fetch("http://example.com/api"),
- *    () => new Error("Fetch failed"),
- * );
- * ```
- *
- * @example
- *
- * ```ts
- * const [err, value] = await Result.$safePromise(Promise.resolve("test"));
- *
- * assert.equal(err, undefined);
- * assert.equal(value, "test");
- * ```
- *
- * @example
- *
- * ```ts
- * const [err, value] = await Result.$safePromise(
- *    Promise.reject(new Error("rejects")),
- *    () => "error",
- * );
- *
- * assert.equal(err, "error");
- * assert.equal(value, undefined);
- * ```
- *
- * @example
- *
- * ```ts
- * const [err, value] = await Result.$safePromise(
- *    Promise.reject(new Error("rejects")),
- * );
- *
- * assert(err instanceof Error && err.message === "rejects");
- * assert.equal(value, undefined);
- * ```
- *
- * @example
- *
- * ```ts
- * const [err, value] = await Result.$safeAsync(
- *    Promise.reject("non error"),
- * );
- *
- * assert(err instanceof RetupleThrownValueError && err.value === "non error");
- * assert.equal(value, undefined);
- */
-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
  *
@@ -445,8 +161,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -454,8 +169,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -463,8 +177,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -472,8 +185,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -481,8 +193,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -490,8 +201,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -499,8 +209,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -508,8 +217,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -517,8 +225,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -526,8 +233,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -535,8 +241,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -544,8 +249,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -553,8 +257,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -562,8 +265,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -571,8 +273,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -580,8 +281,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -589,8 +289,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -598,8 +297,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -607,8 +305,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -616,8 +313,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -625,8 +321,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -634,8 +329,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -643,8 +337,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -652,8 +345,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -661,8 +353,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -670,8 +361,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -679,8 +369,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -688,8 +377,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -697,8 +385,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -706,8 +393,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -715,8 +401,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -724,8 +409,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -733,8 +417,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -742,8 +425,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -751,8 +433,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -760,8 +441,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -769,8 +449,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -778,8 +457,7 @@ declare class RetupleArray<T> extends Array<T> {
     /**
      * ## Method not available
      *
-     * Built-in array methods not available on `Result` types, convert the result
-     * to a tuple using `$tuple()` first.
+     * Built-in array methods not available on {@link Result} types.
      *
      * @deprecated
      */
@@ -818,65 +496,77 @@ declare class ResultAsync<T, E> {
      */
     $unwrapOrElse<U = T>(this: ResultAsync<T, E>, f: () => U): Promise<T | U>;
     /**
-     * The same as {@link Retuple.$map|$map}, except it returns `ResultAsync`.
+     * The same as {@link Retuple.$map|$map}, except it returns
+     * {@link ResultAsync}.
      */
     $map<U>(this: ResultAsync<T, E>, f: (val: T) => U): ResultAsync<U, E>;
     /**
      * The same as {@link Retuple.$mapErr|$mapErr}, except it returns
-     * `ResultAsync`.
+     * {@link ResultAsync}.
      */
     $mapErr<F = E>(this: ResultAsync<T, E>, f: (err: E) => F): ResultAsync<T, F>;
     /**
-     * The same as {@link Retuple.$mapOr|$mapOr}, except it returns `ResultAsync`.
+     * The same as {@link Retuple.$mapOr|$mapOr}, except it returns
+     * {@link ResultAsync}.
      */
     $mapOr<U, V = U>(this: ResultAsync<T, E>, def: U, f: (val: T) => V): ResultAsync<U | V, never>;
     /**
      * The same as {@link Retuple.$mapOrElse|$mapOrElse}, except it returns
-     * `ResultAsync`.
+     * {@link ResultAsync}.
      */
     $mapOrElse<U, V = U>(this: ResultAsync<T, E>, def: (err: E) => U, f: (val: T) => V): ResultAsync<U | V, never>;
     /**
      * The same as {@link Retuple.$andAssertOr|$andAssertOr}, except it:
      *
      * - can also accept a `PromiseLike` default value;
-     * - returns `ResultAsync`.
+     * - returns {@link ResultAsync}.
      */
-    $andAssertOr<U = T, F = E>(this: ResultAsync<T, E>, def: RetupleAwaitable<U, F>): ResultAsync<Truthy<T> | U, E | F>;
-    $andAssertOr<U = T, F = E, A extends T = T>(this: ResultAsync<T, E>, def: RetupleAwaitable<U, F>, predicate: (val: T) => val is A): ResultAsync<U | A, E | F>;
-    $andAssertOr<U = T, F = E>(this: ResultAsync<T, E>, def: RetupleAwaitable<U, F>, condition: (val: T) => unknown): ResultAsync<T | U, E | F>;
+    $andAssertOr<U = T, F = E>(this: ResultAsync<T, E>, def: ResultLikeAwaitable<U, F>): ResultAsync<Truthy<T> | U, E | F>;
+    $andAssertOr<U = T, F = E, A extends T = T>(this: ResultAsync<T, E>, def: ResultLikeAwaitable<U, F>, predicate: (val: T) => val is A): ResultAsync<U | A, E | F>;
+    $andAssertOr<U = T, F = E>(this: ResultAsync<T, E>, def: ResultLikeAwaitable<U, F>, condition: (val: T) => unknown): ResultAsync<T | U, E | F>;
     /**
      * The same as {@link Retuple.$andAssertOrElse|$andAssertOrElse}, except it:
      *
      * - can also accept an `async` default function;
-     * - returns `ResultAsync`.
+     * - returns {@link ResultAsync}.
      */
-    $andAssertOrElse<U = T, F = E>(this: ResultAsync<T, E>, def: (val: T) => RetupleAwaitable<U, F>): ResultAsync<Truthy<T> | U, E | F>;
-    $andAssertOrElse<U = T, F = E, A extends T = T>(this: ResultAsync<T, E>, def: (val: T) => RetupleAwaitable<U, F>, predicate: (val: T) => val is A): ResultAsync<U | A, E | F>;
-    $andAssertOrElse<U = T, F = E>(this: ResultAsync<T, E>, def: (val: T) => RetupleAwaitable<U, F>, condition: (val: T) => unknown): ResultAsync<T | U, E | F>;
+    $andAssertOrElse<U = T, F = E>(this: ResultAsync<T, E>, def: (val: T) => ResultLikeAwaitable<U, F>): ResultAsync<Truthy<T> | U, E | F>;
+    $andAssertOrElse<U = T, F = E, A extends T = T>(this: ResultAsync<T, E>, def: (val: T) => ResultLikeAwaitable<U, F>, predicate: (val: T) => val is A): ResultAsync<U | A, E | F>;
+    $andAssertOrElse<U = T, F = E>(this: ResultAsync<T, E>, def: (val: T) => ResultLikeAwaitable<U, F>, condition: (val: T) => unknown): ResultAsync<T | U, E | F>;
     /**
      * The same as {@link Retuple.$or|$or}, except it:
      *
      * - can also accept a `PromiseLike` or value;
-     * - returns `ResultAsync`.
+     * - returns {@link ResultAsync}.
      */
-    $or<U = T, F = E>(this: ResultAsync<T, E>, or: Retuple<U, F> | PromiseLike<Retuple<U, F>>): ResultAsync<T | U, F>;
+    $or<U = T, F = E>(this: ResultAsync<T, E>, or: ResultLikeAwaitable<U, F>): ResultAsync<T | U, F>;
     /**
      * The same as {@link Retuple.$orElse|$orElse}, except it:
      *
      * - can also accept an `async` or function;
-     * - returns `ResultAsync`.
+     * - returns {@link ResultAsync}.
      */
-    $orElse<U = T, F = E>(this: ResultAsync<T, E>, f: (err: E) => RetupleAwaitable<U, F>): ResultAsync<T | U, F>;
+    $orElse<U = T, F = E>(this: ResultAsync<T, E>, f: (err: E) => ResultLikeAwaitable<U, F>): ResultAsync<T | U, F>;
     /**
      * The same as {@link Retuple.$orSafe|$orSafe}, except it:
      *
      * - can also accept an `async` safe function;
-     * - returns `ResultAsync`.
+     * - returns {@link ResultAsync}.
      */
     $orSafe<U = T>(this: ResultAsync<T, E>, f: (err: E) => U | PromiseLike<U>): ResultAsync<T | U, Error>;
     $orSafe<U = T, F = E>(this: ResultAsync<T, E>, f: (err: E) => U | PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<T | U, F>;
     /**
-     * @TODO
+     * Returns {@link ResultAsync} based on the outcome of the promise when this
+     * result is `Err`.
+     *
+     * Otherwise, returns `Ok` containing the current contained value.
+     *
+     * Uses the same strategy as {@link Result.$safePromise}, equivalent to
+     * calling:
+     *
+     * ```ts
+     * resultAsync.$orElse(() => Result.$safePromise(...))
+     * ```
      */
     $orSafePromise<U = T>(this: ResultAsync<T, E>, promise: PromiseLike<U>): ResultAsync<T | U, Error>;
     $orSafePromise<U = T, F = E>(this: ResultAsync<T, E>, promise: PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<T | U, F>;
@@ -884,33 +574,43 @@ declare class ResultAsync<T, E> {
      * The same as {@link Retuple.$and|$and}, except it:
      *
      * - can also accept a `PromiseLike` and value;
-     * - returns `ResultAsync`.
+     * - returns {@link ResultAsync}.
      */
-    $and<U = T, F = E>(this: ResultAsync<T, E>, and: RetupleAwaitable<U, F>): ResultAsync<U, E | F>;
+    $and<U = T, F = E>(this: ResultAsync<T, E>, and: ResultLikeAwaitable<U, F>): ResultAsync<U, E | F>;
     /**
      * The same as {@link Retuple.$andThen|$andThen}, except it:
      *
      * - can also accept an `async` and function;
-     * - returns `ResultAsync`.
+     * - returns {@link ResultAsync}.
      */
-    $andThen<U = T, F = E>(this: ResultAsync<T, E>, f: (val: T) => RetupleAwaitable<U, F>): ResultAsync<U, E | F>;
+    $andThen<U = T, F = E>(this: ResultAsync<T, E>, f: (val: T) => ResultLikeAwaitable<U, F>): ResultAsync<U, E | F>;
     /**
      * The same as {@link Retuple.$andThrough|$andThrough}, except it:
      *
      * - can also accept an `async` through function;
-     * - returns `ResultAsync`.
+     * - returns {@link ResultAsync}.
      */
-    $andThrough<F = E>(this: ResultAsync<T, E>, f: (val: T) => RetupleAwaitable<any, F>): ResultAsync<T, E | F>;
+    $andThrough<F = E>(this: ResultAsync<T, E>, f: (val: T) => ResultLikeAwaitable<any, F>): ResultAsync<T, E | F>;
     /**
      * The same as {@link Retuple.$andSafe|$andSafe}, except it:
      *
      * - can also accept an `async` safe function;
-     * - returns `ResultAsync`.
+     * - returns {@link ResultAsync}.
      */
     $andSafe<U = T>(this: ResultAsync<T, E>, f: (val: T) => U | PromiseLike<U>): ResultAsync<U, E | Error>;
     $andSafe<U = T, F = E>(this: ResultAsync<T, E>, f: (val: T) => U | PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<U, E | F>;
     /**
-     * @TODO
+     * Returns {@link ResultAsync} based on the outcome of the promise when this
+     * result is `Ok`.
+     *
+     * Otherwise, returns `Err` containing the current error value.
+     *
+     * Uses the same strategy as {@link Result.$safePromise}, equivalent to
+     * calling:
+     *
+     * ```ts
+     * resultAsync.$andThen(() => Result.$safePromise(...))
+     * ```
      */
     $andSafePromise<U = T>(this: ResultAsync<T, E>, promise: PromiseLike<U>): ResultAsync<U, E | Error>;
     $andSafePromise<U = T, F = E>(this: ResultAsync<T, E>, promise: PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<U, E | F>;
@@ -918,21 +618,21 @@ declare class ResultAsync<T, E> {
      * The same as {@link Retuple.$peek|$peek}, except it:
      *
      * - awaits the peek function;
-     * - returns `ResultAsync`.
+     * - returns {@link ResultAsync}.
      */
     $peek(this: ResultAsync<T, E>, f: (res: Result<T, E>) => any): ResultAsync<T, E>;
     /**
      * The same as {@link Retuple.$tap|$tap}, except it:
      *
      * - awaits the tap function;
-     * - returns `ResultAsync`.
+     * - returns {@link ResultAsync}.
      */
     $tap(this: ResultAsync<T, E>, f: (val: T) => any): ResultAsync<T, E>;
     /**
      * The same as {@link Retuple.$tapErr|$tapErr}, except it:
      *
      * - awaits the tap error function;
-     * - returns `ResultAsync`.
+     * - returns {@link ResultAsync}.
      */
     $tapErr(this: ResultAsync<T, E>, f: (err: E) => any): ResultAsync<T, E>;
     /**
@@ -940,31 +640,132 @@ declare class ResultAsync<T, E> {
      */
     $promise(this: ResultAsync<T, E>): Promise<Result<T, E>>;
     /**
-     * The same as {@link Retuple.$tuple|$tuple}, except it returns a `Promise`.
+     * The same as {@link Retuple.$iter|$iter}, except it returns a `Promise`.
      */
-    $tuple(this: ResultAsync<T, E>): Promise<[err: E | undefined, value: T | undefined]>;
+    $iter<U>(this: ResultAsync<Iterable<U>, E>): Promise<IterableIterator<U, undefined, unknown>>;
+}
+/**
+ * ## ResultRetry
+ */
+declare class ResultRetry<T, E> implements PromiseLike<Result<T, E>> {
+    #private;
+    private static MAX_TIMEOUT;
+    private static MAX_RETRY;
+    private static zero;
+    private static delay;
+    private static integer;
+    constructor(f: () => ResultLikeAwaitable<T, E>);
+    then<U = Result<T, E>, F = never>(this: ResultRetry<T, E>, onfulfilled?: ((value: Result<T, E>) => U | PromiseLike<U>) | null | undefined, onrejected?: ((reason: any) => F | PromiseLike<F>) | null | undefined): PromiseLike<U | F>;
     /**
-     * The same as {@link Retuple.$tuple|$iter}, except it returns a `Promise`.
+     * Sets the maximum number of times the retry function can be executed,
+     * mutating this `ResultRetry` instance.
+     *
+     * **The default value is 1 - meaning that unless set, no retries will be
+     * attempted.**
+     *
+     * The retry function can be called up to the maximum number of times until
+     * it returns `Ok`. If it never returns `Ok`, the  most recent `Err` is
+     * returned.
+     *
+     * This function accepts a positive integer between 1 and 100:
+     *
+     * - Integers outside of this range are clamped to the nearest valid value;
+     * - Any other value (NaN, Infinity, fractions, strings) are treated as 1.
+     *
+     * @example
+     *
+     * ```ts
+     * // Retry someResultFn up to 3 times until Ok is returned:
+     * const result = await Result.$retry(someResultFn).$times(3);
+     * ```
      */
-    $iter<U>(this: ResultAsync<Iterable<U>, E>): Promise<IterableIterator<U, undefined, unknown>>;
+    $times<N extends number>(this: ResultRetry<T, E>, times: NonZero<N> & NonNegativeOrDecimal<N>): ResultRetry<T, E>;
+    /**
+     * Sets the delay between each retry attempt, mutating this `ResultRetry`
+     * instance.
+     *
+     * - Provide a number of milliseconds to introduce a static delay between
+     *   attempts;
+     * - Provide a function to compute the delay dynamically for each attempt;
+     * - If the maximum number of retries is 1, this setting as no effect.
+     *
+     * **The default value is 0 - meaning that unless set, there will be no delay
+     * between attempts.**
+     *
+     * This function accepts an integer between 0 and 3600000:
+     *
+     * - Integers outside of this range are clamped to the nearest valid value;
+     * - Any other value (NaN, Infinity, fractions, strings) are treated as 0.
+     *
+     * @example
+     *
+     * ```ts
+     * // Retry someResultFn up to 3 times until Ok is returned,
+     * // with a 1 second delay between each invocation:
+     * const result = await Result.$retry(someResultFn).$times(3).$delay(1000);
+     * ```
+     */
+    $delay<N extends number>(this: ResultRetry<T, E>, f: (attempt: number) => NonNegativeOrDecimal<N>): ResultRetry<T, E>;
+    $delay<N extends number>(this: ResultRetry<T, E>, ms: NonNegativeOrDecimal<N>): ResultRetry<T, E>;
+    /**
+     * Sets a handler to be called when an attempt returns `Err`, mutating this
+     * `ResultRetry` instance. The handler can be used to capture information
+     * about each failure, and to abort early and prevent further retries.
+     *
+     * The handler function is called with `ResultRetryHandleState`, containing:
+     *
+     * - **error** - The error value from the last failed attempt;
+     * - **attempt** - The attempt number;
+     * - **abort** - A function which when called, prevents further retries.
+     *
+     * @example
+     *
+     * ```ts
+     * // Retry someResultFn up to 3 times until Ok is returned, logging each
+     * // attempt and aborting early if the error code is "UNAUTHORIZED".
+     * const result = await Result.$retry(someResultFn)
+     *    .$times(3)
+     *    .$handle(({ error, attempt, abort }) => {
+     *       console.info(`Attempt ${attempt} failed: ${error}`);
+     *       if (error === "UNAUTHORIZED") {
+     *          abort();
+     *       }
+     *    });
+     * ```
+     */
+    $handle(f: (controller: ResultRetryController<E>) => void): ResultRetry<T, E>;
+    /**
+     * Returns {@link ResultAsync} which resolves to this retried {@link Result}.
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string, SomeError> = await Result
+     *    .$retry(someResultFn)
+     *    .$times(3)
+     *    .$delay(100)
+     *    .$async()
+     *    .$andThen((message) => `Success: ${message}`)
+     *    .$mapErr((code) => new SomeError({ code }));
+     * ```
+     */
+    $async(this: ResultRetry<T, E>): ResultAsync<T, E>;
+    /**
+     * Returns a `Promise` which resolves to this retried {@link Result}.
+     *
+     * @example
+     *
+     * ```ts
+     * const promise: Promise<Result<string, Error>> = Result
+     *    .$retry(someResultFn)
+     *    .$times(3)
+     *    .$promise();
+     * ```
+     */
+    $promise(this: ResultRetry<T, E>): Promise<Result<T, E>>;
+    private drain;
 }
-type Truthy<T> = Exclude<T, false | null | undefined | 0 | 0n | "">;
-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> {
+interface Retuple<T, E> extends RetupleArray<T | E | undefined>, ResultLike<T, E> {
     /**
      * Returns true when this result is `Ok`. Acts as a type guard.
      *
@@ -1340,9 +1141,9 @@ interface Retuple<T, E> extends RetupleArray<T | E | undefined> {
      * assert.equal(asserted.$unwrapErr(), "test");
      * ```
      */
-    $andAssertOr<U = T, F = E>(this: Result<T, E>, def: Result<U, F>): Result<Truthy<T> | U, E | F>;
-    $andAssertOr<U = T, F = E, A extends T = T>(this: Result<T, E>, def: Result<U, F>, predicate: (val: T) => val is A): Result<U | A, E | F>;
-    $andAssertOr<U = T, F = E>(this: Result<T, E>, def: Result<U, F>, condition: (val: T) => unknown): Result<T | U, E | F>;
+    $andAssertOr<U = T, F = E>(this: Result<T, E>, def: ResultLike<U, F>): Result<Truthy<T> | U, E | F>;
+    $andAssertOr<U = T, F = E, A extends T = T>(this: Result<T, E>, def: ResultLike<U, F>, predicate: (val: T) => val is A): Result<U | A, E | F>;
+    $andAssertOr<U = T, F = E>(this: Result<T, E>, def: ResultLike<U, F>, condition: (val: T) => unknown): Result<T | U, E | F>;
     /**
      * Performs an assertion when this result is `Ok`:
      *
@@ -1423,9 +1224,9 @@ interface Retuple<T, E> extends RetupleArray<T | E | undefined> {
      * assert.equal(asserted.$unwrapErr(), "test");
      * ```
      */
-    $andAssertOrElse<U = T, F = E>(this: Result<T, E>, def: (val: T) => Result<U, F>): Result<Truthy<T> | U, E | F>;
-    $andAssertOrElse<U = T, F = E, A extends T = T>(this: Result<T, E>, def: (val: T) => Result<U, F>, predicate: (val: T) => val is A): Result<U | A, E | F>;
-    $andAssertOrElse<U = T, F = E>(this: Result<T, E>, def: (val: T) => Result<U, F>, condition: (val: T) => unknown): Result<T | U, E | F>;
+    $andAssertOrElse<U = T, F = E>(this: Result<T, E>, def: (val: T) => ResultLike<U, F>): Result<Truthy<T> | U, E | F>;
+    $andAssertOrElse<U = T, F = E, A extends T = T>(this: Result<T, E>, def: (val: T) => ResultLike<U, F>, predicate: (val: T) => val is A): Result<U | A, E | F>;
+    $andAssertOrElse<U = T, F = E>(this: Result<T, E>, def: (val: T) => ResultLike<U, F>, condition: (val: T) => unknown): Result<T | U, E | F>;
     /**
      * Returns `Ok` containing the return value of the map function when this
      * result is `Ok`.
@@ -1576,7 +1377,7 @@ interface Retuple<T, E> extends RetupleArray<T | E | undefined> {
      * );
      * ```
      */
-    $or<U = T, F = E>(this: Result<T, E>, or: Result<U, F>): Result<T | U, F>;
+    $or<U = T, F = E>(this: Result<T, E>, or: ResultLike<U, F>): Result<T | U, F>;
     /**
      * Returns the result returned by the or function, when this result is `Err`.
      *
@@ -1612,10 +1413,10 @@ interface Retuple<T, E> extends RetupleArray<T | E | undefined> {
      * );
      * ```
      */
-    $orElse<U = T, F = E>(this: Result<T, E>, f: (err: E) => Result<U, F>): Result<T | U, F>;
+    $orElse<U = T, F = E>(this: Result<T, E>, f: (err: E) => ResultLike<U, F>): Result<T | U, F>;
     /**
-     * Returns a `Result` based on the outcome of the safe function when this
-     * result is `Err`.
+     * Returns a {@link Result} based on the outcome of the safe function when
+     * this result is `Err`.
      *
      * Otherwise, returns `Ok` containing the current ok value.
      *
@@ -1659,7 +1460,7 @@ interface Retuple<T, E> extends RetupleArray<T | E | undefined> {
      * );
      * ```
      */
-    $and<U = T, F = E>(this: Result<T, E>, and: Result<U, F>): Result<U, E | F>;
+    $and<U = T, F = E>(this: Result<T, E>, and: ResultLike<U, F>): Result<U, E | F>;
     /**
      * Returns the and result, when this result is `Ok`.
      *
@@ -1695,7 +1496,7 @@ interface Retuple<T, E> extends RetupleArray<T | E | undefined> {
      * );
      * ```
      */
-    $andThen<U = T, F = E>(this: Result<T, E>, f: (val: T) => Result<U, F>): Result<U, E | F>;
+    $andThen<U = T, F = E>(this: Result<T, E>, f: (val: T) => ResultLike<U, F>): Result<U, E | F>;
     /**
      * Calls the through function when this result is `Ok` and returns:
      *
@@ -1735,23 +1536,24 @@ interface Retuple<T, E> extends RetupleArray<T | E | undefined> {
      * );
      * ```
      */
-    $andThrough<F = E>(this: Result<T, E>, f: (val: T) => Result<any, F>): Result<T, E | F>;
+    $andThrough<F = E>(this: Result<T, E>, f: (val: T) => ResultLike<any, F>): Result<T, E | F>;
     /**
      * Returns a result based on the outcome of the safe function when this
      * result is `Ok`.
      *
      * Otherwise, returns `Err` containing the current error value.
      *
-     * Uses the same strategy as {@link Result.$safe}, equivalent to calling
-     * `result.$and(Result.$safe(...))`.
+     * Uses the same strategy as {@link Result.$safe}, equivalent to calling:
+     *
+     * ```ts
+     * result.$andThen(() => Result.$safe(...))
+     * ```
      */
     $andSafe<U = T>(this: Result<T, E>, f: (val: T) => U): Result<U, E | Error>;
     $andSafe<U = T, F = E>(this: Result<T, E>, f: (val: T) => U, mapError: (err: unknown) => F): Result<U, E | F>;
     /**
-     * @TODO
-     */
-    /**
-     * Calls the peek function and returns `Result` equivalent to this result.
+     * Calls the peek function and returns {@link Result} equivalent to this
+     * result.
      *
      * @example
      *
@@ -1847,7 +1649,7 @@ interface Retuple<T, E> extends RetupleArray<T | E | undefined> {
      */
     $tapErr(this: Result<T, E>, f: (err: E) => void): Result<T, E>;
     /**
-     * Returns the contained `Result` when this result is `Ok`.
+     * Returns the contained {@link Result} when this result is `Ok`.
      *
      * Otherwise returns `Err` containing the current error value.
      *
@@ -1878,7 +1680,7 @@ interface Retuple<T, E> extends RetupleArray<T | E | undefined> {
      */
     $flatten<U, F>(this: Result<Result<U, F>, E>): Result<U, E | F>;
     /**
-     * Returns an equivalent `ResultAsync`.
+     * Returns an equivalent {@link ResultAsync}.
      *
      * @example
      *
@@ -1912,24 +1714,6 @@ interface Retuple<T, E> extends RetupleArray<T | E | undefined> {
      * ```
      */
     $promise(this: Result<T, E>): Promise<Result<T, E>>;
-    /**
-     * Returns a two-element, standard array tuple equivalent to this result.
-     *
-     * @example
-     *
-     * ```ts
-     * const result = Ok("test");
-     * assert.deepEqual(result.$tuple(), [undefined, "test"]);
-     * ```
-     *
-     * @example
-     *
-     * ```ts
-     * const result = Err("test");
-     * assert.deepEqual(result.$tuple(), ["test", undefined]);
-     * ```
-     */
-    $tuple(this: Result<T, E>): [err: E | undefined, value: T | undefined];
     /**
      * Returns an `IterableIterator` over the contained ok value, when this
      * result is `Ok`.
@@ -1974,3 +1758,19 @@ interface Retuple<T, E> extends RetupleArray<T | E | undefined> {
      */
     $iter<U>(this: Result<Iterable<U>, E>): IterableIterator<U, undefined, unknown>;
 }
+type OkTuple<T> = [err: undefined, value: T];
+type ErrTuple<E> = [err: E, value: undefined];
+type ResultLikeAwaitable<T, E> = ResultLike<T, E> | PromiseLike<ResultLike<T, E>>;
+type ObjectUnionOk<T> = {
+    success: true;
+    data: T;
+    error?: never | undefined;
+};
+type ObjectUnionErr<E> = {
+    success: false;
+    data?: never | undefined;
+    error: E;
+};
+type Truthy<T> = Exclude<T, false | null | undefined | 0 | 0n | "">;
+type NonZero<N extends number> = N & (`${N}` extends "0" ? never : N);
+type NonNegativeOrDecimal<N extends number> = N & (`${N}` extends `-${string}` | `${string}.${string}` ? never : N);