retuple 1.0.0-next.11 → 1.0.0-next.13

package/dist/index.cjs

@@ -10,9 +10,9 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _ResultAsync_inner;
+var _ResultAsync_inner, _a, _ResultRetry_f, _ResultRetry_promise, _ResultRetry_times, _ResultRetry_attempt, _ResultRetry_aborted, _ResultRetry_abort, _ResultRetry_getDelay, _ResultRetry_errorHandler;
 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;
@@ -95,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
  *
@@ -128,9 +144,12 @@ Result.Err = Err;
 Result.$resolve = resolve;
 Result.$nonNullable = nonNullable;
 Result.$truthy = truthy;
+Result.$union = union;
 Result.$safe = safe;
 Result.$safeAsync = safeAsync;
 Result.$safePromise = safePromise;
+Result.$retry = retry;
+Result.$safeRetry = safeRetry;
 Object.freeze(Result);
 function Ok(val) {
     return new ResultOk(val);
@@ -138,6 +157,9 @@ function Ok(val) {
 function Err(err) {
     return new ResultErr(err);
 }
+/**
+ * @TODO
+ */
 function resolve(result) {
     if (result instanceof ResultAsync) {
         return result;
@@ -161,6 +183,18 @@ function truthy(value, error = mapTrue) {
     }
     return Err(error());
 }
+/**
+ * @TODO
+ */
+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());
@@ -182,6 +216,22 @@ function safeAsync(f, mapError = ensureError) {
 function safePromise(promise, mapError = ensureError) {
     return new ResultAsync(promise.then((Ok), async (err) => Err(await mapError(err))));
 }
+/**
+ * @TODO
+ */
+function retry(f) {
+    return new ResultRetry(f);
+}
+function safeRetry(f, mapError = ensureError) {
+    return new ResultRetry(async () => {
+        try {
+            return Ok(await f());
+        }
+        catch (err) {
+            return Err(mapError(err));
+        }
+    });
+}
 /**
  * ## RetupleArray
  *
@@ -1082,6 +1132,96 @@ class ResultAsync {
     }
 }
 _ResultAsync_inner = new WeakMap();
+/**
+ * @TODO
+ */
+class ResultRetry {
+    static zero() {
+        return 0;
+    }
+    static delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, Math.min(ms, _a.MAX_TIMEOUT)));
+    }
+    static integer(value) {
+        if (typeof value === "number" && Number.isInteger(value)) {
+            return Math.max(0, value);
+        }
+        return 0;
+    }
+    constructor(f) {
+        _ResultRetry_f.set(this, void 0);
+        _ResultRetry_promise.set(this, void 0);
+        _ResultRetry_times.set(this, 1);
+        _ResultRetry_attempt.set(this, 0);
+        _ResultRetry_aborted.set(this, false);
+        _ResultRetry_abort.set(this, () => (__classPrivateFieldSet(this, _ResultRetry_aborted, true, "f")));
+        _ResultRetry_getDelay.set(this, _a.zero);
+        _ResultRetry_errorHandler.set(this, void 0);
+        __classPrivateFieldSet(this, _ResultRetry_f, f, "f");
+        __classPrivateFieldSet(this, _ResultRetry_promise, this.drain(), "f");
+    }
+    then(onfulfilled, onrejected) {
+        return __classPrivateFieldGet(this, _ResultRetry_promise, "f").then(onfulfilled, onrejected);
+    }
+    /**
+     * @TODO - Capped 100
+     */
+    $times(times) {
+        __classPrivateFieldSet(this, _ResultRetry_times, Math.min(Math.max(1, _a.integer(times)), _a.MAX_RETRY), "f");
+        return this;
+    }
+    $delay(fnOrMs) {
+        if (typeof fnOrMs === "function") {
+            __classPrivateFieldSet(this, _ResultRetry_getDelay, fnOrMs, "f");
+            return this;
+        }
+        const delay = _a.integer(fnOrMs);
+        if (delay > 0) {
+            __classPrivateFieldSet(this, _ResultRetry_getDelay, () => delay, "f");
+        }
+        return this;
+    }
+    /**
+     * @TODO
+     */
+    $monitor(f) {
+        __classPrivateFieldSet(this, _ResultRetry_errorHandler, f, "f");
+        return this;
+    }
+    /**
+     * @TODO
+     */
+    $async() {
+        return new ResultAsync(this);
+    }
+    async drain() {
+        var _b;
+        while (__classPrivateFieldGet(this, _ResultRetry_attempt, "f") < __classPrivateFieldGet(this, _ResultRetry_times, "f")) {
+            const result = await __classPrivateFieldGet(this, _ResultRetry_f, "f").call(this);
+            __classPrivateFieldSet(this, _ResultRetry_attempt, (_b = __classPrivateFieldGet(this, _ResultRetry_attempt, "f"), _b++, _b), "f");
+            if (result.$isOk()) {
+                return result;
+            }
+            if (__classPrivateFieldGet(this, _ResultRetry_errorHandler, "f")) {
+                await __classPrivateFieldGet(this, _ResultRetry_errorHandler, "f").call(this, {
+                    error: result[0],
+                    attempt: __classPrivateFieldGet(this, _ResultRetry_attempt, "f"),
+                    abort: __classPrivateFieldGet(this, _ResultRetry_abort, "f"),
+                });
+            }
+            if (__classPrivateFieldGet(this, _ResultRetry_aborted, "f") || __classPrivateFieldGet(this, _ResultRetry_attempt, "f") === __classPrivateFieldGet(this, _ResultRetry_times, "f")) {
+                return result;
+            }
+            const delay = _a.integer(__classPrivateFieldGet(this, _ResultRetry_getDelay, "f").call(this, __classPrivateFieldGet(this, _ResultRetry_attempt, "f")));
+            if (delay > 0) {
+                await _a.delay(delay);
+            }
+        }
+    }
+}
+_a = ResultRetry, _ResultRetry_f = new WeakMap(), _ResultRetry_promise = new WeakMap(), _ResultRetry_times = new WeakMap(), _ResultRetry_attempt = new WeakMap(), _ResultRetry_aborted = new WeakMap(), _ResultRetry_abort = new WeakMap(), _ResultRetry_getDelay = new WeakMap(), _ResultRetry_errorHandler = new WeakMap();
+ResultRetry.MAX_TIMEOUT = 3600000;
+ResultRetry.MAX_RETRY = 100;
 function ensureError(err) {
     if (err instanceof Error) {
         return err;

package/dist/index.d.cts

@@ -62,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
  *
@@ -83,9 +95,12 @@ export declare namespace Result {
     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 $retry: typeof retry;
+    var $safeRetry: typeof safeRetry;
 }
 /**
  * Create a new {@link Result} with the `Ok` variant. When called without
@@ -129,6 +144,9 @@ 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>;
+/**
+ * @TODO
+ */
 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
@@ -224,6 +242,10 @@ declare function nonNullable<const T, E>(value: T, error: () => E): Result<NonNu
  */
 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>;
+/**
+ * @TODO
+ */
+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`.
@@ -421,6 +443,15 @@ declare function safeAsync<T, E>(f: () => T | PromiseLike<T>, mapError: (err: un
  */
 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>;
+/**
+ * @TODO
+ */
+declare function retry<T, E>(f: () => Retuple<T, E> | PromiseLike<Retuple<T, E>>): ResultRetry<T, E>;
+/**
+ * @TODO
+ */
+declare function safeRetry<T>(f: () => T | PromiseLike<T>): ResultRetry<T, Error>;
+declare function safeRetry<T, E>(f: () => T | PromiseLike<T>, mapError: (err: unknown) => E): ResultRetry<T, E>;
 /**
  * ## RetupleArray
  *
@@ -934,12 +965,42 @@ declare class ResultAsync<T, E> {
      */
     $iter<U>(this: ResultAsync<Iterable<U>, E>): Promise<IterableIterator<U, undefined, unknown>>;
 }
-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 RetupleAwaitable<T, E> = Retuple<T, E> | PromiseLike<Retuple<T, E>>;
+interface ResultRetryMonitor<E> {
+    error: E;
+    attempt: number;
+    abort: () => void;
+}
+/**
+ * @TODO
+ */
+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: () => RetupleAwaitable<T, E>);
+    then<U = Result<T, E>, F = never>(onfulfilled?: ((value: Result<T, E>) => U | PromiseLike<U>) | null | undefined, onrejected?: ((reason: any) => F | PromiseLike<F>) | null | undefined): PromiseLike<U | F>;
+    /**
+     * @TODO - Capped 100
+     */
+    $times<N extends number>(this: ResultRetry<T, E>, times: NonZero<N> & NonNegativeOrDecimal<N>): ResultRetry<T, E>;
+    /**
+     * @TODO - Capped 1 hour
+     */
+    $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>;
+    /**
+     * @TODO
+     */
+    $monitor(f: (state: ResultRetryMonitor<E>) => void): ResultRetry<T, E>;
+    /**
+     * @TODO
+     */
+    $async(this: ResultRetry<T, E>): ResultAsync<T, E>;
+    private drain;
+}
 interface Retuple<T, E> extends RetupleArray<T | E | undefined> {
     /**
      * Returns true when this result is `Ok`. Acts as a type guard.
@@ -1950,3 +2011,21 @@ 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 ThisOk<T> = OkTuple<T> & Retuple<T, never>;
+type ThisErr<E> = ErrTuple<E> & Retuple<never, E>;
+type RetupleAwaitable<T, E> = Retuple<T, E> | PromiseLike<Retuple<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);

package/dist/index.d.ts

@@ -62,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
  *
@@ -83,9 +95,12 @@ export declare namespace Result {
     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 $retry: typeof retry;
+    var $safeRetry: typeof safeRetry;
 }
 /**
  * Create a new {@link Result} with the `Ok` variant. When called without
@@ -129,6 +144,9 @@ 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>;
+/**
+ * @TODO
+ */
 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
@@ -224,6 +242,10 @@ declare function nonNullable<const T, E>(value: T, error: () => E): Result<NonNu
  */
 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>;
+/**
+ * @TODO
+ */
+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`.
@@ -421,6 +443,15 @@ declare function safeAsync<T, E>(f: () => T | PromiseLike<T>, mapError: (err: un
  */
 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>;
+/**
+ * @TODO
+ */
+declare function retry<T, E>(f: () => Retuple<T, E> | PromiseLike<Retuple<T, E>>): ResultRetry<T, E>;
+/**
+ * @TODO
+ */
+declare function safeRetry<T>(f: () => T | PromiseLike<T>): ResultRetry<T, Error>;
+declare function safeRetry<T, E>(f: () => T | PromiseLike<T>, mapError: (err: unknown) => E): ResultRetry<T, E>;
 /**
  * ## RetupleArray
  *
@@ -934,12 +965,42 @@ declare class ResultAsync<T, E> {
      */
     $iter<U>(this: ResultAsync<Iterable<U>, E>): Promise<IterableIterator<U, undefined, unknown>>;
 }
-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 RetupleAwaitable<T, E> = Retuple<T, E> | PromiseLike<Retuple<T, E>>;
+interface ResultRetryMonitor<E> {
+    error: E;
+    attempt: number;
+    abort: () => void;
+}
+/**
+ * @TODO
+ */
+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: () => RetupleAwaitable<T, E>);
+    then<U = Result<T, E>, F = never>(onfulfilled?: ((value: Result<T, E>) => U | PromiseLike<U>) | null | undefined, onrejected?: ((reason: any) => F | PromiseLike<F>) | null | undefined): PromiseLike<U | F>;
+    /**
+     * @TODO - Capped 100
+     */
+    $times<N extends number>(this: ResultRetry<T, E>, times: NonZero<N> & NonNegativeOrDecimal<N>): ResultRetry<T, E>;
+    /**
+     * @TODO - Capped 1 hour
+     */
+    $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>;
+    /**
+     * @TODO
+     */
+    $monitor(f: (state: ResultRetryMonitor<E>) => void): ResultRetry<T, E>;
+    /**
+     * @TODO
+     */
+    $async(this: ResultRetry<T, E>): ResultAsync<T, E>;
+    private drain;
+}
 interface Retuple<T, E> extends RetupleArray<T | E | undefined> {
     /**
      * Returns true when this result is `Ok`. Acts as a type guard.
@@ -1950,3 +2011,21 @@ 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 ThisOk<T> = OkTuple<T> & Retuple<T, never>;
+type ThisErr<E> = ErrTuple<E> & Retuple<never, E>;
+type RetupleAwaitable<T, E> = Retuple<T, E> | PromiseLike<Retuple<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);

package/dist/index.js

@@ -9,7 +9,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _ResultAsync_inner;
+var _ResultAsync_inner, _a, _ResultRetry_f, _ResultRetry_promise, _ResultRetry_times, _ResultRetry_attempt, _ResultRetry_aborted, _ResultRetry_abort, _ResultRetry_getDelay, _ResultRetry_errorHandler;
 /**
  * ## Retuple Unwrap Failed
  *
@@ -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
  *
@@ -115,9 +130,12 @@ Result.Err = Err;
 Result.$resolve = resolve;
 Result.$nonNullable = nonNullable;
 Result.$truthy = truthy;
+Result.$union = union;
 Result.$safe = safe;
 Result.$safeAsync = safeAsync;
 Result.$safePromise = safePromise;
+Result.$retry = retry;
+Result.$safeRetry = safeRetry;
 Object.freeze(Result);
 export function Ok(val) {
     return new ResultOk(val);
@@ -125,6 +143,9 @@ export function Ok(val) {
 export function Err(err) {
     return new ResultErr(err);
 }
+/**
+ * @TODO
+ */
 function resolve(result) {
     if (result instanceof ResultAsync) {
         return result;
@@ -148,6 +169,18 @@ function truthy(value, error = mapTrue) {
     }
     return Err(error());
 }
+/**
+ * @TODO
+ */
+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());
@@ -169,6 +202,22 @@ function safeAsync(f, mapError = ensureError) {
 function safePromise(promise, mapError = ensureError) {
     return new ResultAsync(promise.then((Ok), async (err) => Err(await mapError(err))));
 }
+/**
+ * @TODO
+ */
+function retry(f) {
+    return new ResultRetry(f);
+}
+function safeRetry(f, mapError = ensureError) {
+    return new ResultRetry(async () => {
+        try {
+            return Ok(await f());
+        }
+        catch (err) {
+            return Err(mapError(err));
+        }
+    });
+}
 /**
  * ## RetupleArray
  *
@@ -1069,6 +1118,96 @@ class ResultAsync {
     }
 }
 _ResultAsync_inner = new WeakMap();
+/**
+ * @TODO
+ */
+class ResultRetry {
+    static zero() {
+        return 0;
+    }
+    static delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, Math.min(ms, _a.MAX_TIMEOUT)));
+    }
+    static integer(value) {
+        if (typeof value === "number" && Number.isInteger(value)) {
+            return Math.max(0, value);
+        }
+        return 0;
+    }
+    constructor(f) {
+        _ResultRetry_f.set(this, void 0);
+        _ResultRetry_promise.set(this, void 0);
+        _ResultRetry_times.set(this, 1);
+        _ResultRetry_attempt.set(this, 0);
+        _ResultRetry_aborted.set(this, false);
+        _ResultRetry_abort.set(this, () => (__classPrivateFieldSet(this, _ResultRetry_aborted, true, "f")));
+        _ResultRetry_getDelay.set(this, _a.zero);
+        _ResultRetry_errorHandler.set(this, void 0);
+        __classPrivateFieldSet(this, _ResultRetry_f, f, "f");
+        __classPrivateFieldSet(this, _ResultRetry_promise, this.drain(), "f");
+    }
+    then(onfulfilled, onrejected) {
+        return __classPrivateFieldGet(this, _ResultRetry_promise, "f").then(onfulfilled, onrejected);
+    }
+    /**
+     * @TODO - Capped 100
+     */
+    $times(times) {
+        __classPrivateFieldSet(this, _ResultRetry_times, Math.min(Math.max(1, _a.integer(times)), _a.MAX_RETRY), "f");
+        return this;
+    }
+    $delay(fnOrMs) {
+        if (typeof fnOrMs === "function") {
+            __classPrivateFieldSet(this, _ResultRetry_getDelay, fnOrMs, "f");
+            return this;
+        }
+        const delay = _a.integer(fnOrMs);
+        if (delay > 0) {
+            __classPrivateFieldSet(this, _ResultRetry_getDelay, () => delay, "f");
+        }
+        return this;
+    }
+    /**
+     * @TODO
+     */
+    $monitor(f) {
+        __classPrivateFieldSet(this, _ResultRetry_errorHandler, f, "f");
+        return this;
+    }
+    /**
+     * @TODO
+     */
+    $async() {
+        return new ResultAsync(this);
+    }
+    async drain() {
+        var _b;
+        while (__classPrivateFieldGet(this, _ResultRetry_attempt, "f") < __classPrivateFieldGet(this, _ResultRetry_times, "f")) {
+            const result = await __classPrivateFieldGet(this, _ResultRetry_f, "f").call(this);
+            __classPrivateFieldSet(this, _ResultRetry_attempt, (_b = __classPrivateFieldGet(this, _ResultRetry_attempt, "f"), _b++, _b), "f");
+            if (result.$isOk()) {
+                return result;
+            }
+            if (__classPrivateFieldGet(this, _ResultRetry_errorHandler, "f")) {
+                await __classPrivateFieldGet(this, _ResultRetry_errorHandler, "f").call(this, {
+                    error: result[0],
+                    attempt: __classPrivateFieldGet(this, _ResultRetry_attempt, "f"),
+                    abort: __classPrivateFieldGet(this, _ResultRetry_abort, "f"),
+                });
+            }
+            if (__classPrivateFieldGet(this, _ResultRetry_aborted, "f") || __classPrivateFieldGet(this, _ResultRetry_attempt, "f") === __classPrivateFieldGet(this, _ResultRetry_times, "f")) {
+                return result;
+            }
+            const delay = _a.integer(__classPrivateFieldGet(this, _ResultRetry_getDelay, "f").call(this, __classPrivateFieldGet(this, _ResultRetry_attempt, "f")));
+            if (delay > 0) {
+                await _a.delay(delay);
+            }
+        }
+    }
+}
+_a = ResultRetry, _ResultRetry_f = new WeakMap(), _ResultRetry_promise = new WeakMap(), _ResultRetry_times = new WeakMap(), _ResultRetry_attempt = new WeakMap(), _ResultRetry_aborted = new WeakMap(), _ResultRetry_abort = new WeakMap(), _ResultRetry_getDelay = new WeakMap(), _ResultRetry_errorHandler = new WeakMap();
+ResultRetry.MAX_TIMEOUT = 3600000;
+ResultRetry.MAX_RETRY = 100;
 function ensureError(err) {
     if (err instanceof Error) {
         return err;

package/package.json

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