@nlozgachev/pipelined 0.57.0 → 0.59.0

package/README.md

@@ -555,12 +555,12 @@ if (Result.is.ok(email)) {
 - **`@nlozgachev/pipelined/core`**: Core context containers, async runtimes, optics, and logic
   abstractions (<16 KB gzipped).
 - **`@nlozgachev/pipelined/data`**: Curried, data-last utilities for collections, numbers, strings,
-  and JSON (<13 KB gzipped).
+  and JSON (<10 KB gzipped).
 - **`@nlozgachev/pipelined/composition`**: Pure higher-order function combinators (`pipe`, `flow`,
   `compose`, `curry`, `uncurry`, `converge`, `juxt`, `memoize`, `tap`, `on`, `not`, `flip`, `fn`)
-  (<4 KB gzipped).
-- **`@nlozgachev/pipelined/types`**: Type-level utilities (`Brand`, `Duration`, `RetryPolicy`) (<2
-  KB gzipped).
+  (<3 KB gzipped).
+- **`@nlozgachev/pipelined/types`**: Type-level utilities (`Brand`, `Duration`, `RetryPolicy`) (<700
+  B gzipped).
 
 Every utility in the library is benchmarked against its native equivalent. While currying introduces
 a small function call overhead for composability, the library uses custom algorithms for

package/dist/{chunk-JSG7SFXS.js → composition.mjs}

@@ -1,7 +1,3 @@
-import {
-  Duration
-} from "./chunk-OIIOGDHK.js";
-
 // src/Composition/compose.ts
 function compose(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9) {
   const len = arguments.length;
@@ -324,6 +320,36 @@ pipe.try = (f, onError) => (a) => {
 
 // src/Composition/tap.ts
 import { inspect as nodeInspect } from "util";
+
+// src/Types/Brand.ts
+var Brand;
+((Brand2) => {
+  Brand2.wrap = () => (value) => value;
+  Brand2.unwrap = (branded) => branded;
+})(Brand || (Brand = {}));
+
+// src/Types/Duration.ts
+var Duration;
+((Duration2) => {
+  const wrap = Brand.wrap();
+  Duration2.milliseconds = (ms) => wrap(ms);
+  Duration2.seconds = (s) => wrap(s * 1e3);
+  Duration2.minutes = (m) => wrap(m * 60 * 1e3);
+  Duration2.hours = (h) => wrap(h * 60 * 60 * 1e3);
+  Duration2.days = (d) => wrap(d * 24 * 60 * 60 * 1e3);
+  let to;
+  ((to2) => {
+    to2.milliseconds = (d) => Brand.unwrap(d);
+    to2.seconds = (d) => Brand.unwrap(d) / 1e3;
+    to2.minutes = (d) => Brand.unwrap(d) / (60 * 1e3);
+    to2.hours = (d) => Brand.unwrap(d) / (60 * 60 * 1e3);
+    to2.days = (d) => Brand.unwrap(d) / (24 * 60 * 60 * 1e3);
+  })(to = Duration2.to || (Duration2.to = {}));
+  Duration2.add = (other) => (self) => wrap(Brand.unwrap(self) + Brand.unwrap(other));
+  Duration2.subtract = (other) => (self) => wrap(Brand.unwrap(self) - Brand.unwrap(other));
+})(Duration || (Duration = {}));
+
+// src/Composition/tap.ts
 function tap(f) {
   return (a) => {
     f(a);
@@ -417,36 +443,35 @@ function uncurry(f) {
 }
 var uncurry3 = (f) => (a, b, c) => f(a)(b)(c);
 var uncurry4 = (f) => (a, b, c, d) => f(a)(b)(c)(d);
-
 export {
+  and,
   compose,
+  constFalse,
+  constNull,
+  constTrue,
+  constUndefined,
+  constVoid,
+  constant,
   converge,
   curry,
   curry3,
   curry4,
+  defaultTo,
   flip,
   flow,
   identity,
-  constant,
-  constTrue,
-  constFalse,
-  constNull,
-  constUndefined,
-  constVoid,
-  and,
-  or,
-  once,
-  defaultTo,
-  tuple,
-  untuple,
   juxt,
   memoize,
   memoizeWeak,
   not,
   on,
+  once,
+  or,
   pipe,
   tap,
+  tuple,
   uncurry,
   uncurry3,
-  uncurry4
+  uncurry4,
+  untuple
 };

package/dist/core.cjs

@@ -30,6 +30,7 @@ __export(Core_exports, {
   Op: () => Op,
   Optional: () => Optional,
   Ordering: () => Ordering,
+  Pair: () => Pair,
   Predicate: () => Predicate,
   Reader: () => Reader,
   Refinement: () => Refinement,
@@ -40,7 +41,6 @@ __export(Core_exports, {
   Stream: () => Stream,
   Task: () => Task,
   These: () => These,
-  Tuple: () => Tuple,
   Validation: () => Validation
 });
 module.exports = __toCommonJS(Core_exports);
@@ -1473,6 +1473,34 @@ var Ordering;
   };
 })(Ordering || (Ordering = {}));
 
+// src/Core/Pair.ts
+var Pair;
+((Pair2) => {
+  let from;
+  ((from2) => {
+    from2.pair = (first2, second2) => [first2, second2];
+    from2.array = (arr) => arr;
+  })(from = Pair2.from || (Pair2.from = {}));
+  Pair2.first = (p) => p[0];
+  Pair2.second = (p) => p[1];
+  Pair2.mapFirst = (f) => (p) => [f(p[0]), p[1]];
+  Pair2.mapSecond = (f) => (p) => [p[0], f(p[1])];
+  Pair2.mapBoth = (onFirst, onSecond) => (p) => [
+    onFirst(p[0]),
+    onSecond(p[1])
+  ];
+  Pair2.fold = (f) => (p) => f(p[0], p[1]);
+  Pair2.swap = (p) => [p[1], p[0]];
+  let to;
+  ((to2) => {
+    to2.Array = (p) => [...p];
+  })(to = Pair2.to || (Pair2.to = {}));
+  Pair2.tap = (f) => (p) => {
+    f(p[0], p[1]);
+    return p;
+  };
+})(Pair || (Pair = {}));
+
 // src/Core/Predicate.ts
 var Predicate;
 ((Predicate2) => {
@@ -2531,34 +2559,6 @@ var These;
   };
 })(These || (These = {}));
 
-// src/Core/Tuple.ts
-var Tuple;
-((Tuple2) => {
-  let from;
-  ((from2) => {
-    from2.pair = (first2, second2) => [first2, second2];
-    from2.array = (arr) => arr;
-  })(from = Tuple2.from || (Tuple2.from = {}));
-  Tuple2.first = (tuple) => tuple[0];
-  Tuple2.second = (tuple) => tuple[1];
-  Tuple2.mapFirst = (f) => (tuple) => [f(tuple[0]), tuple[1]];
-  Tuple2.mapSecond = (f) => (tuple) => [tuple[0], f(tuple[1])];
-  Tuple2.mapBoth = (onFirst, onSecond) => (tuple) => [
-    onFirst(tuple[0]),
-    onSecond(tuple[1])
-  ];
-  Tuple2.fold = (f) => (tuple) => f(tuple[0], tuple[1]);
-  Tuple2.swap = (tuple) => [tuple[1], tuple[0]];
-  let to;
-  ((to2) => {
-    to2.Array = (tuple) => [...tuple];
-  })(to = Tuple2.to || (Tuple2.to = {}));
-  Tuple2.tap = (f) => (tuple) => {
-    f(tuple[0], tuple[1]);
-    return tuple;
-  };
-})(Tuple || (Tuple = {}));
-
 // src/Core/Validation.ts
 var Validation;
 ((Validation2) => {
@@ -2676,6 +2676,7 @@ var Validation;
   Op,
   Optional,
   Ordering,
+  Pair,
   Predicate,
   Reader,
   Refinement,
@@ -2686,6 +2687,5 @@ var Validation;
   Stream,
   Task,
   These,
-  Tuple,
   Validation
 });

package/dist/core.d.cts

@@ -1327,6 +1327,148 @@ declare namespace Optional {
     const andThenLens: <A, B>(inner: Lens<A, B>) => <S>(outer: Optional<S, A>) => Optional<S, B>;
 }
 
+/**
+ * Pair<A, B> represents a pair of two values that are always both present.
+ * It is a typed alias for `readonly [A, B]`.
+ *
+ * Use Pair when two values always travel together through a pipeline and you
+ * want to transform either or both sides without destructuring.
+ *
+ * @example
+ * ```ts
+ * import { Pair } from "@nlozgachev/pipelined/core";
+ * import { pipe } from "@nlozgachev/pipelined/composition";
+ *
+ * const entry = Pair.from.pair("alice", 42);
+ *
+ * pipe(
+ *   entry,
+ *   Pair.mapFirst((name) => name.toUpperCase()),
+ *   Pair.mapSecond((score) => score * 2),
+ *   Pair.fold((name, score) => `${name}: ${score}`),
+ * ); // "ALICE: 84"
+ * ```
+ */
+type Pair<A, B> = readonly [A, B];
+declare namespace Pair {
+    namespace from {
+        /**
+         * Creates a Pair from two values.
+         *
+         * @example
+         * ```ts
+         * Pair.from.pair("Paris", 2_161_000); // ["Paris", 2161000]
+         * ```
+         */
+        const pair: <A, B>(first: A, second: B) => Pair<A, B>;
+        /**
+         * Creates a Pair from a two-element array.
+         *
+         * @example
+         * ```ts
+         * Pair.from.array(["Paris", 2_161_000] as const); // ["Paris", 2161000]
+         * ```
+         */
+        const array: <A, B>(arr: readonly [A, B]) => Pair<A, B>;
+    }
+    /**
+     * Returns the first value from the pair.
+     *
+     * @example
+     * ```ts
+     * Pair.first(Pair.from.pair("Paris", 2_161_000)); // "Paris"
+     * ```
+     */
+    const first: <A, B>(p: Pair<A, B>) => A;
+    /**
+     * Returns the second value from the pair.
+     *
+     * @example
+     * ```ts
+     * Pair.second(Pair.from.pair("Paris", 2_161_000)); // 2161000
+     * ```
+     */
+    const second: <A, B>(p: Pair<A, B>) => B;
+    /**
+     * Transforms the first value, leaving the second unchanged.
+     *
+     * @example
+     * ```ts
+     * pipe(Pair.from.pair("alice", 42), Pair.mapFirst((s) => s.toUpperCase())); // ["ALICE", 42]
+     * ```
+     */
+    const mapFirst: <A, C>(f: (a: A) => C) => <B>(p: Pair<A, B>) => Pair<C, B>;
+    /**
+     * Transforms the second value, leaving the first unchanged.
+     *
+     * @example
+     * ```ts
+     * pipe(Pair.from.pair("alice", 42), Pair.mapSecond((n) => n * 2)); // ["alice", 84]
+     * ```
+     */
+    const mapSecond: <B, D>(f: (b: B) => D) => <A>(p: Pair<A, B>) => Pair<A, D>;
+    /**
+     * Transforms both values independently in a single step.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Pair.from.pair("alice", 42),
+     *   Pair.mapBoth(
+     *     (name) => name.toUpperCase(),
+     *     (score) => score * 2,
+     *   ),
+     * ); // ["ALICE", 84]
+     * ```
+     */
+    const mapBoth: <A, C, B, D>(onFirst: (a: A) => C, onSecond: (b: B) => D) => (p: Pair<A, B>) => Pair<C, D>;
+    /**
+     * 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(Pair.from.pair("Alice", 100), Pair.fold((name, score) => `${name}: ${score}`));
+     * // "Alice: 100"
+     * ```
+     */
+    const fold: <A, B, C>(f: (a: A, b: B) => C) => (p: Pair<A, B>) => C;
+    /**
+     * Swaps the two values: `[A, B]` becomes `[B, A]`.
+     *
+     * @example
+     * ```ts
+     * Pair.swap(Pair.from.pair("key", 1)); // [1, "key"]
+     * ```
+     */
+    const swap: <A, B>(p: Pair<A, B>) => Pair<B, A>;
+    namespace to {
+        /**
+         * Converts the pair to a heterogeneous readonly array `readonly (A | B)[]`.
+         *
+         * @example
+         * ```ts
+         * Pair.to.Array(Pair.from.pair("hello", 42)); // ["hello", 42]
+         * ```
+         */
+        const Array: <A, B>(p: Pair<A, B>) => readonly (A | B)[];
+    }
+    /**
+     * 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(
+     *   Pair.from.pair("Paris", 2_161_000),
+     *   Pair.tap((city, pop) => console.log(`${city}: ${pop}`)),
+     *   Pair.mapSecond((n) => n / 1_000_000),
+     * ); // logs "Paris: 2161000", returns ["Paris", 2.161]
+     * ```
+     */
+    const tap: <A, B>(f: (a: A, b: B) => void) => (p: Pair<A, B>) => Pair<A, B>;
+}
+
 /**
  * A boolean-valued function over a type `A`.
  *
@@ -2877,146 +3019,4 @@ declare namespace These {
     const swap: <A, B>(data: These<A, B>) => These<B, A>;
 }
 
-/**
- * Tuple<A, B> represents a pair of two values that are always both present.
- * It is a typed alias for `readonly [A, B]`.
- *
- * Use Tuple when two values always travel together through a pipeline and you
- * want to transform either or both sides without destructuring.
- *
- * @example
- * ```ts
- * import { Tuple } from "@nlozgachev/pipelined/core";
- * import { pipe } from "@nlozgachev/pipelined/composition";
- *
- * const entry = Tuple.from.pair("alice", 42);
- *
- * pipe(
- *   entry,
- *   Tuple.mapFirst((name) => name.toUpperCase()),
- *   Tuple.mapSecond((score) => score * 2),
- *   Tuple.fold((name, score) => `${name}: ${score}`),
- * ); // "ALICE: 84"
- * ```
- */
-type Tuple<A, B> = readonly [A, B];
-declare namespace Tuple {
-    namespace from {
-        /**
-         * Creates a pair from two values.
-         *
-         * @example
-         * ```ts
-         * Tuple.from.pair("Paris", 2_161_000); // ["Paris", 2161000]
-         * ```
-         */
-        const pair: <A, B>(first: A, second: B) => Tuple<A, B>;
-        /**
-         * Creates a Tuple from a two-element array.
-         *
-         * @example
-         * ```ts
-         * Tuple.from.array(["Paris", 2_161_000] as const); // ["Paris", 2161000]
-         * ```
-         */
-        const array: <A, B>(arr: readonly [A, B]) => Tuple<A, B>;
-    }
-    /**
-     * Returns the first value from the pair.
-     *
-     * @example
-     * ```ts
-     * Tuple.first(Tuple.from.pair("Paris", 2_161_000)); // "Paris"
-     * ```
-     */
-    const first: <A, B>(tuple: Tuple<A, B>) => A;
-    /**
-     * Returns the second value from the pair.
-     *
-     * @example
-     * ```ts
-     * Tuple.second(Tuple.from.pair("Paris", 2_161_000)); // 2161000
-     * ```
-     */
-    const second: <A, B>(tuple: Tuple<A, B>) => B;
-    /**
-     * Transforms the first value, leaving the second unchanged.
-     *
-     * @example
-     * ```ts
-     * pipe(Tuple.from.pair("alice", 42), Tuple.mapFirst((s) => s.toUpperCase())); // ["ALICE", 42]
-     * ```
-     */
-    const mapFirst: <A, C>(f: (a: A) => C) => <B>(tuple: Tuple<A, B>) => Tuple<C, B>;
-    /**
-     * Transforms the second value, leaving the first unchanged.
-     *
-     * @example
-     * ```ts
-     * pipe(Tuple.from.pair("alice", 42), Tuple.mapSecond((n) => n * 2)); // ["alice", 84]
-     * ```
-     */
-    const mapSecond: <B, D>(f: (b: B) => D) => <A>(tuple: Tuple<A, B>) => Tuple<A, D>;
-    /**
-     * Transforms both values independently in a single step.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Tuple.from.pair("alice", 42),
-     *   Tuple.mapBoth(
-     *     (name) => name.toUpperCase(),
-     *     (score) => score * 2,
-     *   ),
-     * ); // ["ALICE", 84]
-     * ```
-     */
-    const mapBoth: <A, C, B, D>(onFirst: (a: A) => C, onSecond: (b: B) => D) => (tuple: Tuple<A, B>) => Tuple<C, D>;
-    /**
-     * 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.from.pair("Alice", 100), Tuple.fold((name, score) => `${name}: ${score}`));
-     * // "Alice: 100"
-     * ```
-     */
-    const fold: <A, B, C>(f: (a: A, b: B) => C) => (tuple: Tuple<A, B>) => C;
-    /**
-     * Swaps the two values: `[A, B]` becomes `[B, A]`.
-     *
-     * @example
-     * ```ts
-     * Tuple.swap(Tuple.from.pair("key", 1)); // [1, "key"]
-     * ```
-     */
-    const swap: <A, B>(tuple: Tuple<A, B>) => Tuple<B, A>;
-    namespace to {
-        /**
-         * Converts the pair to a heterogeneous readonly array `readonly (A | B)[]`.
-         *
-         * @example
-         * ```ts
-         * Tuple.to.Array(Tuple.from.pair("hello", 42)); // ["hello", 42]
-         * ```
-         */
-        const Array: <A, B>(tuple: Tuple<A, B>) => readonly (A | B)[];
-    }
-    /**
-     * 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.from.pair("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]
-     * ```
-     */
-    const tap: <A, B>(f: (a: A, b: B) => void) => (tuple: Tuple<A, B>) => Tuple<A, B>;
-}
-
-export { Combinable, Deferred, type Failure, Lazy, Lens, type Loading, Logged, Maybe, type NotAsked, Op, Optional, Predicate, Reader, Refinement, RemoteData, Resource, Result, State, Stream, type Success, Task, These, type TheseBoth, type TheseFirst, type TheseSecond, Tuple };
+export { Combinable, Deferred, type Failure, Lazy, Lens, type Loading, Logged, Maybe, type NotAsked, Op, Optional, Pair, Predicate, Reader, Refinement, RemoteData, Resource, Result, State, Stream, type Success, Task, These, type TheseBoth, type TheseFirst, type TheseSecond };