@nlozgachev/pipelined 0.10.0 → 0.12.0

package/README.md

@@ -17,8 +17,6 @@ state flag soup, you get types that name every possible state and make invalid o
 Each type comes with a consistent set of operations — `map`, `chain`, `match`, `getOrElse` — that
 compose with `pipe` and `flow`.
 
-No FP jargon required. You won't find `Monad`, `Functor`, or `Applicative` in the API.
-
 ## What's included?
 
 ### pipelined/core
@@ -39,8 +37,16 @@ No FP jargon required. You won't find `Monad`, `Functor`, or `Applicative` in th
 - **`Optional<S, A>`** — like `Lens`, but the target may be absent (nullable fields, array indices).
 - **`Reader<R, A>`** — a computation that depends on an environment `R`, supplied once at the
   boundary.
+
+
+### pipelined/utils
+
+Everyday utilities for built-in JS types.
+
 - **`Arr`** — array utilities, data-last, returning `Option` instead of `undefined`.
-- **`Rec`** — record utilities, data-last, with `Option`-returning key lookup.
+- **`Rec`** — record/object utilities, data-last, with `Option`-returning key lookup.
+- **`Num`** — number utilities: `range`, `clamp`, `between`, safe `parse`, and curried arithmetic.
+- **`Str`** — string utilities: `split`, `trim`, `words`, `lines`, and safe `parse.int` / `parse.float`.
 
 ### pipelined/types
 

package/esm/src/Core/Option.js

@@ -1,4 +1,5 @@
 import { Result } from "./Result.js";
+const _none = { kind: "None" };
 export var Option;
 (function (Option) {
     /**
@@ -12,7 +13,7 @@ export var Option;
     /**
      * Creates a None (empty Option).
      */
-    Option.none = () => ({ kind: "None" });
+    Option.none = () => _none;
     /**
      * Type guard that checks if a Option is None.
      */

package/esm/src/Core/RemoteData.js

@@ -1,15 +1,17 @@
 import { Option } from "./Option.js";
 import { Result } from "./Result.js";
+const _notAsked = { kind: "NotAsked" };
+const _loading = { kind: "Loading" };
 export var RemoteData;
 (function (RemoteData) {
     /**
      * Creates a NotAsked RemoteData.
      */
-    RemoteData.notAsked = () => ({ kind: "NotAsked" });
+    RemoteData.notAsked = () => _notAsked;
     /**
      * Creates a Loading RemoteData.
      */
-    RemoteData.loading = () => ({ kind: "Loading" });
+    RemoteData.loading = () => _loading;
     /**
      * Creates a Failure RemoteData with the given error.
      */
@@ -205,7 +207,5 @@ export var RemoteData;
      * ); // Ok(42)
      * ```
      */
-    RemoteData.toResult = (onNotReady) => (data) => RemoteData.isSuccess(data)
-        ? Result.ok(data.value)
-        : Result.err(RemoteData.isFailure(data) ? data.error : onNotReady());
+    RemoteData.toResult = (onNotReady) => (data) => RemoteData.isSuccess(data) ? Result.ok(data.value) : Result.err(RemoteData.isFailure(data) ? data.error : onNotReady());
 })(RemoteData || (RemoteData = {}));

package/esm/src/Core/TaskValidation.js

@@ -91,9 +91,7 @@ export var TaskValidation;
      * The fallback receives the accumulated error list so callers can inspect which errors occurred.
      * The fallback can produce a different success type, widening the result to `TaskValidation<E, A | B>`.
      */
-    TaskValidation.recover = (fallback) => (data) => Task.chain((validation) => Validation.isValid(validation)
-        ? Task.resolve(validation)
-        : fallback(validation.errors))(data);
+    TaskValidation.recover = (fallback) => (data) => Task.chain((validation) => Validation.isValid(validation) ? Task.resolve(validation) : fallback(validation.errors))(data);
     /**
      * Runs two TaskValidations concurrently and combines their results into a tuple.
      * If both are Valid, returns Valid with both values. If either fails, accumulates

package/esm/src/Core/Tuple.js

@@ -0,0 +1,112 @@
+export var Tuple;
+(function (Tuple) {
+    /**
+     * Creates a pair from two values.
+     *
+     * @example
+     * ```ts
+     * Tuple.make("Paris", 2_161_000); // ["Paris", 2161000]
+     * ```
+     */
+    Tuple.make = (first, second) => [first, second];
+    /**
+     * Returns the first value from the pair.
+     *
+     * @example
+     * ```ts
+     * Tuple.first(Tuple.make("Paris", 2_161_000)); // "Paris"
+     * ```
+     */
+    Tuple.first = (tuple) => tuple[0];
+    /**
+     * Returns the second value from the pair.
+     *
+     * @example
+     * ```ts
+     * Tuple.second(Tuple.make("Paris", 2_161_000)); // 2161000
+     * ```
+     */
+    Tuple.second = (tuple) => tuple[1];
+    /**
+     * Transforms the first value, leaving the second unchanged.
+     *
+     * @example
+     * ```ts
+     * pipe(Tuple.make("alice", 42), Tuple.mapFirst((s) => s.toUpperCase())); // ["ALICE", 42]
+     * ```
+     */
+    Tuple.mapFirst = (f) => (tuple) => [f(tuple[0]), tuple[1]];
+    /**
+     * Transforms the second value, leaving the first unchanged.
+     *
+     * @example
+     * ```ts
+     * pipe(Tuple.make("alice", 42), Tuple.mapSecond((n) => n * 2)); // ["alice", 84]
+     * ```
+     */
+    Tuple.mapSecond = (f) => (tuple) => [tuple[0], f(tuple[1])];
+    /**
+     * Transforms both values independently in a single step.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Tuple.make("alice", 42),
+     *   Tuple.mapBoth(
+     *     (name) => name.toUpperCase(),
+     *     (score) => score * 2,
+     *   ),
+     * ); // ["ALICE", 84]
+     * ```
+     */
+    Tuple.mapBoth = (onFirst, onSecond) => (tuple) => [
+        onFirst(tuple[0]),
+        onSecond(tuple[1]),
+    ];
+    /**
+     * Applies a binary function to both values, collapsing the pair into a single value.
+     * Useful as the final step when consuming a pair in a pipeline.
+     *
+     * @example
+     * ```ts
+     * pipe(Tuple.make("Alice", 100), Tuple.fold((name, score) => `${name}: ${score}`));
+     * // "Alice: 100"
+     * ```
+     */
+    Tuple.fold = (f) => (tuple) => f(tuple[0], tuple[1]);
+    /**
+     * Swaps the two values: `[A, B]` becomes `[B, A]`.
+     *
+     * @example
+     * ```ts
+     * Tuple.swap(Tuple.make("key", 1)); // [1, "key"]
+     * ```
+     */
+    Tuple.swap = (tuple) => [tuple[1], tuple[0]];
+    /**
+     * Converts the pair to a heterogeneous readonly array `readonly (A | B)[]`.
+     *
+     * @example
+     * ```ts
+     * Tuple.toArray(Tuple.make("hello", 42)); // ["hello", 42]
+     * ```
+     */
+    Tuple.toArray = (tuple) => [...tuple];
+    /**
+     * Runs a side effect with both values without changing the pair.
+     * Useful for logging or debugging in the middle of a pipeline.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Tuple.make("Paris", 2_161_000),
+     *   Tuple.tap((city, pop) => console.log(`${city}: ${pop}`)),
+     *   Tuple.mapSecond((n) => n / 1_000_000),
+     * ); // logs "Paris: 2161000", returns ["Paris", 2.161]
+     * ```
+     */
+    Tuple.tap = (f) => (tuple) => {
+        f(tuple[0], tuple[1]);
+        return tuple;
+    };
+})(Tuple || (Tuple = {}));

package/esm/src/Core/index.js

@@ -1,19 +1,18 @@
-export * from "./Arr.js";
-export * from "./Logged.js";
 export * from "./Deferred.js";
 export * from "./Lens.js";
+export * from "./Logged.js";
 export * from "./Option.js";
-export * from "./Reader.js";
 export * from "./Optional.js";
-export * from "./Rec.js";
 export * from "./Predicate.js";
+export * from "./Reader.js";
 export * from "./Refinement.js";
 export * from "./RemoteData.js";
-export * from "./State.js";
 export * from "./Result.js";
+export * from "./State.js";
 export * from "./Task.js";
 export * from "./TaskOption.js";
 export * from "./TaskResult.js";
 export * from "./TaskValidation.js";
 export * from "./These.js";
+export * from "./Tuple.js";
 export * from "./Validation.js";

package/esm/src/{Core → Utils}/Arr.js

@@ -1,7 +1,7 @@
-import { Deferred } from "./Deferred.js";
-import { Option } from "./Option.js";
-import { Result } from "./Result.js";
-import { Task } from "./Task.js";
+import { Deferred } from "../Core/Deferred.js";
+import { Option } from "../Core/Option.js";
+import { Result } from "../Core/Result.js";
+import { Task } from "../Core/Task.js";
 import { isNonEmptyList } from "../Types/NonEmptyList.js";
 /**
  * Functional array utilities that compose well with pipe.
@@ -110,7 +110,13 @@ export var Arr;
      * pipe([1, 2, 3], Arr.map(n => n * 2)); // [2, 4, 6]
      * ```
      */
-    Arr.map = (f) => (data) => data.map(f);
+    Arr.map = (f) => (data) => {
+        const n = data.length;
+        const result = new Array(n);
+        for (let i = 0; i < n; i++)
+            result[i] = f(data[i]);
+        return result;
+    };
     /**
      * Filters elements that satisfy the predicate.
      *
@@ -119,7 +125,15 @@ export var Arr;
      * pipe([1, 2, 3, 4], Arr.filter(n => n % 2 === 0)); // [2, 4]
      * ```
      */
-    Arr.filter = (predicate) => (data) => data.filter(predicate);
+    Arr.filter = (predicate) => (data) => {
+        const n = data.length;
+        const result = [];
+        for (let i = 0; i < n; i++) {
+            if (predicate(data[i]))
+                result.push(data[i]);
+        }
+        return result;
+    };
     /**
      * Splits an array into two groups based on a predicate.
      * First group contains elements that satisfy the predicate,
@@ -213,9 +227,9 @@ export var Arr;
      */
     Arr.zip = (other) => (data) => {
         const len = Math.min(data.length, other.length);
-        const result = [];
+        const result = new Array(len);
         for (let i = 0; i < len; i++) {
-            result.push([data[i], other[i]]);
+            result[i] = [data[i], other[i]];
         }
         return result;
     };
@@ -229,9 +243,9 @@ export var Arr;
      */
     Arr.zipWith = (f) => (other) => (data) => {
         const len = Math.min(data.length, other.length);
-        const result = [];
+        const result = new Array(len);
         for (let i = 0; i < len; i++) {
-            result.push(f(data[i], other[i]));
+            result[i] = f(data[i], other[i]);
         }
         return result;
     };
@@ -286,7 +300,17 @@ export var Arr;
      * pipe([1, 2, 3], Arr.flatMap(n => [n, n * 10])); // [1, 10, 2, 20, 3, 30]
      * ```
      */
-    Arr.flatMap = (f) => (data) => [].concat(...data.map(f));
+    Arr.flatMap = (f) => (data) => {
+        const n = data.length;
+        const result = [];
+        for (let i = 0; i < n; i++) {
+            const chunk = f(data[i]);
+            const m = chunk.length;
+            for (let j = 0; j < m; j++)
+                result.push(chunk[j]);
+        }
+        return result;
+    };
     /**
      * Reduces an array from the left.
      *
@@ -313,12 +337,13 @@ export var Arr;
      * ```
      */
     Arr.traverse = (f) => (data) => {
-        const result = [];
-        for (const a of data) {
-            const mapped = f(a);
-            if (Option.isNone(mapped))
+        const n = data.length;
+        const result = new Array(n);
+        for (let i = 0; i < n; i++) {
+            const mapped = f(data[i]);
+            if (mapped.kind === "None")
                 return Option.none();
-            result.push(mapped.value);
+            result[i] = mapped.value;
         }
         return Option.some(result);
     };
@@ -335,12 +360,13 @@ export var Arr;
      * ```
      */
     Arr.traverseResult = (f) => (data) => {
-        const result = [];
-        for (const a of data) {
-            const mapped = f(a);
-            if (Result.isErr(mapped))
+        const n = data.length;
+        const result = new Array(n);
+        for (let i = 0; i < n; i++) {
+            const mapped = f(data[i]);
+            if (mapped.kind === "Error")
                 return mapped;
-            result.push(mapped.value);
+            result[i] = mapped.value;
         }
         return Result.ok(result);
     };
@@ -427,7 +453,13 @@ export var Arr;
      * pipe([1, 2, 3], Arr.some(n => n > 2)); // true
      * ```
      */
-    Arr.some = (predicate) => (data) => data.some(predicate);
+    Arr.some = (predicate) => (data) => {
+        const n = data.length;
+        for (let i = 0; i < n; i++)
+            if (predicate(data[i]))
+                return true;
+        return false;
+    };
     /**
      * Returns true if all elements satisfy the predicate.
      *
@@ -436,7 +468,13 @@ export var Arr;
      * pipe([1, 2, 3], Arr.every(n => n > 0)); // true
      * ```
      */
-    Arr.every = (predicate) => (data) => data.every(predicate);
+    Arr.every = (predicate) => (data) => {
+        const n = data.length;
+        for (let i = 0; i < n; i++)
+            if (!predicate(data[i]))
+                return false;
+        return true;
+    };
     /**
      * Reverses an array. Returns a new array.
      *
@@ -495,4 +533,38 @@ export var Arr;
             i++;
         return data.slice(i);
     };
+    /**
+     * Like `reduce`, but returns every intermediate accumulator as an array.
+     * The initial value is not included — the output has the same length as the input.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3], Arr.scan(0, (acc, n) => acc + n)); // [1, 3, 6]
+     * ```
+     */
+    Arr.scan = (initial, f) => (data) => {
+        const n = data.length;
+        const result = new Array(n);
+        let acc = initial;
+        for (let i = 0; i < n; i++) {
+            acc = f(acc, data[i]);
+            result[i] = acc;
+        }
+        return result;
+    };
+    /**
+     * Splits an array at an index into a `[before, after]` tuple.
+     * Negative indices clamp to 0; indices beyond the array length clamp to the end.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3, 4], Arr.splitAt(2)); // [[1, 2], [3, 4]]
+     * pipe([1, 2, 3], Arr.splitAt(0));    // [[], [1, 2, 3]]
+     * pipe([1, 2, 3], Arr.splitAt(10));   // [[1, 2, 3], []]
+     * ```
+     */
+    Arr.splitAt = (index) => (data) => {
+        const i = Math.max(0, index);
+        return [data.slice(0, i), data.slice(i)];
+    };
 })(Arr || (Arr = {}));