@nlozgachev/pipekit 0.2.0 → 0.4.0

package/script/src/Core/These.js

@@ -1,134 +1,145 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.These = void 0;
-const Result_js_1 = require("./Result.js");
 var These;
 (function (These) {
     /**
-     * Creates a These holding only an error/warning (no success value).
+     * Creates a These holding only a first value.
      *
      * @example
      * ```ts
-     * These.err("Something went wrong");
+     * These.first(42); // { kind: "First", first: 42 }
      * ```
      */
-    These.err = (error) => Result_js_1.Result.err(error);
+    These.first = (value) => ({ kind: "First", first: value });
     /**
-     * Creates a These holding only a success value (no error).
+     * Creates a These holding only a second value.
      *
      * @example
      * ```ts
-     * These.ok(42);
+     * These.second("warning"); // { kind: "Second", second: "warning" }
      * ```
      */
-    These.ok = (value) => Result_js_1.Result.ok(value);
+    These.second = (value) => ({ kind: "Second", second: value });
     /**
-     * Creates a These holding both an error/warning and a success value.
+     * Creates a These holding both a first and a second value simultaneously.
      *
      * @example
      * ```ts
-     * These.both("Deprecated API used", result);
+     * These.both(42, "Deprecated API used"); // { kind: "Both", first: 42, second: "Deprecated API used" }
      * ```
      */
-    These.both = (error, value) => ({
+    These.both = (first, second) => ({
         kind: "Both",
-        error,
-        value,
+        first,
+        second,
     });
     /**
-     * Type guard — checks if a These holds only an error/warning.
+     * Type guard — checks if a These holds only a first value.
      */
-    These.isErr = (data) => data.kind === "Error";
+    These.isFirst = (data) => data.kind === "First";
     /**
-     * Type guard — checks if a These holds only a success value.
+     * Type guard — checks if a These holds only a second value.
      */
-    These.isOk = (data) => data.kind === "Ok";
+    These.isSecond = (data) => data.kind === "Second";
     /**
-     * Type guard — checks if a These holds both an error/warning and a success value.
+     * Type guard — checks if a These holds both values simultaneously.
      */
     These.isBoth = (data) => data.kind === "Both";
     /**
-     * Returns true if the These contains a success value (Ok or Both).
+     * Returns true if the These contains a first value (First or Both).
      */
-    These.hasValue = (data) => data.kind === "Ok" || data.kind === "Both";
+    These.hasFirst = (data) => data.kind === "First" || data.kind === "Both";
     /**
-     * Returns true if the These contains an error/warning (Err or Both).
+     * Returns true if the These contains a second value (Second or Both).
      */
-    These.hasError = (data) => data.kind === "Error" || data.kind === "Both";
+    These.hasSecond = (data) => data.kind === "Second" || data.kind === "Both";
     /**
-     * Transforms the success value, leaving the error unchanged.
+     * Transforms the first value, leaving the second unchanged.
      *
      * @example
      * ```ts
-     * pipe(These.ok(5), These.map(n => n * 2));          // Ok(10)
-     * pipe(These.both("warn", 5), These.map(n => n * 2)); // Both("warn", 10)
-     * pipe(These.err("err"), These.map(n => n * 2));      // Err("err")
+     * pipe(These.first(5), These.mapFirst(n => n * 2));           // First(10)
+     * pipe(These.both(5, "warn"), These.mapFirst(n => n * 2));    // Both(10, "warn")
+     * pipe(These.second("warn"), These.mapFirst(n => n * 2));     // Second("warn")
      * ```
      */
-    These.map = (f) => (data) => {
-        if (These.isErr(data))
+    These.mapFirst = (f) => (data) => {
+        if (These.isSecond(data))
             return data;
-        if (These.isOk(data))
-            return These.ok(f(data.value));
-        return These.both(data.error, f(data.value));
+        if (These.isFirst(data))
+            return These.first(f(data.first));
+        return These.both(f(data.first), data.second);
     };
     /**
-     * Transforms the error/warning value, leaving the success value unchanged.
+     * Transforms the second value, leaving the first unchanged.
      *
      * @example
      * ```ts
-     * pipe(These.err("err"), These.mapErr(e => e.toUpperCase()));         // Err("ERR")
-     * pipe(These.both("warn", 5), These.mapErr(e => e.toUpperCase()));    // Both("WARN", 5)
+     * pipe(These.second("warn"), These.mapSecond(e => e.toUpperCase()));     // Second("WARN")
+     * pipe(These.both(5, "warn"), These.mapSecond(e => e.toUpperCase()));    // Both(5, "WARN")
      * ```
      */
-    These.mapErr = (f) => (data) => {
-        if (These.isOk(data))
+    These.mapSecond = (f) => (data) => {
+        if (These.isFirst(data))
             return data;
-        if (These.isErr(data))
-            return These.err(f(data.error));
-        return These.both(f(data.error), data.value);
+        if (These.isSecond(data))
+            return These.second(f(data.second));
+        return These.both(data.first, f(data.second));
     };
     /**
-     * Transforms both the error and success values independently.
+     * Transforms both the first and second values independently.
      *
      * @example
      * ```ts
      * pipe(
-     *   These.both("warn", 5),
-     *   These.bimap(e => e.toUpperCase(), n => n * 2)
-     * ); // Both("WARN", 10)
+     *   These.both(5, "warn"),
+     *   These.mapBoth(n => n * 2, e => e.toUpperCase())
+     * ); // Both(10, "WARN")
      * ```
      */
-    These.bimap = (onErr, onOk) => (data) => {
-        if (These.isErr(data))
-            return These.err(onErr(data.error));
-        if (These.isOk(data))
-            return These.ok(onOk(data.value));
-        return These.both(onErr(data.error), onOk(data.value));
+    These.mapBoth = (onFirst, onSecond) => (data) => {
+        if (These.isSecond(data))
+            return These.second(onSecond(data.second));
+        if (These.isFirst(data))
+            return These.first(onFirst(data.first));
+        return These.both(onFirst(data.first), onSecond(data.second));
     };
     /**
-     * Chains These computations by passing the success value to f.
-     * - Err propagates unchanged.
-     * - Ok(a) applies f(a) directly.
-     * - Both(e, a): applies f(a); if the result is Ok(b), returns Both(e, b)
-     *   to preserve the warning. Otherwise returns f(a) as-is.
+     * Chains These computations by passing the first value to f.
+     * Second propagates unchanged; First and Both apply f to the first value.
      *
      * @example
      * ```ts
-     * const double = (n: number): These<string, number> => These.ok(n * 2);
+     * const double = (n: number): These<number, string> => These.first(n * 2);
      *
-     * pipe(These.ok(5), These.chain(double));           // Ok(10)
-     * pipe(These.both("warn", 5), These.chain(double)); // Both("warn", 10)
-     * pipe(These.err("err"), These.chain(double));      // Err("err")
+     * pipe(These.first(5), These.chainFirst(double));            // First(10)
+     * pipe(These.both(5, "warn"), These.chainFirst(double));     // First(10)
+     * pipe(These.second("warn"), These.chainFirst(double));      // Second("warn")
      * ```
      */
-    These.chain = (f) => (data) => {
-        if (These.isErr(data))
+    These.chainFirst = (f) => (data) => {
+        if (These.isSecond(data))
             return data;
-        if (These.isOk(data))
-            return f(data.value);
-        const result = f(data.value);
-        return These.isOk(result) ? These.both(data.error, result.value) : result;
+        return f(data.first);
+    };
+    /**
+     * Chains These computations by passing the second value to f.
+     * First propagates unchanged; Second and Both apply f to the second value.
+     *
+     * @example
+     * ```ts
+     * const shout = (s: string): These<number, string> => These.second(s.toUpperCase());
+     *
+     * pipe(These.second("warn"), These.chainSecond(shout));      // Second("WARN")
+     * pipe(These.both(5, "warn"), These.chainSecond(shout));     // Second("WARN")
+     * pipe(These.first(5), These.chainSecond(shout));            // First(5)
+     * ```
+     */
+    These.chainSecond = (f) => (data) => {
+        if (These.isFirst(data))
+            return data;
+        return f(data.second);
     };
     /**
      * Extracts a value from a These by providing handlers for all three cases.
@@ -138,19 +149,19 @@ var These;
      * pipe(
      *   these,
      *   These.fold(
-     *     e => `Error: ${e}`,
-     *     a => `Value: ${a}`,
-     *     (e, a) => `Both: ${e} / ${a}`
+     *     a => `First: ${a}`,
+     *     b => `Second: ${b}`,
+     *     (a, b) => `Both: ${a} / ${b}`
      *   )
      * );
      * ```
      */
-    These.fold = (onErr, onOk, onBoth) => (data) => {
-        if (These.isErr(data))
-            return onErr(data.error);
-        if (These.isOk(data))
-            return onOk(data.value);
-        return onBoth(data.error, data.value);
+    These.fold = (onFirst, onSecond, onBoth) => (data) => {
+        if (These.isSecond(data))
+            return onSecond(data.second);
+        if (These.isFirst(data))
+            return onFirst(data.first);
+        return onBoth(data.first, data.second);
     };
     /**
      * Pattern matches on a These, returning the result of the matching case.
@@ -160,86 +171,74 @@ var These;
      * pipe(
      *   these,
      *   These.match({
-     *     err: e => `Error: ${e}`,
-     *     ok: a => `Value: ${a}`,
-     *     both: (e, a) => `Both: ${e} / ${a}`
+     *     first: a => `First: ${a}`,
+     *     second: b => `Second: ${b}`,
+     *     both: (a, b) => `Both: ${a} / ${b}`
      *   })
      * );
      * ```
      */
     These.match = (cases) => (data) => {
-        if (These.isErr(data))
-            return cases.err(data.error);
-        if (These.isOk(data))
-            return cases.ok(data.value);
-        return cases.both(data.error, data.value);
+        if (These.isSecond(data))
+            return cases.second(data.second);
+        if (These.isFirst(data))
+            return cases.first(data.first);
+        return cases.both(data.first, data.second);
     };
     /**
-     * Returns the success value, or a default if the These has no success value.
+     * Returns the first value, or a default if the These has no first value.
      *
      * @example
      * ```ts
-     * pipe(These.ok(5), These.getOrElse(0));           // 5
-     * pipe(These.both("warn", 5), These.getOrElse(0)); // 5
-     * pipe(These.err("err"), These.getOrElse(0));      // 0
+     * pipe(These.first(5), These.getFirstOrElse(0));            // 5
+     * pipe(These.both(5, "warn"), These.getFirstOrElse(0));     // 5
+     * pipe(These.second("warn"), These.getFirstOrElse(0));      // 0
      * ```
      */
-    These.getOrElse = (defaultValue) => (data) => These.hasValue(data) ? data.value : defaultValue;
+    These.getFirstOrElse = (defaultValue) => (data) => These.hasFirst(data) ? data.first : defaultValue;
     /**
-     * Executes a side effect on the success value without changing the These.
-     * Useful for logging or debugging.
-     */
-    These.tap = (f) => (data) => {
-        if (These.hasValue(data))
-            f(data.value);
-        return data;
-    };
-    /**
-     * Swaps the roles of error and success values.
-     * - Err(e)      → Ok(e)
-     * - Ok(a)       → Err(a)
-     * - Both(e, a)  → Both(a, e)
+     * Returns the second value, or a default if the These has no second value.
      *
      * @example
      * ```ts
-     * These.swap(These.err("err"));        // Ok("err")
-     * These.swap(These.ok(5));             // Err(5)
-     * These.swap(These.both("warn", 5));   // Both(5, "warn")
+     * pipe(These.second("warn"), These.getSecondOrElse("none")); // "warn"
+     * pipe(These.both(5, "warn"), These.getSecondOrElse("none")); // "warn"
+     * pipe(These.first(5), These.getSecondOrElse("none"));       // "none"
      * ```
      */
-    These.swap = (data) => {
-        if (These.isErr(data))
-            return These.ok(data.error);
-        if (These.isOk(data))
-            return These.err(data.value);
-        return These.both(data.value, data.error);
-    };
+    These.getSecondOrElse = (defaultValue) => (data) => These.hasSecond(data) ? data.second : defaultValue;
     /**
-     * Converts a These to an Option.
-     * Ok and Both produce Some; Err produces None.
+     * Executes a side effect on the first value without changing the These.
+     * Useful for logging or debugging.
      *
      * @example
      * ```ts
-     * These.toOption(These.ok(42));          // Some(42)
-     * These.toOption(These.both("warn", 42)); // Some(42)
-     * These.toOption(These.err("err"));       // None
+     * pipe(These.first(5), These.tap(console.log)); // logs 5, returns First(5)
      * ```
      */
-    These.toOption = (data) => These.hasValue(data) ? { kind: "Some", value: data.value } : { kind: "None" };
+    These.tap = (f) => (data) => {
+        if (These.hasFirst(data))
+            f(data.first);
+        return data;
+    };
     /**
-     * Converts a These to a Result, discarding any warning from Both.
-     * Ok and Both produce Ok; Err produces Err.
+     * Swaps the roles of first and second values.
+     * - First(a)    → Second(a)
+     * - Second(b)   → First(b)
+     * - Both(a, b)  → Both(b, a)
      *
      * @example
      * ```ts
-     * These.toResult(These.ok(42));           // Ok(42)
-     * These.toResult(These.both("warn", 42)); // Ok(42)
-     * These.toResult(These.err("err"));       // Err("err")
+     * These.swap(These.first(5));            // Second(5)
+     * These.swap(These.second("warn"));      // First("warn")
+     * These.swap(These.both(5, "warn"));     // Both("warn", 5)
      * ```
      */
-    These.toResult = (data) => {
-        if (These.hasValue(data))
-            return Result_js_1.Result.ok(data.value);
-        return data;
+    These.swap = (data) => {
+        if (These.isSecond(data))
+            return These.first(data.second);
+        if (These.isFirst(data))
+            return These.second(data.first);
+        return These.both(data.second, data.first);
     };
 })(These || (exports.These = These = {}));

package/script/src/Core/Validation.js

@@ -9,56 +9,55 @@ var Validation;
      *
      * @example
      * ```ts
-     * Validation.of(42); // Valid(42)
+     * Validation.valid(42); // Valid(42)
      * ```
      */
-    Validation.of = (value) => ({
+    Validation.valid = (value) => ({
         kind: "Valid",
         value,
     });
     /**
-     * Creates a valid Validation with the given value.
-     */
-    Validation.toValid = (value) => ({ kind: "Valid", value });
-    /**
-     * Type guard that checks if a Validation is valid.
+     * Creates an invalid Validation from a single error.
+     *
+     * @example
+     * ```ts
+     * Validation.invalid("Invalid input");
+     * ```
      */
-    Validation.isValid = (data) => data.kind === "Valid";
+    Validation.invalid = (error) => ({
+        kind: "Invalid",
+        errors: [error],
+    });
     /**
-     * Creates an invalid Validation with the given errors.
+     * Creates an invalid Validation from multiple errors.
      *
      * @example
      * ```ts
-     * Validation.toInvalid(["Email is invalid", "Password too short"]);
+     * Validation.invalidAll(["Invalid input"]);
      * ```
      */
-    Validation.toInvalid = (errors) => ({
+    Validation.invalidAll = (errors) => ({
         kind: "Invalid",
         errors,
     });
     /**
-     * Type guard that checks if a Validation is invalid.
+     * Type guard that checks if a Validation is valid.
      */
-    Validation.isInvalid = (data) => data.kind === "Invalid";
+    Validation.isValid = (data) => data.kind === "Valid";
     /**
-     * Creates an invalid Validation from a single error.
-     *
-     * @example
-     * ```ts
-     * Validation.fail("Invalid input");
-     * ```
+     * Type guard that checks if a Validation is invalid.
      */
-    Validation.fail = (error) => Validation.toInvalid([error]);
+    Validation.isInvalid = (data) => data.kind === "Invalid";
     /**
      * Transforms the success value inside a Validation.
      *
      * @example
      * ```ts
-     * pipe(Validation.of(5), Validation.map(n => n * 2)); // Valid(10)
-     * pipe(Validation.fail("oops"), Validation.map(n => n * 2)); // Invalid(["oops"])
+     * pipe(Validation.valid(5), Validation.map(n => n * 2)); // Valid(10)
+     * pipe(Validation.invalid("oops"), Validation.map(n => n * 2)); // Invalid(["oops"])
      * ```
      */
-    Validation.map = (f) => (data) => Validation.isValid(data) ? Validation.of(f(data.value)) : data;
+    Validation.map = (f) => (data) => Validation.isValid(data) ? Validation.valid(f(data.value)) : data;
     /**
      * Chains Validation computations. If the first is Valid, passes the value to f.
      * If the first is Invalid, propagates the errors.
@@ -68,10 +67,10 @@ var Validation;
      * @example
      * ```ts
      * const validatePositive = (n: number): Validation<string, number> =>
-     *   n > 0 ? Validation.of(n) : Validation.fail("Must be positive");
+     *   n > 0 ? Validation.valid(n) : Validation.invalid("Must be positive");
      *
-     * pipe(Validation.of(5), Validation.chain(validatePositive)); // Valid(5)
-     * pipe(Validation.of(-1), Validation.chain(validatePositive)); // Invalid(["Must be positive"])
+     * pipe(Validation.valid(5), Validation.chain(validatePositive)); // Valid(5)
+     * pipe(Validation.valid(-1), Validation.chain(validatePositive)); // Invalid(["Must be positive"])
      * ```
      */
     Validation.chain = (f) => (data) => Validation.isValid(data) ? f(data.value) : data;
@@ -83,26 +82,26 @@ var Validation;
      * ```ts
      * const add = (a: number) => (b: number) => a + b;
      * pipe(
-     *   Validation.of(add),
-     *   Validation.ap(Validation.of(5)),
-     *   Validation.ap(Validation.of(3))
+     *   Validation.valid(add),
+     *   Validation.ap(Validation.valid(5)),
+     *   Validation.ap(Validation.valid(3))
      * ); // Valid(8)
      *
      * pipe(
-     *   Validation.of(add),
-     *   Validation.ap(Validation.fail<string, number>("bad a")),
-     *   Validation.ap(Validation.fail<string, number>("bad b"))
+     *   Validation.valid(add),
+     *   Validation.ap(Validation.invalid<string, number>("bad a")),
+     *   Validation.ap(Validation.invalid<string, number>("bad b"))
      * ); // Invalid(["bad a", "bad b"])
      * ```
      */
     Validation.ap = (arg) => (data) => {
         if (Validation.isValid(data) && Validation.isValid(arg))
-            return Validation.of(data.value(arg.value));
+            return Validation.valid(data.value(arg.value));
         const errors = [
             ...(Validation.isInvalid(data) ? data.errors : []),
             ...(Validation.isInvalid(arg) ? arg.errors : []),
         ];
-        return (0, NonEmptyList_js_1.isNonEmptyList)(errors) ? Validation.toInvalid(errors) : Validation.of(data);
+        return (0, NonEmptyList_js_1.isNonEmptyList)(errors) ? Validation.invalidAll(errors) : Validation.valid(data);
     };
     /**
      * Extracts the value from a Validation by providing handlers for both cases.
@@ -110,7 +109,7 @@ var Validation;
      * @example
      * ```ts
      * pipe(
-     *   Validation.of(42),
+     *   Validation.valid(42),
      *   Validation.fold(
      *     errors => `Errors: ${errors.join(", ")}`,
      *     value => `Value: ${value}`
@@ -139,8 +138,8 @@ var Validation;
      *
      * @example
      * ```ts
-     * pipe(Validation.of(5), Validation.getOrElse(0)); // 5
-     * pipe(Validation.fail("oops"), Validation.getOrElse(0)); // 0
+     * pipe(Validation.valid(5), Validation.getOrElse(0)); // 5
+     * pipe(Validation.invalid("oops"), Validation.getOrElse(0)); // 0
      * ```
      */
     Validation.getOrElse = (defaultValue) => (data) => Validation.isValid(data) ? data.value : defaultValue;
@@ -150,7 +149,7 @@ var Validation;
      * @example
      * ```ts
      * pipe(
-     *   Validation.of(5),
+     *   Validation.valid(5),
      *   Validation.tap(n => console.log("Value:", n)),
      *   Validation.map(n => n * 2)
      * );
@@ -180,13 +179,13 @@ var Validation;
      * @example
      * ```ts
      * Validation.combine(
-     *   Validation.fail("Error 1"),
-     *   Validation.fail("Error 2")
+     *   Validation.invalid("Error 1"),
+     *   Validation.invalid("Error 2")
      * ); // Invalid(["Error 1", "Error 2"])
      *
      * Validation.combine(
-     *   Validation.of("a"),
-     *   Validation.of("b")
+     *   Validation.valid("a"),
+     *   Validation.valid("b")
      * ); // Valid("b")
      * ```
      */
@@ -198,7 +197,7 @@ var Validation;
             ...(Validation.isInvalid(first) ? first.errors : []),
             ...(Validation.isInvalid(second) ? second.errors : []),
         ];
-        return (0, NonEmptyList_js_1.isNonEmptyList)(errors) ? Validation.toInvalid(errors) : second;
+        return (0, NonEmptyList_js_1.isNonEmptyList)(errors) ? Validation.invalidAll(errors) : second;
     };
     /**
      * Combines multiple Validation instances, accumulating all errors.

package/types/src/Composition/flip.d.ts

@@ -6,13 +6,13 @@
  * ```ts
  * // Original data-last (for pipe)
  * pipe(
- *   Option.of(5),
+ *   Option.some(5),
  *   Option.map(n => n * 2)
  * ); // Some(10)
  *
  * // Flipped to data-first
  * const mapFirst = flip(Option.map);
- * mapFirst(Option.of(5))(n => n * 2); // Some(10)
+ * mapFirst(Option.some(5))(n => n * 2); // Some(10)
  * ```
  *
  * @see {@link uncurry} for converting curried functions to multi-argument functions

package/types/src/Composition/fn.d.ts

@@ -4,7 +4,7 @@
  * @example
  * ```ts
  * identity(42); // 42
- * pipe(Option.of(5), Option.fold(() => 0, identity)); // 5
+ * pipe(Option.some(5), Option.fold(() => 0, identity)); // 5
  * ```
  */
 export declare const identity: <A>(a: A) => A;

package/types/src/Composition/pipe.d.ts

@@ -17,7 +17,7 @@
  *
  * // With library functions
  * const greeting = pipe(
- *   Option.of("Alice"),
+ *   Option.some("Alice"),
  *   Option.map(name => name.toUpperCase()),
  *   Option.map(name => `Hello, ${name}!`),
  *   Option.getOrElse("Hello!")

package/types/src/Composition/tap.d.ts

@@ -6,7 +6,7 @@
  * ```ts
  * // Debugging a pipeline
  * pipe(
- *   Option.of(5),
+ *   Option.some(5),
  *   tap(x => console.log("Before map:", x)),
  *   Option.map(n => n * 2),
  *   tap(x => console.log("After map:", x)),

package/types/src/Composition/uncurry.d.ts

@@ -11,15 +11,15 @@
  * uncurry(nested)(); // 42
  *
  * // Original curried function
- * Option.map(n => n * 2)(Option.of(5)); // Some(10)
+ * Option.map(n => n * 2)(Option.some(5)); // Some(10)
  *
  * // Uncurried - all arguments at once
  * const mapUncurried = uncurry(Option.map);
- * mapUncurried(n => n * 2, Option.of(5)); // Some(10)
+ * mapUncurried(n => n * 2, Option.some(5)); // Some(10)
  *
  * // Combined with flip for data-first uncurried
  * const mapDataFirst = uncurry(flip(Option.map));
- * mapDataFirst(Option.of(5), n => n * 2); // Some(10)
+ * mapDataFirst(Option.some(5), n => n * 2); // Some(10)
  * ```
  *
  * @see {@link flip} for reversing curried argument order

package/types/src/Core/Arr.d.ts

@@ -227,7 +227,7 @@ export declare namespace Arr {
      * ```ts
      * const parseNum = (s: string): Option<number> => {
      *   const n = Number(s);
-     *   return isNaN(n) ? Option.none() : Option.of(n);
+     *   return isNaN(n) ? Option.none() : Option.some(n);
      * };
      *
      * pipe(["1", "2", "3"], Arr.traverse(parseNum)); // Some([1, 2, 3])
@@ -255,7 +255,7 @@ export declare namespace Arr {
      * ```ts
      * pipe(
      *   [1, 2, 3],
-     *   Arr.traverseTask(n => Task.of(n * 2))
+     *   Arr.traverseTask(n => Task.resolve(n * 2))
      * )(); // Promise<[2, 4, 6]>
      * ```
      */
@@ -266,8 +266,8 @@ export declare namespace Arr {
      *
      * @example
      * ```ts
-     * Arr.sequence([Option.of(1), Option.of(2)]); // Some([1, 2])
-     * Arr.sequence([Option.of(1), Option.none()]); // None
+     * Arr.sequence([Option.some(1), Option.some(2)]); // Some([1, 2])
+     * Arr.sequence([Option.some(1), Option.none()]); // None
      * ```
      */
     const sequence: <A>(data: readonly Option<A>[]) => Option<readonly A[]>;

package/types/src/Core/InternalTypes.d.ts

@@ -11,4 +11,10 @@ export type WithError<T> = {
 export type WithErrors<T> = {
     readonly errors: NonEmptyList<T>;
 };
+export type WithFirst<T> = {
+    readonly first: T;
+};
+export type WithSecond<T> = {
+    readonly second: T;
+};
 //# sourceMappingURL=InternalTypes.d.ts.map