retuple 1.0.0-next.2 → 1.0.0-next.21

package/dist/index.cjs

@@ -10,15 +10,18 @@ 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_handler;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Result = exports.RetupleThrownValueError = exports.RetupleExpectFailed = exports.RetupleUnwrapErrFailed = exports.RetupleUnwrapFailed = void 0;
+exports.RetupleInvalidUnionError = exports.RetupleCaughtValueError = exports.RetupleExpectFailed = exports.RetupleUnwrapErrFailed = exports.RetupleUnwrapFailed = void 0;
+exports.Result = Result;
 exports.Ok = Ok;
 exports.Err = Err;
-exports.from = from;
-exports.safe = safe;
-exports.safeAsync = safeAsync;
-exports.safePromise = safePromise;
+const retuple_symbols_1 = require("retuple-symbols");
+/**
+ * ## Retuple Unwrap Failed
+ *
+ * An error which occurs when calling `$unwrap` on `Err`.
+ */
 class RetupleUnwrapFailed extends Error {
     constructor(value, msg = "Unwrap failed") {
         super(msg, value instanceof Error ? { cause: value } : undefined);
@@ -26,6 +29,11 @@ class RetupleUnwrapFailed extends Error {
     }
 }
 exports.RetupleUnwrapFailed = RetupleUnwrapFailed;
+/**
+ * ## Retuple Unwrap Err Failed
+ *
+ * An error which occurs when calling `$unwrapErr` on `Ok`.
+ */
 class RetupleUnwrapErrFailed extends Error {
     constructor(value, msg = "Unwrap error failed") {
         super(msg);
@@ -33,6 +41,12 @@ class RetupleUnwrapErrFailed extends Error {
     }
 }
 exports.RetupleUnwrapErrFailed = RetupleUnwrapErrFailed;
+/**
+ * ## Retuple Expect Failed
+ *
+ * An error which occurs when calling `$expect` on `Err`, when the value
+ * contained in the `Err` is not an instance of `Error`.
+ */
 class RetupleExpectFailed extends Error {
     constructor(value) {
         super("Expect failed");
@@ -40,43 +54,175 @@ class RetupleExpectFailed extends Error {
     }
 }
 exports.RetupleExpectFailed = RetupleExpectFailed;
-class RetupleThrownValueError extends Error {
+/**
+ * ## Retuple Thrown Value Error
+ *
+ * An error constructed when a safe function call throws or rejects, when the
+ * thrown error or rejected value is not an instance of `Error`, and when no
+ * map error function is provided.
+ */
+class RetupleCaughtValueError extends Error {
     constructor(value) {
         super("Caught value was not an instance of Error");
         this.value = value;
     }
 }
-exports.RetupleThrownValueError = RetupleThrownValueError;
+exports.RetupleCaughtValueError = RetupleCaughtValueError;
+/**
+ * ## 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;
 /**
  * ## Result
  *
  * @TODO
  */
-exports.Result = {
-    Ok,
-    Err,
-    from,
-    safe,
-    safeAsync,
-    safePromise,
-};
-exports.default = exports.Result;
+function Result(resultLike) {
+    return asResult(resultLike);
+}
+Result.Ok = Ok;
+Result.Err = Err;
+Result.$from = $from;
+Result.$resolve = $resolve;
+Result.$nonNullable = $nonNullable;
+Result.$truthy = $truthy;
+Result.$fromUnion = $fromUnion;
+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);
 }
 function Err(err) {
     return new ResultErr(err);
 }
-function from(value, error) {
+/**
+ * Construct a {@link Result} from a {@link ResultLike}.
+ *
+ * @example
+ *
+ * ```ts
+ * const value: Result<T, E> | ResultLike<T, E> = someResultFn();
+ * const result: Result<T, E> = Result.$from(result);
+ * ```
+ */
+function $from(result) {
+    if (result instanceof ResultOk || result instanceof ResultErr) {
+        return result;
+    }
+    return asResult(result);
+}
+/**
+ * Construct a {@link ResultAsync} from a {@link ResultLikeAwaitable}.
+ *
+ * @example
+ *
+ * ```ts
+ * const value:
+ *    | Result<T, E>
+ *    | ResultLike<T, E>
+ *    | ResultAsync<T, E>
+ *    | Promise<Result<T, E>>
+ *    | Promise<ResultLike<T, E>>
+ *    | PromiseLike<Result<T, E>>
+ *    | PromiseLike<ResultLike<T, E>> = someResultFn();
+ *
+ * const result: ResultAsync<T, E> = Result.$resolve(result);
+ * ```
+ */
+function $resolve(result) {
+    switch (true) {
+        case result instanceof ResultAsync:
+            return result;
+        case result instanceof ResultOk:
+        case result instanceof ResultErr:
+            return new ResultAsync(Promise.resolve(result));
+        default:
+            return new ResultAsync(Promise.resolve(result).then((asResult)));
+    }
+}
+function $nonNullable(value, error = mapTrue) {
+    if (value !== null && value !== undefined) {
+        return Ok(value);
+    }
+    return Err(error());
+}
+function $truthy(value, error = mapTrue) {
     if (value) {
-        return new ResultOk(value);
+        return Ok(value);
     }
-    if (error) {
-        return new ResultErr(error());
+    return Err(error());
+}
+/**
+ * Construct a {@link Result} from a common discriminated union shape. If the
+ * union is 'success' then 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);
+ * ```
+ */
+function $fromUnion(union) {
+    if (union.success === true) {
+        return Ok(union.data);
+    }
+    if (union.success === false) {
+        return Err(union.error);
     }
-    return new ResultErr(true);
+    throw new RetupleInvalidUnionError(union);
 }
-function safe(f, mapError = ensureError) {
+function $safe(f, mapError = ensureError) {
     try {
         return Ok(f());
     }
@@ -84,7 +230,7 @@ function safe(f, mapError = ensureError) {
         return Err(mapError(err));
     }
 }
-function safeAsync(f, mapError = ensureError) {
+function $safeAsync(f, mapError = ensureError) {
     return new ResultAsync((async () => {
         try {
             return Ok(await f());
@@ -94,13 +240,42 @@ function safeAsync(f, mapError = ensureError) {
         }
     })());
 }
-function safePromise(promise, mapError = ensureError) {
+function $safePromise(promise, mapError = ensureError) {
     return new ResultAsync(promise.then((Ok), async (err) => Err(await mapError(err))));
 }
 /**
- * ## Ok
+ * Construct a {@link ResultRetry} from a function which returns a
+ * {@link Result}. The function will be retried based on provided retry
+ * settings and eventually return a `Result`. No attempt is made to catch
+ * thrown errors or promise rejections.
  *
- * @TODO
+ * To retry a potentially unsafe function, use {@link Result.$safeRetry}.
+ *
+ * @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);
+ * ```
+ */
+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));
+        }
+    });
+}
+/**
+ * ## ResultOk
+ *
+ * This is the `Ok` variant of a `Result`, used internally and not exported.
  */
 class ResultOk extends Array {
     constructor(value) {
@@ -108,14 +283,17 @@ class ResultOk extends Array {
         this[0] = undefined;
         this[1] = value;
     }
-    $value() {
+    [retuple_symbols_1.ResultLikeSymbol]() {
+        return { ok: true, value: this[1] };
+    }
+    toJSON() {
         return this[1];
     }
     $isOk() {
         return true;
     }
     $isOkAnd(f) {
-        return f(this[1]);
+        return !!f(this[1]);
     }
     $isErr() {
         return false;
@@ -139,44 +317,77 @@ class ResultOk extends Array {
         return this[1];
     }
     $map(f) {
-        return new ResultOk(f(this[1]));
+        return Ok(f(this[1]));
     }
     $mapErr() {
         return this;
     }
     $mapOr(_def, f) {
-        return new ResultOk(f(this[1]));
+        return Ok(f(this[1]));
     }
     $mapOrElse(_def, f) {
-        return new ResultOk(f(this[1]));
+        return Ok(f(this[1]));
+    }
+    $andAssertOr(def, condition = isTruthy) {
+        return condition(this[1]) ? this : asResult(def);
+    }
+    $andAssertOrElse(def, condition = isTruthy) {
+        return condition(this[1]) ? this : asResult(def(this[1]));
     }
     $or() {
         return this;
     }
+    $orAsync() {
+        return this.$async();
+    }
     $orElse() {
         return this;
     }
+    $orElseAsync() {
+        return this.$async();
+    }
     $orSafe() {
         return this;
     }
+    $orSafeAsync() {
+        return this.$async();
+    }
+    $orSafePromise() {
+        return this.$async();
+    }
     $and(and) {
-        return and;
+        return asResult(and);
+    }
+    $andAsync(and) {
+        return this.$async().$and(and);
     }
     $andThen(f) {
-        return f(this[1]);
+        return asResult(f(this[1]));
+    }
+    $andThenAsync(f) {
+        return this.$async().$andThen(f);
     }
     $andThrough(f) {
-        const res = f(this[1]);
+        const res = asResult(f(this[1]));
         return res instanceof ResultErr ? res : this;
     }
+    $andThroughAsync(f) {
+        return this.$async().$andThrough(f);
+    }
     $andSafe(f, mapError = ensureError) {
         try {
-            return new ResultOk(f(this[1]));
+            return Ok(f(this[1]));
         }
         catch (err) {
-            return new ResultErr(mapError(err));
+            return Err(mapError(err));
         }
     }
+    $andSafeAsync(f, mapError = ensureError) {
+        return this.$async().$andSafe(f, mapError);
+    }
+    $andSafePromise(promise, mapError = ensureError) {
+        return this.$async().$andSafePromise(promise, mapError);
+    }
     $peek(f) {
         f(this);
         return this;
@@ -197,11 +408,14 @@ class ResultOk extends Array {
     $promise() {
         return Promise.resolve(this);
     }
+    *$iter() {
+        yield* this[1];
+    }
 }
 /**
- * ## Err
+ * ## ResultErr
  *
- * @TODO
+ * This is the `Err` variant of a `Result`, used internally and not exported.
  */
 class ResultErr extends Array {
     constructor(err) {
@@ -209,8 +423,11 @@ class ResultErr extends Array {
         this[0] = err;
         this[1] = undefined;
     }
-    $value() {
-        return this[0];
+    [retuple_symbols_1.ResultLikeSymbol]() {
+        return { ok: false, value: this[0] };
+    }
+    toJSON() {
+        return null;
     }
     $isOk() {
         return false;
@@ -222,7 +439,7 @@ class ResultErr extends Array {
         return true;
     }
     $isErrAnd(f) {
-        return f(this[0]);
+        return !!f(this[0]);
     }
     $expect() {
         if (this[0] instanceof Error) {
@@ -246,40 +463,73 @@ class ResultErr extends Array {
         return this;
     }
     $mapErr(f) {
-        return new ResultErr(f(this[0]));
+        return Err(f(this[0]));
     }
     $mapOr(def) {
-        return new ResultOk(def);
+        return Ok(def);
     }
     $mapOrElse(def) {
-        return new ResultOk(def(this[0]));
+        return Ok(def(this[0]));
+    }
+    $andAssertOr() {
+        return this;
+    }
+    $andAssertOrElse() {
+        return this;
     }
     $or(or) {
-        return or;
+        return asResult(or);
+    }
+    $orAsync(or) {
+        return this.$async().$or(or);
     }
     $orElse(f) {
-        return f(this[0]);
+        return asResult(f(this[0]));
+    }
+    $orElseAsync(f) {
+        return this.$async().$orElse(f);
     }
     $orSafe(f, mapError = ensureError) {
         try {
-            return new ResultOk(f(this[0]));
+            return Ok(f(this[0]));
         }
         catch (err) {
-            return new ResultErr(mapError(err));
+            return Err(mapError(err));
         }
     }
+    $orSafeAsync(f, mapError = ensureError) {
+        return this.$async().$orSafe(f, mapError);
+    }
+    $orSafePromise(promise, mapError = ensureError) {
+        return this.$async().$orSafePromise(promise, mapError);
+    }
     $and() {
         return this;
     }
+    $andAsync() {
+        return this.$async();
+    }
     $andThen() {
         return this;
     }
+    $andThenAsync() {
+        return this.$async();
+    }
     $andThrough() {
         return this;
     }
+    $andThroughAsync() {
+        return this.$async();
+    }
     $andSafe() {
         return this;
     }
+    $andSafeAsync() {
+        return this.$async();
+    }
+    $andSafePromise() {
+        return this.$async();
+    }
     $peek(f) {
         f(this);
         return this;
@@ -300,6 +550,9 @@ class ResultErr extends Array {
     $promise() {
         return Promise.resolve(this);
     }
+    *$iter() {
+        return;
+    }
 }
 /**
  * ## ResultAsync
@@ -315,44 +568,42 @@ class ResultAsync {
         return __classPrivateFieldGet(this, _ResultAsync_inner, "f").then(onfulfilled, onrejected);
     }
     /**
-     * @TODO
-     */
-    async $value() {
-        return (await __classPrivateFieldGet(this, _ResultAsync_inner, "f")).$value();
-    }
-    /**
-     * @TODO
+     * The same as {@link Retuple.$expect|$expect}, except it returns a `Promise`.
      */
     async $expect() {
         return (await __classPrivateFieldGet(this, _ResultAsync_inner, "f")).$expect();
     }
     /**
-     * @TODO
+     * The same as {@link Retuple.$unwrap|$unwrap}, except it returns a `Promise`.
      */
     async $unwrap(msg) {
         return (await __classPrivateFieldGet(this, _ResultAsync_inner, "f")).$unwrap(msg);
     }
     /**
-     * @TODO
+     * The same as {@link Retuple.$unwrapErr|$unwrapErr}, except it returns
+     * a `Promise`.
      */
     async $unwrapErr(msg) {
         return (await __classPrivateFieldGet(this, _ResultAsync_inner, "f")).$unwrapErr(msg);
     }
     /**
-     * @TODO
+     * The same as {@link Retuple.$unwrapOr|$unwrapOr}, except it returns
+     * a `Promise`.
      */
     async $unwrapOr(def) {
         return (await __classPrivateFieldGet(this, _ResultAsync_inner, "f")).$unwrapOr(def);
     }
     /**
-     * @TODO
+     * The same as {@link Retuple.$unwrapOrElse|$unwrapOrElse}, except it returns
+     * a `Promise`.
      */
     async $unwrapOrElse(f) {
         const res = await __classPrivateFieldGet(this, _ResultAsync_inner, "f");
         return res instanceof ResultOk ? res[1] : f();
     }
     /**
-     * @TODO
+     * The same as {@link Retuple.$map|$map}, except it returns
+     * {@link ResultAsync}.
      */
     $map(f) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
@@ -362,7 +613,8 @@ class ResultAsync {
         }));
     }
     /**
-     * @TODO
+     * The same as {@link Retuple.$mapErr|$mapErr}, except it returns
+     * {@link ResultAsync}.
      */
     $mapErr(f) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
@@ -372,7 +624,8 @@ class ResultAsync {
         }));
     }
     /**
-     * @TODO
+     * The same as {@link Retuple.$mapOr|$mapOr}, except it returns
+     * {@link ResultAsync}.
      */
     $mapOr(def, f) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
@@ -382,7 +635,8 @@ class ResultAsync {
         }));
     }
     /**
-     * @TODO
+     * The same as {@link Retuple.$mapOrElse|$mapOrElse}, except it returns
+     * {@link ResultAsync}.
      */
     $mapOrElse(def, f) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
@@ -391,25 +645,36 @@ class ResultAsync {
                 : new ResultOk(def(res[0]));
         }));
     }
-    /**
-     * @TODO
-     */
+    $andAssertOr(def, condition = isTruthy) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            if (res instanceof ResultErr || condition(res[1])) {
+                return res;
+            }
+            return asResult(await def);
+        }));
+    }
+    $andAssertOrElse(def, condition = isTruthy) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            if (res instanceof ResultErr || condition(res[1])) {
+                return res;
+            }
+            return asResult(await def(res[1]));
+        }));
+    }
     $or(or) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
-            return res instanceof ResultErr ? await or : res;
+            return res instanceof ResultErr
+                ? asResult(await or)
+                : res;
         }));
     }
-    /**
-     * @TODO
-     */
     $orElse(f) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
-            return res instanceof ResultErr ? await f(res[0]) : res;
+            return res instanceof ResultErr
+                ? asResult(await f(res[0]))
+                : res;
         }));
     }
-    /**
-     * @TODO
-     */
     $orSafe(f, mapError = ensureError) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
             if (res instanceof ResultOk) {
@@ -423,29 +688,37 @@ class ResultAsync {
             }
         }));
     }
-    /**
-     * @TODO
-     */
+    $orSafePromise(promise, mapError = ensureError) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            if (res instanceof ResultOk) {
+                return res;
+            }
+            try {
+                return new ResultOk(await promise);
+            }
+            catch (err) {
+                return new ResultErr(mapError(err));
+            }
+        }));
+    }
     $and(and) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
-            return res instanceof ResultOk ? await and : res;
+            return res instanceof ResultOk
+                ? asResult(await and)
+                : res;
         }));
     }
-    /**
-     * @TODO
-     */
     $andThen(f) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
-            return res instanceof ResultOk ? await f(res[1]) : res;
+            return res instanceof ResultOk
+                ? asResult(await f(res[1]))
+                : res;
         }));
     }
-    /**
-     * @TODO
-     */
     $andThrough(f) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
             if (res instanceof ResultOk) {
-                const through = await f(res[1]);
+                const through = asResult(await f(res[1]));
                 if (through instanceof ResultErr) {
                     return through;
                 }
@@ -453,24 +726,37 @@ class ResultAsync {
             return res;
         }));
     }
-    /**
-     * @TODO
-     */
     $andSafe(f, mapError = ensureError) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
             if (res instanceof ResultErr) {
                 return res;
             }
             try {
-                return new ResultOk(await f(res[1]));
+                return Ok(await f(res[1]));
             }
             catch (err) {
-                return new ResultErr(mapError(err));
+                return Err(mapError(err));
+            }
+        }));
+    }
+    $andSafePromise(promise, mapError = ensureError) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            if (res instanceof ResultErr) {
+                return res;
+            }
+            try {
+                return Ok(await promise);
+            }
+            catch (err) {
+                return Err(mapError(err));
             }
         }));
     }
     /**
-     * @TODO
+     * The same as {@link Retuple.$peek|$peek}, except it:
+     *
+     * - awaits the peek function;
+     * - returns {@link ResultAsync}.
      */
     $peek(f) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
@@ -479,7 +765,10 @@ class ResultAsync {
         }));
     }
     /**
-     * @TODO
+     * The same as {@link Retuple.$tap|$tap}, except it:
+     *
+     * - awaits the tap function;
+     * - returns {@link ResultAsync}.
      */
     $tap(f) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
@@ -490,7 +779,10 @@ class ResultAsync {
         }));
     }
     /**
-     * @TODO
+     * The same as {@link Retuple.$tapErr|$tapErr}, except it:
+     *
+     * - awaits the tap error function;
+     * - returns {@link ResultAsync}.
      */
     $tapErr(f) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
@@ -501,31 +793,165 @@ class ResultAsync {
         }));
     }
     /**
-     * @TODO
+     * The same as {@link Retuple.$promise|$promise}.
      */
     $promise() {
         return Promise.resolve(this);
     }
+    /**
+     * The same as {@link Retuple.$iter|$iter}, except it returns a `Promise`.
+     */
+    async $iter() {
+        return (await __classPrivateFieldGet(this, _ResultAsync_inner, "f")).$iter();
+    }
 }
 _ResultAsync_inner = new WeakMap();
+/**
+ * ## ResultRetry
+ */
+class ResultRetry extends ResultAsync {
+    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) {
+        super(Promise.resolve().then(() => __classPrivateFieldGet(this, _ResultRetry_promise, "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_handler.set(this, void 0);
+        __classPrivateFieldSet(this, _ResultRetry_f, f, "f");
+        __classPrivateFieldSet(this, _ResultRetry_promise, this.drain(), "f");
+    }
+    then(onfulfilled, onrejected) {
+        return super.then(onfulfilled, onrejected);
+    }
+    /**
+     * 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);
+     * ```
+     */
+    $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;
+    }
+    /**
+     * 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) {
+        __classPrivateFieldSet(this, _ResultRetry_handler, f, "f");
+        return this;
+    }
+    async drain() {
+        var _b;
+        while (__classPrivateFieldGet(this, _ResultRetry_attempt, "f") < __classPrivateFieldGet(this, _ResultRetry_times, "f")) {
+            const result = asResult(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_handler, "f")) {
+                await __classPrivateFieldGet(this, _ResultRetry_handler, "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);
+            }
+        }
+        /* v8 ignore next */
+        throw new Error("Retuple: Unreachable code executed");
+    }
+}
+_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_handler = new WeakMap();
+ResultRetry.MAX_TIMEOUT = 3600000;
+ResultRetry.MAX_RETRY = 100;
+function asResult(resultLike) {
+    if (resultLike instanceof ResultOk || resultLike instanceof ResultErr) {
+        return resultLike;
+    }
+    const result = resultLike[retuple_symbols_1.ResultLikeSymbol]();
+    return result.ok ? new ResultOk(result.value) : new ResultErr(result.value);
+}
 function ensureError(err) {
     if (err instanceof Error) {
         return err;
     }
-    return new RetupleThrownValueError(err);
+    return new RetupleCaughtValueError(err);
+}
+function mapTrue() {
+    return true;
+}
+function isTruthy(val) {
+    return !!val;
 }
-Object.freeze(exports.Result);
-Object.freeze(ResultOk);
-Object.freeze(ResultErr);
-Object.freeze(ResultAsync);
-Object.freeze(RetupleUnwrapFailed);
-Object.freeze(RetupleUnwrapErrFailed);
-Object.freeze(RetupleExpectFailed);
-Object.freeze(RetupleThrownValueError);
-Object.freeze(ResultOk.prototype);
-Object.freeze(ResultErr.prototype);
-Object.freeze(ResultAsync.prototype);
-Object.freeze(RetupleUnwrapFailed.prototype);
-Object.freeze(RetupleUnwrapErrFailed.prototype);
-Object.freeze(RetupleExpectFailed.prototype);
-Object.freeze(RetupleThrownValueError.prototype);