retuple 1.0.0-next.27 → 1.0.0-next.29

package/dist/index.cjs

@@ -17,6 +17,7 @@ exports.Result = Result;
 exports.Ok = Ok;
 exports.Err = Err;
 const retuple_symbols_1 = require("retuple-symbols");
+const RetupleStackSymbol = Symbol("RetupleStackSymbol");
 /**
  * ## Retuple Unwrap Failed
  *
@@ -664,9 +665,24 @@ class ResultOk extends Array {
     $andThen(f) {
         return asResult(f(this[1]));
     }
+    $andStack(f) {
+        const res = asResult(f(this[1]));
+        if (res instanceof ResultErr) {
+            return res;
+        }
+        if (this[1] instanceof RetupleStack) {
+            return Ok(new RetupleStack(...this[1], res[1]));
+        }
+        else {
+            return Ok(new RetupleStack(this[1], res[1]));
+        }
+    }
     $andThenAsync(f) {
         return this.$async().$andThen(f);
     }
+    $andStackAsync(f) {
+        return this.$async().$andStack(f);
+    }
     $andThrough(f) {
         const res = asResult(f(this[1]));
         return res instanceof ResultErr ? res : this;
@@ -824,9 +840,15 @@ class ResultErr extends Array {
     $andThen() {
         return this;
     }
+    $andStack() {
+        return this;
+    }
     $andThenAsync() {
         return this.$async();
     }
+    $andStackAsync() {
+        return this.$async();
+    }
     $andThrough() {
         return this;
     }
@@ -1067,6 +1089,21 @@ class ResultAsync {
                 : res;
         }));
     }
+    $andStack(f) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            if (res instanceof ResultErr) {
+                return res;
+            }
+            const resThen = asResult(await f(res[1]));
+            if (resThen instanceof ResultErr) {
+                return resThen;
+            }
+            if (res[1] instanceof RetupleStack) {
+                return Ok(new RetupleStack(...res[1], resThen[1]));
+            }
+            return Ok(new RetupleStack(res[1], resThen[1]));
+        }));
+    }
     $andThrough(f) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
             if (res instanceof ResultOk) {
@@ -1311,6 +1348,8 @@ class ResultRetry extends ResultAsync {
 _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;
+class RetupleStack extends Array {
+}
 function asResult(resultLike) {
     if (resultLike instanceof ResultOk || resultLike instanceof ResultErr) {
         return resultLike;

package/dist/index.d.cts

@@ -1,4 +1,5 @@
 import { type ResultLike } from "retuple-symbols";
+declare const RetupleStackSymbol: unique symbol;
 export type Ok = typeof Ok;
 export type Err = typeof Err;
 export type Result<T, E> = (OkTuple<T> | ErrTuple<E>) & Retuple<T, E>;
@@ -323,6 +324,14 @@ declare class ResultAsync<T, E> {
      * - returns {@link ResultAsync}.
      */
     $andThen<U = T, F = E>(this: ResultAsync<T, E>, f: (val: T) => ResultLikeAwaitable<U, F>): ResultAsync<U, E | F>;
+    /**
+     * The same as {@link Retuple.$andStack|$andStack}, except it:
+     *
+     * - can also accept an `async` and function;
+     * - returns {@link ResultAsync}.
+     */
+    $andStack<U = T, F = E, S extends [...any[], any] = [...any[], any]>(this: ResultAsync<Stack<S>, E>, f: (val: T) => ResultLikeAwaitable<U, F>): ResultAsync<Stack<[...S, U]>, E | F>;
+    $andStack<U = T, F = E>(this: ResultAsync<T, E>, f: (val: T) => ResultLikeAwaitable<U, F>): ResultAsync<Stack<[T, U]>, E | F>;
     /**
      * The same as {@link Retuple.$andThrough|$andThrough}, except it:
      *
@@ -504,6 +513,9 @@ declare class ResultRetry<T, E> extends ResultAsync<T, E> implements PromiseLike
     $handle(f: (controller: ResultRetryController<E>) => void): ResultRetry<T, E>;
     private drain;
 }
+type Stack<T extends [...any[], any] = [...any[], any]> = T & {
+    [RetupleStackSymbol]: T;
+};
 interface Retuple<T, E> extends ResultLike<T, E> {
     /**
      * Returns true when this result is `Ok`. Acts as a type guard.
@@ -1216,10 +1228,46 @@ interface Retuple<T, E> extends ResultLike<T, E> {
      * ```
      */
     $andThen<U = T, F = E>(this: Result<T, E>, f: (val: T) => ResultLike<U, F>): Result<U, E | F>;
+    /**
+     * Stacks the result of the and function on to the current contained
+     * value, when this result and the result of the function is `Ok`.
+     *
+     * Otherwise, returns the current `Err` or the `Err` from the and
+     * function.
+     *
+     * A stack is a special tuple which makes it possilble to pass multiple
+     * values down a chain with minimal effort.
+     *
+     * @example
+     *
+     * ```ts
+     * const identity = <T>(val: T) => Ok(val);
+     *
+     * const stack = Ok("test")
+     *    .$andStack((val) => identity(`${val}-2`))
+     *    .$andStack(([val, val2]) => identity(val.length + val2.length))
+     *    .$map(([val, val2, len]) => `'${val}${val2}' has length ${len}`);
+     *
+     * const nostack = Ok("test")
+     *   .$andThen((val) => identity(`${val}-2`).$map((val2) => [val, val2]))
+     *   .$andThen(([val, val2]) => {
+     *      return identity(val.length + val2.length)
+     *         .$map((len) => [val, val2, len]);
+     *   })
+     *   .$map(([val, val2, len]) => `'${val}${val2}' has length ${len}`);
+     * ```
+     */
+    $andStack<U = T, F = E, S extends [...any[], any] = [...any[], any]>(this: Result<Stack<S>, E>, f: (val: T) => ResultLike<U, F>): Result<Stack<[...S, U]>, E | F>;
+    $andStack<U = T, F = E>(this: Result<T, E>, f: (val: T) => ResultLike<U, F>): Result<Stack<[T, 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>;
+    /**
+     * Shorthand for `result.$async().$andStack(...)`
+     */
+    $andStackAsync<U = T, F = E, S extends [...any[], any] = [...any[], any]>(this: Result<Stack<S>, E>, f: (val: T) => ResultLikeAwaitable<U, F>): ResultAsync<Stack<[...S, U]>, E | F>;
+    $andStackAsync<U = T, F = E>(this: Result<T, E>, f: (val: T) => ResultLikeAwaitable<U, F>): ResultAsync<Stack<[T, U]>, E | F>;
     /**
      * Calls the through function when this result is `Ok` and returns:
      *

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { type ResultLike } from "retuple-symbols";
+declare const RetupleStackSymbol: unique symbol;
 export type Ok = typeof Ok;
 export type Err = typeof Err;
 export type Result<T, E> = (OkTuple<T> | ErrTuple<E>) & Retuple<T, E>;
@@ -323,6 +324,14 @@ declare class ResultAsync<T, E> {
      * - returns {@link ResultAsync}.
      */
     $andThen<U = T, F = E>(this: ResultAsync<T, E>, f: (val: T) => ResultLikeAwaitable<U, F>): ResultAsync<U, E | F>;
+    /**
+     * The same as {@link Retuple.$andStack|$andStack}, except it:
+     *
+     * - can also accept an `async` and function;
+     * - returns {@link ResultAsync}.
+     */
+    $andStack<U = T, F = E, S extends [...any[], any] = [...any[], any]>(this: ResultAsync<Stack<S>, E>, f: (val: T) => ResultLikeAwaitable<U, F>): ResultAsync<Stack<[...S, U]>, E | F>;
+    $andStack<U = T, F = E>(this: ResultAsync<T, E>, f: (val: T) => ResultLikeAwaitable<U, F>): ResultAsync<Stack<[T, U]>, E | F>;
     /**
      * The same as {@link Retuple.$andThrough|$andThrough}, except it:
      *
@@ -504,6 +513,9 @@ declare class ResultRetry<T, E> extends ResultAsync<T, E> implements PromiseLike
     $handle(f: (controller: ResultRetryController<E>) => void): ResultRetry<T, E>;
     private drain;
 }
+type Stack<T extends [...any[], any] = [...any[], any]> = T & {
+    [RetupleStackSymbol]: T;
+};
 interface Retuple<T, E> extends ResultLike<T, E> {
     /**
      * Returns true when this result is `Ok`. Acts as a type guard.
@@ -1216,10 +1228,46 @@ interface Retuple<T, E> extends ResultLike<T, E> {
      * ```
      */
     $andThen<U = T, F = E>(this: Result<T, E>, f: (val: T) => ResultLike<U, F>): Result<U, E | F>;
+    /**
+     * Stacks the result of the and function on to the current contained
+     * value, when this result and the result of the function is `Ok`.
+     *
+     * Otherwise, returns the current `Err` or the `Err` from the and
+     * function.
+     *
+     * A stack is a special tuple which makes it possilble to pass multiple
+     * values down a chain with minimal effort.
+     *
+     * @example
+     *
+     * ```ts
+     * const identity = <T>(val: T) => Ok(val);
+     *
+     * const stack = Ok("test")
+     *    .$andStack((val) => identity(`${val}-2`))
+     *    .$andStack(([val, val2]) => identity(val.length + val2.length))
+     *    .$map(([val, val2, len]) => `'${val}${val2}' has length ${len}`);
+     *
+     * const nostack = Ok("test")
+     *   .$andThen((val) => identity(`${val}-2`).$map((val2) => [val, val2]))
+     *   .$andThen(([val, val2]) => {
+     *      return identity(val.length + val2.length)
+     *         .$map((len) => [val, val2, len]);
+     *   })
+     *   .$map(([val, val2, len]) => `'${val}${val2}' has length ${len}`);
+     * ```
+     */
+    $andStack<U = T, F = E, S extends [...any[], any] = [...any[], any]>(this: Result<Stack<S>, E>, f: (val: T) => ResultLike<U, F>): Result<Stack<[...S, U]>, E | F>;
+    $andStack<U = T, F = E>(this: Result<T, E>, f: (val: T) => ResultLike<U, F>): Result<Stack<[T, 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>;
+    /**
+     * Shorthand for `result.$async().$andStack(...)`
+     */
+    $andStackAsync<U = T, F = E, S extends [...any[], any] = [...any[], any]>(this: Result<Stack<S>, E>, f: (val: T) => ResultLikeAwaitable<U, F>): ResultAsync<Stack<[...S, U]>, E | F>;
+    $andStackAsync<U = T, F = E>(this: Result<T, E>, f: (val: T) => ResultLikeAwaitable<U, F>): ResultAsync<Stack<[T, U]>, E | F>;
     /**
      * Calls the through function when this result is `Ok` and returns:
      *

package/dist/index.js

@@ -11,6 +11,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _ResultAsync_inner, _a, _ResultRetry_f, _ResultRetry_promise, _ResultRetry_times, _ResultRetry_attempt, _ResultRetry_aborted, _ResultRetry_abort, _ResultRetry_getDelay, _ResultRetry_handler;
 import { ResultLikeSymbol, } from "retuple-symbols";
+const RetupleStackSymbol = Symbol("RetupleStackSymbol");
 /**
  * ## Retuple Unwrap Failed
  *
@@ -650,9 +651,24 @@ class ResultOk extends Array {
     $andThen(f) {
         return asResult(f(this[1]));
     }
+    $andStack(f) {
+        const res = asResult(f(this[1]));
+        if (res instanceof ResultErr) {
+            return res;
+        }
+        if (this[1] instanceof RetupleStack) {
+            return Ok(new RetupleStack(...this[1], res[1]));
+        }
+        else {
+            return Ok(new RetupleStack(this[1], res[1]));
+        }
+    }
     $andThenAsync(f) {
         return this.$async().$andThen(f);
     }
+    $andStackAsync(f) {
+        return this.$async().$andStack(f);
+    }
     $andThrough(f) {
         const res = asResult(f(this[1]));
         return res instanceof ResultErr ? res : this;
@@ -810,9 +826,15 @@ class ResultErr extends Array {
     $andThen() {
         return this;
     }
+    $andStack() {
+        return this;
+    }
     $andThenAsync() {
         return this.$async();
     }
+    $andStackAsync() {
+        return this.$async();
+    }
     $andThrough() {
         return this;
     }
@@ -1053,6 +1075,21 @@ class ResultAsync {
                 : res;
         }));
     }
+    $andStack(f) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            if (res instanceof ResultErr) {
+                return res;
+            }
+            const resThen = asResult(await f(res[1]));
+            if (resThen instanceof ResultErr) {
+                return resThen;
+            }
+            if (res[1] instanceof RetupleStack) {
+                return Ok(new RetupleStack(...res[1], resThen[1]));
+            }
+            return Ok(new RetupleStack(res[1], resThen[1]));
+        }));
+    }
     $andThrough(f) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
             if (res instanceof ResultOk) {
@@ -1297,6 +1334,8 @@ class ResultRetry extends ResultAsync {
 _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;
+class RetupleStack extends Array {
+}
 function asResult(resultLike) {
     if (resultLike instanceof ResultOk || resultLike instanceof ResultErr) {
         return resultLike;

package/package.json

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