@nlozgachev/pipelined 0.9.0 → 0.11.0

package/esm/src/Utils/Str.js

@@ -0,0 +1,134 @@
+import { Option } from "../Core/Option.js";
+/**
+ * String utilities. All transformation functions are data-last and curried so they
+ * compose naturally with `pipe`. Safe parsers return `Option` instead of `NaN`.
+ *
+ * @example
+ * ```ts
+ * import { Str } from "@nlozgachev/pipelined/utils";
+ * import { pipe } from "@nlozgachev/pipelined/composition";
+ *
+ * pipe("  Hello, World!  ", Str.trim, Str.toLowerCase); // "hello, world!"
+ * ```
+ */
+export var Str;
+(function (Str) {
+    /**
+     * Splits a string by a separator. Data-last: use in `pipe`.
+     *
+     * @example
+     * ```ts
+     * pipe("a,b,c", Str.split(",")); // ["a", "b", "c"]
+     * ```
+     */
+    Str.split = (separator) => (s) => s.split(separator);
+    /**
+     * Removes leading and trailing whitespace from a string.
+     *
+     * @example
+     * ```ts
+     * pipe("  hello  ", Str.trim); // "hello"
+     * ```
+     */
+    Str.trim = (s) => s.trim();
+    /**
+     * Returns `true` when the string contains the given substring.
+     *
+     * @example
+     * ```ts
+     * pipe("hello world", Str.includes("world")); // true
+     * pipe("hello world", Str.includes("xyz"));   // false
+     * ```
+     */
+    Str.includes = (substring) => (s) => s.includes(substring);
+    /**
+     * Returns `true` when the string starts with the given prefix.
+     *
+     * @example
+     * ```ts
+     * pipe("hello world", Str.startsWith("hello")); // true
+     * pipe("hello world", Str.startsWith("world")); // false
+     * ```
+     */
+    Str.startsWith = (prefix) => (s) => s.startsWith(prefix);
+    /**
+     * Returns `true` when the string ends with the given suffix.
+     *
+     * @example
+     * ```ts
+     * pipe("hello world", Str.endsWith("world")); // true
+     * pipe("hello world", Str.endsWith("hello")); // false
+     * ```
+     */
+    Str.endsWith = (suffix) => (s) => s.endsWith(suffix);
+    /**
+     * Converts a string to uppercase.
+     *
+     * @example
+     * ```ts
+     * pipe("hello", Str.toUpperCase); // "HELLO"
+     * ```
+     */
+    Str.toUpperCase = (s) => s.toUpperCase();
+    /**
+     * Converts a string to lowercase.
+     *
+     * @example
+     * ```ts
+     * pipe("HELLO", Str.toLowerCase); // "hello"
+     * ```
+     */
+    Str.toLowerCase = (s) => s.toLowerCase();
+    /**
+     * Splits a string into lines, normalising `\r\n` and `\r` line endings.
+     *
+     * @example
+     * ```ts
+     * Str.lines("one\ntwo\nthree"); // ["one", "two", "three"]
+     * Str.lines("a\r\nb");         // ["a", "b"]
+     * ```
+     */
+    Str.lines = (s) => s.split(/\r?\n|\r/);
+    /**
+     * Splits a string into words on any whitespace boundary, filtering out empty strings.
+     *
+     * @example
+     * ```ts
+     * Str.words("  hello   world  "); // ["hello", "world"]
+     * ```
+     */
+    Str.words = (s) => s.trim().split(/\s+/).filter(Boolean);
+    /**
+     * Safe number parsers that return `Option` instead of `NaN`.
+     */
+    Str.parse = {
+        /**
+         * Parses a string as an integer (base 10). Returns `None` if the result is `NaN`.
+         *
+         * @example
+         * ```ts
+         * Str.parse.int("42");   // Some(42)
+         * Str.parse.int("3.7");  // Some(3)
+         * Str.parse.int("abc");  // None
+         * ```
+         */
+        int: (s) => {
+            const n = parseInt(s, 10);
+            return isNaN(n) ? Option.none() : Option.some(n);
+        },
+        /**
+         * Parses a string as a floating-point number. Returns `None` if the result is `NaN`.
+         *
+         * @example
+         * ```ts
+         * Str.parse.float("3.14"); // Some(3.14)
+         * Str.parse.float("42");   // Some(42)
+         * Str.parse.float("abc");  // None
+         * ```
+         */
+        float: (s) => {
+            const n = parseFloat(s);
+            return isNaN(n) ? Option.none() : Option.some(n);
+        },
+    };
+})(Str || (Str = {}));

package/esm/src/Utils/index.js

@@ -0,0 +1,4 @@
+export * from "./Arr.js";
+export * from "./Rec.js";
+export * from "./Num.js";
+export * from "./Str.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nlozgachev/pipelined",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Simple functional programming toolkit for TypeScript",
   "keywords": [
     "functional",
@@ -37,6 +37,16 @@
         "default": "./script/src/Core/index.js"
       }
     },
+    "./utils": {
+      "import": {
+        "types": "./types/src/Utils/index.d.ts",
+        "default": "./esm/src/Utils/index.js"
+      },
+      "require": {
+        "types": "./types/src/Utils/index.d.ts",
+        "default": "./script/src/Utils/index.js"
+      }
+    },
     "./types": {
       "import": {
         "types": "./types/src/Types/index.d.ts",

package/script/src/Core/Option.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Option = void 0;
 const Result_js_1 = require("./Result.js");
+const _none = { kind: "None" };
 var Option;
 (function (Option) {
     /**
@@ -15,7 +16,7 @@ var Option;
     /**
      * Creates a None (empty Option).
      */
-    Option.none = () => ({ kind: "None" });
+    Option.none = () => _none;
     /**
      * Type guard that checks if a Option is None.
      */

package/script/src/Core/Optional.js

@@ -87,12 +87,12 @@ var Optional;
      *
      * @example
      * ```ts
-     * pipe(profile, Optional.getOrElse(bioOpt)("no bio"));
+     * pipe(profile, Optional.getOrElse(bioOpt)(() => "no bio"));
      * ```
      */
     Optional.getOrElse = (opt) => (defaultValue) => (s) => {
         const val = opt.get(s);
-        return val.kind === "Some" ? val.value : defaultValue;
+        return val.kind === "Some" ? val.value : defaultValue();
     };
     /**
      * Extracts a value from an Optional focus using handlers for the present

package/script/src/Core/RemoteData.js

@@ -3,16 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RemoteData = void 0;
 const Option_js_1 = require("./Option.js");
 const Result_js_1 = require("./Result.js");
+const _notAsked = { kind: "NotAsked" };
+const _loading = { kind: "Loading" };
 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.
      */
@@ -162,9 +164,9 @@ var RemoteData;
      *
      * @example
      * ```ts
-     * pipe(RemoteData.success(5), RemoteData.getOrElse(0)); // 5
-     * pipe(RemoteData.loading(), RemoteData.getOrElse(0)); // 0
-     * pipe(RemoteData.loading<string, number>(), RemoteData.getOrElse(null)); // null — typed as number | null
+     * pipe(RemoteData.success(5), RemoteData.getOrElse(() => 0)); // 5
+     * pipe(RemoteData.loading(), RemoteData.getOrElse(() => 0)); // 0
+     * pipe(RemoteData.loading<string, number>(), RemoteData.getOrElse(() => null)); // null — typed as number | null
      * ```
      */
     RemoteData.getOrElse = (defaultValue) => (data) => RemoteData.isSuccess(data) ? data.value : defaultValue();
@@ -208,7 +210,5 @@ var RemoteData;
      * ); // Ok(42)
      * ```
      */
-    RemoteData.toResult = (onNotReady) => (data) => RemoteData.isSuccess(data)
-        ? Result_js_1.Result.ok(data.value)
-        : Result_js_1.Result.err(RemoteData.isFailure(data) ? data.error : onNotReady());
+    RemoteData.toResult = (onNotReady) => (data) => RemoteData.isSuccess(data) ? Result_js_1.Result.ok(data.value) : Result_js_1.Result.err(RemoteData.isFailure(data) ? data.error : onNotReady());
 })(RemoteData || (exports.RemoteData = RemoteData = {}));

package/script/src/Core/TaskValidation.js

@@ -42,15 +42,6 @@ var TaskValidation;
      * Transforms the success value inside a TaskValidation.
      */
     TaskValidation.map = (f) => (data) => Task_js_1.Task.map(Validation_js_1.Validation.map(f))(data);
-    /**
-     * Chains TaskValidation computations. If the first is Valid, passes the value
-     * to f. If the first is Invalid, propagates the errors.
-     *
-     * Note: chain short-circuits on first error. Use ap to accumulate errors.
-     */
-    TaskValidation.chain = (f) => (data) => Task_js_1.Task.chain((validation) => Validation_js_1.Validation.isValid(validation)
-        ? f(validation.value)
-        : Task_js_1.Task.resolve(Validation_js_1.Validation.invalidAll(validation.errors)))(data);
     /**
      * Applies a function wrapped in a TaskValidation to a value wrapped in a
      * TaskValidation. Both Tasks run in parallel and errors from both sides
@@ -100,9 +91,41 @@ var TaskValidation;
     TaskValidation.tap = (f) => (data) => Task_js_1.Task.map(Validation_js_1.Validation.tap(f))(data);
     /**
      * Recovers from an Invalid state by providing a fallback 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_js_1.Task.chain((validation) => Validation_js_1.Validation.isValid(validation)
-        ? Task_js_1.Task.resolve(validation)
-        : fallback())(data);
+    TaskValidation.recover = (fallback) => (data) => Task_js_1.Task.chain((validation) => Validation_js_1.Validation.isValid(validation) ? Task_js_1.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
+     * errors from both sides.
+     *
+     * @example
+     * ```ts
+     * await TaskValidation.product(
+     *   validateName(form.name),
+     *   validateAge(form.age),
+     * )(); // Valid(["Alice", 30]) or Invalid([...errors])
+     * ```
+     */
+    TaskValidation.product = (first, second) => Task_js_1.Task.from(() => Promise.all([
+        Deferred_js_1.Deferred.toPromise(first()),
+        Deferred_js_1.Deferred.toPromise(second()),
+    ]).then(([va, vb]) => Validation_js_1.Validation.product(va, vb)));
+    /**
+     * Runs all TaskValidations concurrently and collects results.
+     * If all are Valid, returns Valid with all values as an array.
+     * If any fail, returns Invalid with all accumulated errors.
+     *
+     * @example
+     * ```ts
+     * await TaskValidation.productAll([
+     *   validateName(form.name),
+     *   validateEmail(form.email),
+     *   validateAge(form.age),
+     * ])(); // Valid([name, email, age]) or Invalid([...all errors])
+     * ```
+     */
+    TaskValidation.productAll = (data) => Task_js_1.Task.from(() => Promise.all(data.map((t) => Deferred_js_1.Deferred.toPromise(t())))
+        .then((results) => Validation_js_1.Validation.productAll(results)));
 })(TaskValidation || (exports.TaskValidation = TaskValidation = {}));

package/script/src/Core/Validation.js

@@ -122,9 +122,9 @@ var Validation;
      *
      * @example
      * ```ts
-     * pipe(Validation.valid(5), Validation.getOrElse(0)); // 5
-     * pipe(Validation.invalid("oops"), Validation.getOrElse(0)); // 0
-     * pipe(Validation.invalid("oops"), Validation.getOrElse(null)); // null — typed as number | null
+     * pipe(Validation.valid(5), Validation.getOrElse(() => 0)); // 5
+     * pipe(Validation.invalid("oops"), Validation.getOrElse(() => 0)); // 0
+     * pipe(Validation.invalid("oops"), Validation.getOrElse(() => null)); // null — typed as number | null
      * ```
      */
     Validation.getOrElse = (defaultValue) => (data) => Validation.isValid(data) ? data.value : defaultValue();

package/script/src/Core/index.js

@@ -14,14 +14,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./Arr.js"), exports);
 __exportStar(require("./Logged.js"), exports);
 __exportStar(require("./Deferred.js"), exports);
 __exportStar(require("./Lens.js"), exports);
 __exportStar(require("./Option.js"), exports);
 __exportStar(require("./Reader.js"), exports);
 __exportStar(require("./Optional.js"), exports);
-__exportStar(require("./Rec.js"), exports);
 __exportStar(require("./Predicate.js"), exports);
 __exportStar(require("./Refinement.js"), exports);
 __exportStar(require("./RemoteData.js"), exports);

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

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Arr = void 0;
-const Deferred_js_1 = require("./Deferred.js");
-const Option_js_1 = require("./Option.js");
-const Result_js_1 = require("./Result.js");
-const Task_js_1 = require("./Task.js");
+const Deferred_js_1 = require("../Core/Deferred.js");
+const Option_js_1 = require("../Core/Option.js");
+const Result_js_1 = require("../Core/Result.js");
+const Task_js_1 = require("../Core/Task.js");
 const NonEmptyList_js_1 = require("../Types/NonEmptyList.js");
 /**
  * Functional array utilities that compose well with pipe.
@@ -113,7 +113,13 @@ 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.
      *
@@ -122,7 +128,15 @@ 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,
@@ -216,9 +230,9 @@ 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;
     };
@@ -232,9 +246,9 @@ 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;
     };
@@ -289,7 +303,17 @@ 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.
      *
@@ -316,12 +340,13 @@ var Arr;
      * ```
      */
     Arr.traverse = (f) => (data) => {
-        const result = [];
-        for (const a of data) {
-            const mapped = f(a);
-            if (Option_js_1.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_js_1.Option.none();
-            result.push(mapped.value);
+            result[i] = mapped.value;
         }
         return Option_js_1.Option.some(result);
     };
@@ -338,12 +363,13 @@ var Arr;
      * ```
      */
     Arr.traverseResult = (f) => (data) => {
-        const result = [];
-        for (const a of data) {
-            const mapped = f(a);
-            if (Result_js_1.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_js_1.Result.ok(result);
     };
@@ -430,7 +456,13 @@ 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.
      *
@@ -439,7 +471,13 @@ 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.
      *
@@ -498,4 +536,38 @@ 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 || (exports.Arr = Arr = {}));

package/script/src/Utils/Num.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Num = void 0;
+const Option_js_1 = require("../Core/Option.js");
+/**
+ * Number utilities for common operations. All transformation functions are data-last
+ * and curried so they compose naturally with `pipe` and `Arr.map`.
+ *
+ * @example
+ * ```ts
+ * import { Num } from "@nlozgachev/pipelined/utils";
+ * import { pipe } from "@nlozgachev/pipelined/composition";
+ *
+ * pipe(
+ *   Num.range(1, 6),
+ *   Arr.map(Num.multiply(2)),
+ *   Arr.filter(Num.between(4, 8))
+ * ); // [4, 6, 8]
+ * ```
+ */
+var Num;
+(function (Num) {
+    /**
+     * Generates an array of numbers from `from` to `to` (both inclusive),
+     * stepping by `step` (default `1`). If `step` is negative or zero, or `from > to`,
+     * returns an empty array. When `step` does not land exactly on `to`, the last value
+     * is the largest reachable value that does not exceed `to`.
+     *
+     * @example
+     * ```ts
+     * Num.range(0, 5);       // [0, 1, 2, 3, 4, 5]
+     * Num.range(0, 10, 2);   // [0, 2, 4, 6, 8, 10]
+     * Num.range(0, 9, 2);    // [0, 2, 4, 6, 8]
+     * Num.range(5, 0);       // []
+     * Num.range(3, 3);       // [3]
+     * ```
+     */
+    Num.range = (from, to, step = 1) => {
+        if (step <= 0 || from > to)
+            return [];
+        const count = Math.floor((to - from) / step) + 1;
+        const result = new Array(count);
+        for (let i = 0; i < count; i++) {
+            result[i] = from + i * step;
+        }
+        return result;
+    };
+    /**
+     * Clamps a number between `min` and `max` (both inclusive).
+     *
+     * @example
+     * ```ts
+     * pipe(150, Num.clamp(0, 100)); // 100
+     * pipe(-5, Num.clamp(0, 100));  // 0
+     * pipe(42, Num.clamp(0, 100));  // 42
+     * ```
+     */
+    Num.clamp = (min, max) => (n) => Math.min(Math.max(n, min), max);
+    /**
+     * Returns `true` when the number is between `min` and `max` (both inclusive).
+     *
+     * @example
+     * ```ts
+     * pipe(5, Num.between(1, 10));  // true
+     * pipe(0, Num.between(1, 10));  // false
+     * pipe(10, Num.between(1, 10)); // true
+     * ```
+     */
+    Num.between = (min, max) => (n) => n >= min && n <= max;
+    /**
+     * Parses a string as a number. Returns `None` when the result is `NaN`.
+     *
+     * @example
+     * ```ts
+     * Num.parse("42");   // Some(42)
+     * Num.parse("3.14"); // Some(3.14)
+     * Num.parse("abc");  // None
+     * Num.parse("");     // None
+     * ```
+     */
+    Num.parse = (s) => {
+        if (s.trim() === "")
+            return Option_js_1.Option.none();
+        const n = Number(s);
+        return isNaN(n) ? Option_js_1.Option.none() : Option_js_1.Option.some(n);
+    };
+    /**
+     * Adds `b` to a number. Data-last: use in `pipe` or `Arr.map`.
+     *
+     * @example
+     * ```ts
+     * pipe(5, Num.add(3));                   // 8
+     * pipe([1, 2, 3], Arr.map(Num.add(10))); // [11, 12, 13]
+     * ```
+     */
+    Num.add = (b) => (a) => a + b;
+    /**
+     * Subtracts `b` from a number. Data-last: `subtract(b)(a)` = `a - b`.
+     *
+     * @example
+     * ```ts
+     * pipe(10, Num.subtract(3));                  // 7
+     * pipe([5, 10, 15], Arr.map(Num.subtract(2))); // [3, 8, 13]
+     * ```
+     */
+    Num.subtract = (b) => (a) => a - b;
+    /**
+     * Multiplies a number by `b`. Data-last: use in `pipe` or `Arr.map`.
+     *
+     * @example
+     * ```ts
+     * pipe(6, Num.multiply(7));                    // 42
+     * pipe([1, 2, 3], Arr.map(Num.multiply(100))); // [100, 200, 300]
+     * ```
+     */
+    Num.multiply = (b) => (a) => a * b;
+    /**
+     * Divides a number by `b`. Data-last: `divide(b)(a)` = `a / b`.
+     *
+     * @example
+     * ```ts
+     * pipe(20, Num.divide(4));                      // 5
+     * pipe([10, 20, 30], Arr.map(Num.divide(10)));  // [1, 2, 3]
+     * ```
+     */
+    Num.divide = (b) => (a) => a / b;
+})(Num || (exports.Num = Num = {}));