@nlozgachev/pipekit 0.2.0 → 0.4.0

package/esm/src/Core/These.js

@@ -1,131 +1,142 @@
-import { Result } from "./Result.js";
 export 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.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.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.
@@ -135,19 +146,19 @@ export 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.
@@ -157,86 +168,74 @@ export 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.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 || (These = {}));

package/esm/src/Core/Validation.js

@@ -6,56 +6,55 @@ export 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.
@@ -65,10 +64,10 @@ export 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;
@@ -80,26 +79,26 @@ export 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 isNonEmptyList(errors) ? Validation.toInvalid(errors) : Validation.of(data);
+        return isNonEmptyList(errors) ? Validation.invalidAll(errors) : Validation.valid(data);
     };
     /**
      * Extracts the value from a Validation by providing handlers for both cases.
@@ -107,7 +106,7 @@ export var Validation;
      * @example
      * ```ts
      * pipe(
-     *   Validation.of(42),
+     *   Validation.valid(42),
      *   Validation.fold(
      *     errors => `Errors: ${errors.join(", ")}`,
      *     value => `Value: ${value}`
@@ -136,8 +135,8 @@ export 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;
@@ -147,7 +146,7 @@ export var Validation;
      * @example
      * ```ts
      * pipe(
-     *   Validation.of(5),
+     *   Validation.valid(5),
      *   Validation.tap(n => console.log("Value:", n)),
      *   Validation.map(n => n * 2)
      * );
@@ -177,13 +176,13 @@ export 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")
      * ```
      */
@@ -195,7 +194,7 @@ export var Validation;
             ...(Validation.isInvalid(first) ? first.errors : []),
             ...(Validation.isInvalid(second) ? second.errors : []),
         ];
-        return isNonEmptyList(errors) ? Validation.toInvalid(errors) : second;
+        return isNonEmptyList(errors) ? Validation.invalidAll(errors) : second;
     };
     /**
      * Combines multiple Validation instances, accumulating all errors.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nlozgachev/pipekit",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Simple functional programming toolkit for TypeScript",
   "keywords": [
     "functional",

package/script/src/Composition/flip.js

@@ -9,13 +9,13 @@ exports.flip = void 0;
  * ```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/script/src/Composition/fn.js

@@ -7,7 +7,7 @@ exports.once = exports.or = exports.and = exports.constVoid = exports.constUndef
  * @example
  * ```ts
  * identity(42); // 42
- * pipe(Option.of(5), Option.fold(() => 0, identity)); // 5
+ * pipe(Option.some(5), Option.fold(() => 0, identity)); // 5
  * ```
  */
 const identity = (a) => a;

package/script/src/Composition/tap.js

@@ -9,7 +9,7 @@ exports.tap = void 0;
  * ```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/script/src/Core/Arr.js

@@ -306,7 +306,7 @@ var 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])
@@ -352,7 +352,7 @@ var Arr;
      * ```ts
      * pipe(
      *   [1, 2, 3],
-     *   Arr.traverseTask(n => Task.of(n * 2))
+     *   Arr.traverseTask(n => Task.resolve(n * 2))
      * )(); // Promise<[2, 4, 6]>
      * ```
      */
@@ -363,8 +363,8 @@ var 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
      * ```
      */
     Arr.sequence = (data) => Arr.traverse((a) => a)(data);