retuple 1.0.0-next.16 → 1.0.0-next.18

package/dist/index.cjs

@@ -162,8 +162,6 @@ function $resolve(result) {
     switch (true) {
         case result instanceof ResultAsync:
             return result;
-        case result instanceof ResultRetry:
-            return new ResultAsync(result);
         case result instanceof ResultOk:
         case result instanceof ResultErr:
             return new ResultAsync(Promise.resolve(result));
@@ -740,22 +738,43 @@ class ResultOk extends RetupleArray {
     $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 asResult(and);
     }
+    $andAsync(and) {
+        return this.$async().$and(and);
+    }
     $andThen(f) {
         return asResult(f(this[1]));
     }
+    $andThenAsync(f) {
+        return this.$async().$andThen(f);
+    }
     $andThrough(f) {
         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 Ok(f(this[1]));
@@ -764,6 +783,12 @@ class ResultOk extends RetupleArray {
             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;
@@ -856,9 +881,15 @@ class ResultErr extends RetupleArray {
     $or(or) {
         return asResult(or);
     }
+    $orAsync(or) {
+        return this.$async().$or(or);
+    }
     $orElse(f) {
         return asResult(f(this[0]));
     }
+    $orElseAsync(f) {
+        return this.$async().$orElse(f);
+    }
     $orSafe(f, mapError = ensureError) {
         try {
             return Ok(f(this[0]));
@@ -867,18 +898,39 @@ class ResultErr extends RetupleArray {
             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;
@@ -1158,7 +1210,7 @@ _ResultAsync_inner = new WeakMap();
 /**
  * ## ResultRetry
  */
-class ResultRetry {
+class ResultRetry extends ResultAsync {
     static zero() {
         return 0;
     }
@@ -1172,6 +1224,7 @@ class ResultRetry {
         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);
@@ -1184,7 +1237,7 @@ class ResultRetry {
         __classPrivateFieldSet(this, _ResultRetry_promise, this.drain(), "f");
     }
     then(onfulfilled, onrejected) {
-        return __classPrivateFieldGet(this, _ResultRetry_promise, "f").then(onfulfilled, onrejected);
+        return super.then(onfulfilled, onrejected);
     }
     /**
      * Sets the maximum number of times the retry function can be executed,
@@ -1254,39 +1307,6 @@ class ResultRetry {
         __classPrivateFieldSet(this, _ResultRetry_handler, f, "f");
         return this;
     }
-    /**
-     * 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() {
-        return new ResultAsync(this);
-    }
-    /**
-     * 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() {
-        return Promise.resolve(this);
-    }
     async drain() {
         var _b;
         while (__classPrivateFieldGet(this, _ResultRetry_attempt, "f") < __classPrivateFieldGet(this, _ResultRetry_times, "f")) {

package/dist/index.d.cts

@@ -644,7 +644,7 @@ declare class ResultAsync<T, E> {
 /**
  * ## ResultRetry
  */
-declare class ResultRetry<T, E> implements PromiseLike<Result<T, E>> {
+declare class ResultRetry<T, E> extends ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
     #private;
     private static MAX_TIMEOUT;
     private static MAX_RETRY;
@@ -731,35 +731,6 @@ declare class ResultRetry<T, E> implements PromiseLike<Result<T, E>> {
      * ```
      */
     $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;
 }
 interface Retuple<T, E> extends RetupleArray<T | E | undefined>, ResultLike<T, E> {
@@ -1375,6 +1346,10 @@ interface Retuple<T, E> extends RetupleArray<T | E | undefined>, ResultLike<T, E
      * ```
      */
     $or<U = T, F = E>(this: Result<T, E>, or: ResultLike<U, F>): Result<T | U, F>;
+    /**
+     * Shorthand for `result.$async().$or(...)`
+     */
+    $orAsync<U = T, F = E>(this: Result<T, E>, or: ResultLikeAwaitable<U, F>): ResultAsync<T | U, F>;
     /**
      * Returns the result returned by the or function, when this result is `Err`.
      *
@@ -1411,6 +1386,10 @@ interface Retuple<T, E> extends RetupleArray<T | E | undefined>, ResultLike<T, E
      * ```
      */
     $orElse<U = T, F = E>(this: Result<T, E>, f: (err: E) => ResultLike<U, F>): Result<T | U, F>;
+    /**
+     * Shorthand for `result.$async().$orElse(...)`
+     */
+    $orElseAsync<U = T, F = E>(this: Result<T, E>, f: (err: E) => ResultLikeAwaitable<U, F>): ResultAsync<T | U, F>;
     /**
      * Returns a {@link Result} based on the outcome of the safe function when
      * this result is `Err`.
@@ -1422,6 +1401,16 @@ interface Retuple<T, E> extends RetupleArray<T | E | undefined>, ResultLike<T, E
      */
     $orSafe<U = T>(this: Result<T, E>, f: (err: E) => U): Result<T | U, Error>;
     $orSafe<U = T, F = E>(this: Result<T, E>, f: (err: E) => U, mapError: (err: unknown) => F): Result<T | U, F>;
+    /**
+     * Shorthand for `result.$async().$orSafe(...)`
+     */
+    $orSafeAsync<U = T>(this: Result<T, E>, f: (err: E) => U | PromiseLike<U>): ResultAsync<T | U, Error>;
+    $orSafeAsync<U = T, F = E>(this: Result<T, E>, f: (err: E) => U | PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<T | U, F>;
+    /**
+     * Shorthand for `result.$async().$orSafePromise(...)`
+     */
+    $orSafePromise<U = T>(this: Result<T, E>, promise: PromiseLike<U>): ResultAsync<T | U, Error>;
+    $orSafePromise<U = T, F = E>(this: Result<T, E>, promise: PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<T | U, F>;
     /**
      * Returns the and result, when this result is `Ok`.
      *
@@ -1458,6 +1447,10 @@ interface Retuple<T, E> extends RetupleArray<T | E | undefined>, ResultLike<T, E
      * ```
      */
     $and<U = T, F = E>(this: Result<T, E>, and: ResultLike<U, F>): Result<U, E | F>;
+    /**
+     * Shorthand for `result.$async().$and(...)`
+     */
+    $andAsync<U = T, F = E>(this: Result<T, E>, and: ResultLikeAwaitable<U, F>): ResultAsync<U, E | F>;
     /**
      * Returns the and result, when this result is `Ok`.
      *
@@ -1494,6 +1487,10 @@ interface Retuple<T, E> extends RetupleArray<T | E | undefined>, ResultLike<T, E
      * ```
      */
     $andThen<U = T, F = E>(this: Result<T, E>, f: (val: T) => ResultLike<U, F>): Result<U, E | F>;
+    /**
+     * Shorthand for `result.$async().$andThen(...)`
+     */
+    $andThenAsync<U = T, F = E>(this: Result<T, E>, f: (val: T) => ResultLikeAwaitable<U, F>): ResultAsync<U, E | F>;
     /**
      * Calls the through function when this result is `Ok` and returns:
      *
@@ -1534,6 +1531,10 @@ interface Retuple<T, E> extends RetupleArray<T | E | undefined>, ResultLike<T, E
      * ```
      */
     $andThrough<F = E>(this: Result<T, E>, f: (val: T) => ResultLike<any, F>): Result<T, E | F>;
+    /**
+     * Shorthand for `result.$async().$andThrough(...)`
+     */
+    $andThroughAsync<F = E>(this: Result<T, E>, f: (val: T) => ResultLikeAwaitable<any, F>): ResultAsync<T, E | F>;
     /**
      * Returns a result based on the outcome of the safe function when this
      * result is `Ok`.
@@ -1548,6 +1549,16 @@ interface Retuple<T, E> extends RetupleArray<T | E | undefined>, ResultLike<T, E
      */
     $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>;
+    /**
+     * Shorthand for `result.$async().$andSafe(...)`
+     */
+    $andSafeAsync<U = T>(this: Result<T, E>, f: (val: T) => U | PromiseLike<U>): ResultAsync<U, E | Error>;
+    $andSafeAsync<U = T, F = E>(this: Result<T, E>, f: (val: T) => U | PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<U, E | F>;
+    /**
+     * Shorthand for `result.$async().$andSafePromise(...)`
+     */
+    $andSafePromise<U = T>(this: Result<T, E>, promise: PromiseLike<U>): ResultAsync<U, E | Error>;
+    $andSafePromise<U = T, F = E>(this: Result<T, E>, promise: PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<U, E | F>;
     /**
      * Calls the peek function and returns {@link Result} equivalent to this
      * result.

package/dist/index.d.ts

@@ -644,7 +644,7 @@ declare class ResultAsync<T, E> {
 /**
  * ## ResultRetry
  */
-declare class ResultRetry<T, E> implements PromiseLike<Result<T, E>> {
+declare class ResultRetry<T, E> extends ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
     #private;
     private static MAX_TIMEOUT;
     private static MAX_RETRY;
@@ -731,35 +731,6 @@ declare class ResultRetry<T, E> implements PromiseLike<Result<T, E>> {
      * ```
      */
     $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;
 }
 interface Retuple<T, E> extends RetupleArray<T | E | undefined>, ResultLike<T, E> {
@@ -1375,6 +1346,10 @@ interface Retuple<T, E> extends RetupleArray<T | E | undefined>, ResultLike<T, E
      * ```
      */
     $or<U = T, F = E>(this: Result<T, E>, or: ResultLike<U, F>): Result<T | U, F>;
+    /**
+     * Shorthand for `result.$async().$or(...)`
+     */
+    $orAsync<U = T, F = E>(this: Result<T, E>, or: ResultLikeAwaitable<U, F>): ResultAsync<T | U, F>;
     /**
      * Returns the result returned by the or function, when this result is `Err`.
      *
@@ -1411,6 +1386,10 @@ interface Retuple<T, E> extends RetupleArray<T | E | undefined>, ResultLike<T, E
      * ```
      */
     $orElse<U = T, F = E>(this: Result<T, E>, f: (err: E) => ResultLike<U, F>): Result<T | U, F>;
+    /**
+     * Shorthand for `result.$async().$orElse(...)`
+     */
+    $orElseAsync<U = T, F = E>(this: Result<T, E>, f: (err: E) => ResultLikeAwaitable<U, F>): ResultAsync<T | U, F>;
     /**
      * Returns a {@link Result} based on the outcome of the safe function when
      * this result is `Err`.
@@ -1422,6 +1401,16 @@ interface Retuple<T, E> extends RetupleArray<T | E | undefined>, ResultLike<T, E
      */
     $orSafe<U = T>(this: Result<T, E>, f: (err: E) => U): Result<T | U, Error>;
     $orSafe<U = T, F = E>(this: Result<T, E>, f: (err: E) => U, mapError: (err: unknown) => F): Result<T | U, F>;
+    /**
+     * Shorthand for `result.$async().$orSafe(...)`
+     */
+    $orSafeAsync<U = T>(this: Result<T, E>, f: (err: E) => U | PromiseLike<U>): ResultAsync<T | U, Error>;
+    $orSafeAsync<U = T, F = E>(this: Result<T, E>, f: (err: E) => U | PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<T | U, F>;
+    /**
+     * Shorthand for `result.$async().$orSafePromise(...)`
+     */
+    $orSafePromise<U = T>(this: Result<T, E>, promise: PromiseLike<U>): ResultAsync<T | U, Error>;
+    $orSafePromise<U = T, F = E>(this: Result<T, E>, promise: PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<T | U, F>;
     /**
      * Returns the and result, when this result is `Ok`.
      *
@@ -1458,6 +1447,10 @@ interface Retuple<T, E> extends RetupleArray<T | E | undefined>, ResultLike<T, E
      * ```
      */
     $and<U = T, F = E>(this: Result<T, E>, and: ResultLike<U, F>): Result<U, E | F>;
+    /**
+     * Shorthand for `result.$async().$and(...)`
+     */
+    $andAsync<U = T, F = E>(this: Result<T, E>, and: ResultLikeAwaitable<U, F>): ResultAsync<U, E | F>;
     /**
      * Returns the and result, when this result is `Ok`.
      *
@@ -1494,6 +1487,10 @@ interface Retuple<T, E> extends RetupleArray<T | E | undefined>, ResultLike<T, E
      * ```
      */
     $andThen<U = T, F = E>(this: Result<T, E>, f: (val: T) => ResultLike<U, F>): Result<U, E | F>;
+    /**
+     * Shorthand for `result.$async().$andThen(...)`
+     */
+    $andThenAsync<U = T, F = E>(this: Result<T, E>, f: (val: T) => ResultLikeAwaitable<U, F>): ResultAsync<U, E | F>;
     /**
      * Calls the through function when this result is `Ok` and returns:
      *
@@ -1534,6 +1531,10 @@ interface Retuple<T, E> extends RetupleArray<T | E | undefined>, ResultLike<T, E
      * ```
      */
     $andThrough<F = E>(this: Result<T, E>, f: (val: T) => ResultLike<any, F>): Result<T, E | F>;
+    /**
+     * Shorthand for `result.$async().$andThrough(...)`
+     */
+    $andThroughAsync<F = E>(this: Result<T, E>, f: (val: T) => ResultLikeAwaitable<any, F>): ResultAsync<T, E | F>;
     /**
      * Returns a result based on the outcome of the safe function when this
      * result is `Ok`.
@@ -1548,6 +1549,16 @@ interface Retuple<T, E> extends RetupleArray<T | E | undefined>, ResultLike<T, E
      */
     $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>;
+    /**
+     * Shorthand for `result.$async().$andSafe(...)`
+     */
+    $andSafeAsync<U = T>(this: Result<T, E>, f: (val: T) => U | PromiseLike<U>): ResultAsync<U, E | Error>;
+    $andSafeAsync<U = T, F = E>(this: Result<T, E>, f: (val: T) => U | PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<U, E | F>;
+    /**
+     * Shorthand for `result.$async().$andSafePromise(...)`
+     */
+    $andSafePromise<U = T>(this: Result<T, E>, promise: PromiseLike<U>): ResultAsync<U, E | Error>;
+    $andSafePromise<U = T, F = E>(this: Result<T, E>, promise: PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<U, E | F>;
     /**
      * Calls the peek function and returns {@link Result} equivalent to this
      * result.

package/dist/index.js

@@ -150,8 +150,6 @@ function $resolve(result) {
     switch (true) {
         case result instanceof ResultAsync:
             return result;
-        case result instanceof ResultRetry:
-            return new ResultAsync(result);
         case result instanceof ResultOk:
         case result instanceof ResultErr:
             return new ResultAsync(Promise.resolve(result));
@@ -728,22 +726,43 @@ class ResultOk extends RetupleArray {
     $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 asResult(and);
     }
+    $andAsync(and) {
+        return this.$async().$and(and);
+    }
     $andThen(f) {
         return asResult(f(this[1]));
     }
+    $andThenAsync(f) {
+        return this.$async().$andThen(f);
+    }
     $andThrough(f) {
         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 Ok(f(this[1]));
@@ -752,6 +771,12 @@ class ResultOk extends RetupleArray {
             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;
@@ -844,9 +869,15 @@ class ResultErr extends RetupleArray {
     $or(or) {
         return asResult(or);
     }
+    $orAsync(or) {
+        return this.$async().$or(or);
+    }
     $orElse(f) {
         return asResult(f(this[0]));
     }
+    $orElseAsync(f) {
+        return this.$async().$orElse(f);
+    }
     $orSafe(f, mapError = ensureError) {
         try {
             return Ok(f(this[0]));
@@ -855,18 +886,39 @@ class ResultErr extends RetupleArray {
             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;
@@ -1146,7 +1198,7 @@ _ResultAsync_inner = new WeakMap();
 /**
  * ## ResultRetry
  */
-class ResultRetry {
+class ResultRetry extends ResultAsync {
     static zero() {
         return 0;
     }
@@ -1160,6 +1212,7 @@ class ResultRetry {
         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);
@@ -1172,7 +1225,7 @@ class ResultRetry {
         __classPrivateFieldSet(this, _ResultRetry_promise, this.drain(), "f");
     }
     then(onfulfilled, onrejected) {
-        return __classPrivateFieldGet(this, _ResultRetry_promise, "f").then(onfulfilled, onrejected);
+        return super.then(onfulfilled, onrejected);
     }
     /**
      * Sets the maximum number of times the retry function can be executed,
@@ -1242,39 +1295,6 @@ class ResultRetry {
         __classPrivateFieldSet(this, _ResultRetry_handler, f, "f");
         return this;
     }
-    /**
-     * 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() {
-        return new ResultAsync(this);
-    }
-    /**
-     * 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() {
-        return Promise.resolve(this);
-    }
     async drain() {
         var _b;
         while (__classPrivateFieldGet(this, _ResultRetry_attempt, "f") < __classPrivateFieldGet(this, _ResultRetry_times, "f")) {

package/package.json

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