@nlozgachev/pipelined 0.6.5 → 0.8.0

package/esm/src/Core/Arr.js

@@ -227,7 +227,7 @@ export var Arr;
      * pipe([1, 2], Arr.zipWith((a, b) => a + b, ["a", "b"])); // ["1a", "2b"]
      * ```
      */
-    Arr.zipWith = (f, other) => (data) => {
+    Arr.zipWith = (f) => (other) => (data) => {
         const len = Math.min(data.length, other.length);
         const result = [];
         for (let i = 0; i < len; i++) {
@@ -376,6 +376,41 @@ export var Arr;
      * Collects an array of Tasks into a Task of array. Runs in parallel.
      */
     Arr.sequenceTask = (data) => Arr.traverseTask((a) => a)(data);
+    /**
+     * Maps each element to a TaskResult and runs them sequentially.
+     * Returns the first Err encountered, or Ok of all results if all succeed.
+     *
+     * @example
+     * ```ts
+     * const validate = (n: number): TaskResult<string, number> =>
+     *   n > 0 ? TaskResult.ok(n) : TaskResult.err("non-positive");
+     *
+     * pipe(
+     *   [1, 2, 3],
+     *   Arr.traverseTaskResult(validate)
+     * )(); // Deferred<Ok([1, 2, 3])>
+     *
+     * pipe(
+     *   [1, -1, 3],
+     *   Arr.traverseTaskResult(validate)
+     * )(); // Deferred<Err("non-positive")>
+     * ```
+     */
+    Arr.traverseTaskResult = (f) => (data) => Task.from(async () => {
+        const result = [];
+        for (const a of data) {
+            const r = await Deferred.toPromise(f(a)());
+            if (Result.isErr(r))
+                return r;
+            result.push(r.value);
+        }
+        return Result.ok(result);
+    });
+    /**
+     * Collects an array of TaskResults into a TaskResult of array.
+     * Returns the first Err if any element is Err, runs sequentially.
+     */
+    Arr.sequenceTaskResult = (data) => Arr.traverseTaskResult((a) => a)(data);
     /**
      * Returns true if the array is non-empty (type guard).
      */

package/esm/src/Core/Deferred.js

@@ -1,3 +1,4 @@
+const _store = new WeakMap();
 export var Deferred;
 (function (Deferred) {
     /**
@@ -10,9 +11,11 @@ export var Deferred;
      * const value = await d; // "hello"
      * ```
      */
-    Deferred.fromPromise = (p) => ({
-        then: ((f) => p.then(f)),
-    });
+    Deferred.fromPromise = (p) => {
+        const d = ({ then: ((f) => p.then(f)) });
+        _store.set(d, p);
+        return d;
+    };
     /**
      * Converts a `Deferred` back into a `Promise`.
      *
@@ -22,5 +25,6 @@ export var Deferred;
      * // p is Promise<42>
      * ```
      */
-    Deferred.toPromise = (d) => new Promise((resolve) => d.then(resolve));
+    Deferred.toPromise = (d) => _store.get(d) ??
+        new Promise((resolve) => d.then(resolve));
 })(Deferred || (Deferred = {}));

package/esm/src/Core/Logged.js

@@ -0,0 +1,111 @@
+export var Logged;
+(function (Logged) {
+    /**
+     * Wraps a pure value into a `Logged` with an empty log.
+     *
+     * @example
+     * ```ts
+     * Logged.make<string, number>(42); // { value: 42, log: [] }
+     * ```
+     */
+    Logged.make = (value) => ({ value, log: [] });
+    /**
+     * Creates a `Logged` that records a single log entry and produces no
+     * meaningful value. Use this to append to the log inside a `chain`.
+     *
+     * @example
+     * ```ts
+     * Logged.tell("operation completed"); // { value: undefined, log: ["operation completed"] }
+     * ```
+     */
+    Logged.tell = (entry) => ({ value: undefined, log: [entry] });
+    /**
+     * Transforms the value inside a `Logged` without affecting the log.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Logged.make<string, number>(5),
+     *   Logged.map(n => n * 2),
+     * ); // { value: 10, log: [] }
+     * ```
+     */
+    Logged.map = (f) => (data) => ({
+        value: f(data.value),
+        log: data.log,
+    });
+    /**
+     * Sequences two `Logged` computations, concatenating their logs.
+     * The value from the first is passed to `f`; the resulting log entries are
+     * appended after the entries from the first.
+     *
+     * Data-last — the first computation is the data being piped.
+     *
+     * @example
+     * ```ts
+     * const result = pipe(
+     *   Logged.make<string, number>(1),
+     *   Logged.chain(n => pipe(Logged.tell("step"), Logged.map(() => n + 1))),
+     *   Logged.chain(n => pipe(Logged.tell("done"), Logged.map(() => n * 10))),
+     * );
+     *
+     * Logged.run(result); // [20, ["step", "done"]]
+     * ```
+     */
+    Logged.chain = (f) => (data) => {
+        const next = f(data.value);
+        return { value: next.value, log: [...data.log, ...next.log] };
+    };
+    /**
+     * Applies a function wrapped in a `Logged` to a value wrapped in a `Logged`,
+     * concatenating both logs.
+     *
+     * @example
+     * ```ts
+     * const fn: Logged<string, (n: number) => number> = {
+     *   value: n => n * 2,
+     *   log: ["fn-loaded"],
+     * };
+     * const arg: Logged<string, number> = { value: 5, log: ["arg-loaded"] };
+     *
+     * const result = pipe(fn, Logged.ap(arg));
+     * Logged.run(result); // [10, ["fn-loaded", "arg-loaded"]]
+     * ```
+     */
+    Logged.ap = (arg) => (data) => ({
+        value: data.value(arg.value),
+        log: [...data.log, ...arg.log],
+    });
+    /**
+     * Runs a side effect on the value without changing the `Logged`.
+     * Useful for debugging or inspecting intermediate values.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Logged.make<string, number>(42),
+     *   Logged.tap(n => console.log("value:", n)),
+     * );
+     * ```
+     */
+    Logged.tap = (f) => (data) => {
+        f(data.value);
+        return data;
+    };
+    /**
+     * Extracts the value and log as a `readonly [A, ReadonlyArray<W>]` tuple.
+     * Use this at the boundary where you need to consume both.
+     *
+     * @example
+     * ```ts
+     * const result = pipe(
+     *   Logged.make<string, number>(1),
+     *   Logged.chain(n => pipe(Logged.tell("incremented"), Logged.map(() => n + 1))),
+     * );
+     *
+     * const [value, log] = Logged.run(result);
+     * // value = 2, log = ["incremented"]
+     * ```
+     */
+    Logged.run = (data) => [data.value, data.log];
+})(Logged || (Logged = {}));

package/esm/src/Core/Option.js

@@ -128,16 +128,17 @@ export var Option;
     Option.match = (cases) => (data) => Option.isSome(data) ? cases.some(data.value) : cases.none();
     /**
      * Returns the value inside an Option, or a default value if None.
+     * The default is a thunk `() => B` — evaluated only when the Option is None.
      * The default can be a different type, widening the result to `A | B`.
      *
      * @example
      * ```ts
-     * pipe(Option.some(5), Option.getOrElse(0)); // 5
-     * pipe(Option.none(), Option.getOrElse(0)); // 0
-     * pipe(Option.none<string>(), Option.getOrElse(null)); // null — typed as string | null
+     * pipe(Option.some(5), Option.getOrElse(() => 0)); // 5
+     * pipe(Option.none(), Option.getOrElse(() => 0)); // 0
+     * pipe(Option.none<string>(), Option.getOrElse(() => null)); // null — typed as string | null
      * ```
      */
-    Option.getOrElse = (defaultValue) => (data) => Option.isSome(data) ? data.value : defaultValue;
+    Option.getOrElse = (defaultValue) => (data) => Option.isSome(data) ? data.value : defaultValue();
     /**
      * Executes a side effect on the value without changing the Option.
      * Useful for logging or debugging.
@@ -166,7 +167,7 @@ export var Option;
      * pipe(Option.some(2), Option.filter(n => n > 3)); // None
      * ```
      */
-    Option.filter = (predicate) => (data) => Option.isSome(data) && predicate(data.value) ? data : Option.none();
+    Option.filter = (predicate) => (data) => Option.isSome(data) ? (predicate(data.value) ? data : Option.none()) : data;
     /**
      * Recovers from a None by providing a fallback Option.
      * The fallback can produce a different type, widening the result to `Option<A | B>`.

package/esm/src/Core/Predicate.js

@@ -0,0 +1,133 @@
+export var Predicate;
+(function (Predicate) {
+    /**
+     * Negates a predicate: the result passes exactly when the original fails.
+     *
+     * @example
+     * ```ts
+     * const isBlank: Predicate<string> = s => s.trim().length === 0;
+     * const isNotBlank = Predicate.not(isBlank);
+     *
+     * isNotBlank("hello");  // true
+     * isNotBlank("   ");    // false
+     * ```
+     */
+    Predicate.not = (p) => (a) => !p(a);
+    /**
+     * Combines two predicates with logical AND: passes only when both hold.
+     *
+     * Data-last — the first predicate is the data being piped.
+     *
+     * @example
+     * ```ts
+     * const isPositive: Predicate<number> = n => n > 0;
+     * const isEven: Predicate<number> = n => n % 2 === 0;
+     *
+     * const isPositiveEven: Predicate<number> = pipe(isPositive, Predicate.and(isEven));
+     *
+     * isPositiveEven(4);   // true
+     * isPositiveEven(3);   // false — positive but odd
+     * isPositiveEven(-2);  // false — even but not positive
+     * ```
+     */
+    Predicate.and = (second) => (first) => (a) => first(a) && second(a);
+    /**
+     * Combines two predicates with logical OR: passes when either holds.
+     *
+     * Data-last — the first predicate is the data being piped.
+     *
+     * @example
+     * ```ts
+     * const isChild: Predicate<number> = n => n < 13;
+     * const isSenior: Predicate<number> = n => n >= 65;
+     *
+     * const getsDiscount: Predicate<number> = pipe(isChild, Predicate.or(isSenior));
+     *
+     * getsDiscount(8);   // true
+     * getsDiscount(70);  // true
+     * getsDiscount(30);  // false
+     * ```
+     */
+    Predicate.or = (second) => (first) => (a) => first(a) || second(a);
+    /**
+     * Adapts a `Predicate<A>` to work on a different input type `B` by applying `f`
+     * to extract the relevant `A` from a `B` before running the check.
+     *
+     * Data-last — the predicate is the data being piped; `f` is the extractor.
+     *
+     * @example
+     * ```ts
+     * type User = { name: string; age: number };
+     *
+     * const isAdult: Predicate<number> = n => n >= 18;
+     *
+     * // Lift isAdult to work on Users by extracting the age field
+     * const isAdultUser: Predicate<User> = pipe(
+     *   isAdult,
+     *   Predicate.using((u: User) => u.age)
+     * );
+     *
+     * isAdultUser({ name: "Alice", age: 30 });  // true
+     * isAdultUser({ name: "Bob",   age: 15 });  // false
+     * ```
+     */
+    Predicate.using = (f) => (p) => (b) => p(f(b));
+    /**
+     * Combines an array of predicates with AND: passes only when every predicate holds.
+     * Returns `true` for an empty array (vacuous truth).
+     *
+     * @example
+     * ```ts
+     * const checks: Predicate<string>[] = [
+     *   s => s.length > 0,
+     *   s => s.length <= 100,
+     *   s => !s.includes("<"),
+     * ];
+     *
+     * Predicate.all(checks)("hello");  // true
+     * Predicate.all(checks)("");       // false — too short
+     * Predicate.all(checks)("<b>");    // false — contains "<"
+     * Predicate.all([])("anything");   // true
+     * ```
+     */
+    Predicate.all = (predicates) => (a) => predicates.every((p) => p(a));
+    /**
+     * Combines an array of predicates with OR: passes when at least one holds.
+     * Returns `false` for an empty array.
+     *
+     * @example
+     * ```ts
+     * const acceptedFormats: Predicate<string>[] = [
+     *   s => s.endsWith(".jpg"),
+     *   s => s.endsWith(".png"),
+     *   s => s.endsWith(".webp"),
+     * ];
+     *
+     * Predicate.any(acceptedFormats)("photo.jpg");   // true
+     * Predicate.any(acceptedFormats)("photo.gif");   // false
+     * Predicate.any([])("anything");                 // false
+     * ```
+     */
+    Predicate.any = (predicates) => (a) => predicates.some((p) => p(a));
+    /**
+     * Converts a `Refinement<A, B>` into a `Predicate<A>`, discarding the compile-time
+     * narrowing. Use this when you want to combine a type guard with plain predicates
+     * using `and`, `or`, or `all`.
+     *
+     * @example
+     * ```ts
+     * const isString: Refinement<unknown, string> =
+     *   Refinement.make(x => typeof x === "string");
+     *
+     * const isShortString: Predicate<unknown> = pipe(
+     *   Predicate.fromRefinement(isString),
+     *   Predicate.and(x => (x as string).length < 10)
+     * );
+     *
+     * isShortString("hi");            // true
+     * isShortString("a very long string that exceeds ten characters");  // false
+     * isShortString(42);              // false
+     * ```
+     */
+    Predicate.fromRefinement = (r) => r;
+})(Predicate || (Predicate = {}));

package/esm/src/Core/Refinement.js

@@ -0,0 +1,115 @@
+import { Option } from "./Option.js";
+import { Result } from "./Result.js";
+export var Refinement;
+(function (Refinement) {
+    /**
+     * Creates a `Refinement<A, B>` from a plain boolean predicate.
+     *
+     * This is an unsafe cast — the caller is responsible for ensuring that the
+     * predicate truly characterises values of type `B`. Use this only when
+     * bootstrapping a new refinement; prefer `compose`, `and`, or `or` to build
+     * derived refinements from existing ones.
+     *
+     * @example
+     * ```ts
+     * type PositiveNumber = number & { readonly _tag: "PositiveNumber" };
+     *
+     * const isPositive: Refinement<number, PositiveNumber> =
+     *   Refinement.make(n => n > 0);
+     * ```
+     */
+    Refinement.make = (f) => f;
+    /**
+     * Chains two refinements: if `ab` narrows `A` to `B` and `bc` narrows `B` to `C`,
+     * the result narrows `A` directly to `C`.
+     *
+     * Data-last — the first refinement `ab` is the data being piped.
+     *
+     * @example
+     * ```ts
+     * type NonEmptyString = string & { readonly _tag: "NonEmpty" };
+     * type TrimmedString  = NonEmptyString & { readonly _tag: "Trimmed" };
+     *
+     * const isNonEmpty: Refinement<string, NonEmptyString> =
+     *   Refinement.make(s => s.length > 0);
+     * const isTrimmed: Refinement<NonEmptyString, TrimmedString> =
+     *   Refinement.make(s => s === s.trim());
+     *
+     * const isNonEmptyTrimmed: Refinement<string, TrimmedString> = pipe(
+     *   isNonEmpty,
+     *   Refinement.compose(isTrimmed)
+     * );
+     * ```
+     */
+    Refinement.compose = (bc) => (ab) => (a) => ab(a) && bc(a);
+    /**
+     * Intersects two refinements: the result narrows `A` to `B & C`, passing only
+     * when both refinements hold simultaneously.
+     *
+     * Data-last — the first refinement is the data being piped.
+     *
+     * @example
+     * ```ts
+     * const isString: Refinement<unknown, string> = Refinement.make(x => typeof x === "string");
+     * const isNonEmpty: Refinement<unknown, { length: number }> =
+     *   Refinement.make(x => (x as any).length > 0);
+     *
+     * const isNonEmptyString = pipe(isString, Refinement.and(isNonEmpty));
+     * isNonEmptyString("hi");  // true
+     * isNonEmptyString("");    // false
+     * ```
+     */
+    Refinement.and = (second) => (first) => (a) => first(a) && second(a);
+    /**
+     * Unions two refinements: the result narrows `A` to `B | C`, passing when either
+     * refinement holds.
+     *
+     * Data-last — the first refinement is the data being piped.
+     *
+     * @example
+     * ```ts
+     * const isString:  Refinement<unknown, string>  = Refinement.make(x => typeof x === "string");
+     * const isNumber:  Refinement<unknown, number>  = Refinement.make(x => typeof x === "number");
+     *
+     * const isStringOrNumber = pipe(isString, Refinement.or(isNumber));
+     * isStringOrNumber("hi"); // true
+     * isStringOrNumber(42);   // true
+     * isStringOrNumber(true); // false
+     * ```
+     */
+    Refinement.or = (second) => (first) => (a) => first(a) || second(a);
+    /**
+     * Converts a `Refinement<A, B>` into a function `(a: A) => Option<B>`.
+     *
+     * Returns `Some(a)` when the refinement holds, `None` otherwise. Useful for
+     * integrating runtime validation into an `Option`-based pipeline.
+     *
+     * @example
+     * ```ts
+     * type PositiveNumber = number & { readonly _tag: "Positive" };
+     * const isPositive: Refinement<number, PositiveNumber> =
+     *   Refinement.make(n => n > 0);
+     *
+     * pipe(-1, Refinement.toFilter(isPositive)); // None
+     * pipe(42, Refinement.toFilter(isPositive)); // Some(42)
+     * ```
+     */
+    Refinement.toFilter = (r) => (a) => r(a) ? Option.some(a) : Option.none();
+    /**
+     * Converts a `Refinement<A, B>` into a function `(a: A) => Result<E, B>`.
+     *
+     * Returns `Ok(a)` when the refinement holds, `Err(onFail(a))` otherwise. Use
+     * this to surface validation failures as typed errors inside a `Result` pipeline.
+     *
+     * @example
+     * ```ts
+     * type NonEmptyString = string & { readonly _tag: "NonEmpty" };
+     * const isNonEmpty: Refinement<string, NonEmptyString> =
+     *   Refinement.make(s => s.length > 0);
+     *
+     * pipe("", Refinement.toResult(isNonEmpty, () => "must not be empty")); // Err(...)
+     * pipe("hi", Refinement.toResult(isNonEmpty, () => "must not be empty")); // Ok("hi")
+     * ```
+     */
+    Refinement.toResult = (r, onFail) => (a) => r(a) ? Result.ok(a) : Result.err(onFail(a));
+})(Refinement || (Refinement = {}));

package/esm/src/Core/RemoteData.js

@@ -162,7 +162,7 @@ export var RemoteData;
      * pipe(RemoteData.loading<string, number>(), RemoteData.getOrElse(null)); // null — typed as number | null
      * ```
      */
-    RemoteData.getOrElse = (defaultValue) => (data) => RemoteData.isSuccess(data) ? data.value : defaultValue;
+    RemoteData.getOrElse = (defaultValue) => (data) => RemoteData.isSuccess(data) ? data.value : defaultValue();
     /**
      * Executes a side effect on the success value without changing the RemoteData.
      *

package/esm/src/Core/Result.js

@@ -1,3 +1,4 @@
+import { Option } from "./Option.js";
 export var Result;
 (function (Result) {
     /**
@@ -102,16 +103,17 @@ export var Result;
     Result.match = (cases) => (data) => Result.isOk(data) ? cases.ok(data.value) : cases.err(data.error);
     /**
      * Returns the success value or a default value if the Result is an error.
+     * The default is a thunk `() => B` — evaluated only when the Result is Err.
      * The default can be a different type, widening the result to `A | B`.
      *
      * @example
      * ```ts
-     * pipe(Result.ok(5), Result.getOrElse(0)); // 5
-     * pipe(Result.err("error"), Result.getOrElse(0)); // 0
-     * pipe(Result.err("error"), Result.getOrElse(null)); // null — typed as number | null
+     * pipe(Result.ok(5), Result.getOrElse(() => 0)); // 5
+     * pipe(Result.err("error"), Result.getOrElse(() => 0)); // 0
+     * pipe(Result.err("error"), Result.getOrElse(() => null)); // null — typed as number | null
      * ```
      */
-    Result.getOrElse = (defaultValue) => (data) => Result.isOk(data) ? data.value : defaultValue;
+    Result.getOrElse = (defaultValue) => (data) => Result.isOk(data) ? data.value : defaultValue();
     /**
      * Executes a side effect on the success value without changing the Result.
      * Useful for logging or debugging.
@@ -134,7 +136,7 @@ export var Result;
      * Recovers from an error by providing a fallback Result.
      * The fallback can produce a different success type, widening the result to `Result<E, A | B>`.
      */
-    Result.recover = (fallback) => (data) => Result.isOk(data) ? data : fallback();
+    Result.recover = (fallback) => (data) => Result.isOk(data) ? data : fallback(data.error);
     /**
      * Recovers from an error unless it matches the blocked error.
      * The fallback can produce a different success type, widening the result to `Result<E, A | B>`.
@@ -150,7 +152,7 @@ export var Result;
      * Result.toOption(Result.err("oops")); // None
      * ```
      */
-    Result.toOption = (data) => Result.isOk(data) ? { kind: "Some", value: data.value } : { kind: "None" };
+    Result.toOption = (data) => Result.isOk(data) ? Option.some(data.value) : Option.none();
     /**
      * Applies a function wrapped in an Result to a value wrapped in an Result.
      *