@nlozgachev/pipelined 0.12.0 → 0.13.0

package/esm/src/Composition/converge.js

@@ -1,3 +0,0 @@
-export function converge(f, transformers) {
-    return (a) => f(...transformers.map((t) => t(a)));
-}

package/esm/src/Composition/curry.js

@@ -1,42 +0,0 @@
-/**
- * Converts a multi-argument function into a curried function.
- * The inverse of `uncurry`.
- *
- * @example
- * ```ts
- * const add = (a: number, b: number) => a + b;
- * const curriedAdd = curry(add);
- * curriedAdd(1)(2); // 3
- *
- * // Partial application
- * const addTen = curriedAdd(10);
- * addTen(5); // 15
- * ```
- *
- * @see {@link uncurry} for the inverse operation
- * @see {@link curry3} for 3-argument functions
- * @see {@link curry4} for 4-argument functions
- */
-export const curry = (f) => (a) => (b) => f(a, b);
-/**
- * Converts a 3-argument function into a curried function.
- *
- * @example
- * ```ts
- * const add3 = (a: number, b: number, c: number) => a + b + c;
- * const curriedAdd3 = curry3(add3);
- * curriedAdd3(1)(2)(3); // 6
- * ```
- */
-export const curry3 = (f) => (a) => (b) => (c) => f(a, b, c);
-/**
- * Converts a 4-argument function into a curried function.
- *
- * @example
- * ```ts
- * const add4 = (a: number, b: number, c: number, d: number) => a + b + c + d;
- * const curriedAdd4 = curry4(add4);
- * curriedAdd4(1)(2)(3)(4); // 10
- * ```
- */
-export const curry4 = (f) => (a) => (b) => (c) => (d) => f(a, b, c, d);

package/esm/src/Composition/flip.js

@@ -1,20 +0,0 @@
-/**
- * Flips the order of arguments for a curried binary function.
- * Converts a data-last function to data-first.
- *
- * @example
- * ```ts
- * // Original data-last (for pipe)
- * pipe(
- *   Option.some(5),
- *   Option.map(n => n * 2)
- * ); // Some(10)
- *
- * // Flipped to data-first
- * const mapFirst = flip(Option.map);
- * mapFirst(Option.some(5))(n => n * 2); // Some(10)
- * ```
- *
- * @see {@link uncurry} for converting curried functions to multi-argument functions
- */
-export const flip = (f) => (b) => (a) => f(a)(b);

package/esm/src/Composition/flow.js

@@ -1,8 +0,0 @@
-export function flow(...fns) {
-    return (...args) => {
-        if (fns.length === 0)
-            return args[0];
-        const [first, ...rest] = fns;
-        return rest.reduce((acc, fn) => fn(acc), first(...args));
-    };
-}

package/esm/src/Composition/fn.js

@@ -1,85 +0,0 @@
-/**
- * Returns the value unchanged. The identity function.
- *
- * @example
- * ```ts
- * identity(42); // 42
- * pipe(Option.some(5), Option.fold(() => 0, identity)); // 5
- * ```
- */
-export const identity = (a) => a;
-/**
- * Creates a function that always returns the given value, ignoring its argument.
- *
- * @example
- * ```ts
- * const always42 = constant(42);
- * always42(); // 42
- * [1, 2, 3].map(constant("x")); // ["x", "x", "x"]
- * ```
- */
-export const constant = (a) => () => a;
-/** Always returns `true`. */
-export const constTrue = () => true;
-/** Always returns `false`. */
-export const constFalse = () => false;
-/** Always returns `null`. */
-export const constNull = () => null;
-/** Always returns `undefined`. */
-export const constUndefined = () => undefined;
-/** Always returns `void`. */
-export const constVoid = () => { };
-/**
- * Combines two predicates with logical AND.
- *
- * @example
- * ```ts
- * const isPositive = (n: number) => n > 0;
- * const isEven = (n: number) => n % 2 === 0;
- * const isPositiveEven = and(isPositive, isEven);
- *
- * isPositiveEven(4); // true
- * isPositiveEven(-2); // false
- * isPositiveEven(3); // false
- * ```
- */
-export const and = (p1, p2) => (...args) => p1(...args) && p2(...args);
-/**
- * Combines two predicates with logical OR.
- *
- * @example
- * ```ts
- * const isNegative = (n: number) => n < 0;
- * const isZero = (n: number) => n === 0;
- * const isNonPositive = or(isNegative, isZero);
- *
- * isNonPositive(-1); // true
- * isNonPositive(0); // true
- * isNonPositive(1); // false
- * ```
- */
-export const or = (p1, p2) => (...args) => p1(...args) || p2(...args);
-/**
- * Creates a function that executes at most once.
- * Subsequent calls return the cached result from the first execution.
- *
- * @example
- * ```ts
- * let count = 0;
- * const initOnce = once(() => { count++; return "initialized"; });
- *
- * initOnce(); // "initialized", count === 1
- * initOnce(); // "initialized", count === 1 (not called again)
- * ```
- */
-export const once = (f) => {
-    let called = false;
-    let result;
-    return () => {
-        if (!called) {
-            result = f();
-            called = true;
-        }
-        return result;
-    };
-};

package/esm/src/Composition/index.js

@@ -1,13 +0,0 @@
-export * from "./compose.js";
-export * from "./converge.js";
-export * from "./curry.js";
-export * from "./flip.js";
-export * from "./fn.js";
-export * from "./flow.js";
-export * from "./juxt.js";
-export * from "./memoize.js";
-export * from "./not.js";
-export * from "./on.js";
-export * from "./pipe.js";
-export * from "./tap.js";
-export * from "./uncurry.js";

package/esm/src/Composition/juxt.js

@@ -1,3 +0,0 @@
-export function juxt(fns) {
-    return (a) => fns.map((f) => f(a));
-}

package/esm/src/Composition/memoize.js

@@ -1,66 +0,0 @@
-/**
- * Creates a memoized version of a function that caches results.
- * Subsequent calls with the same argument return the cached result.
- *
- * By default, uses the argument directly as the cache key.
- * For complex arguments, provide a custom `keyFn` to generate cache keys.
- *
- * @example
- * ```ts
- * // Basic usage
- * const expensive = memoize((n: number) => {
- *   console.log("Computing...");
- *   return n * 2;
- * });
- *
- * expensive(5); // logs "Computing...", returns 10
- * expensive(5); // returns 10 (cached, no log)
- * expensive(3); // logs "Computing...", returns 6
- *
- * // With custom key function for objects
- * const fetchUser = memoize(
- *   (opts: { id: string }) => fetch(`/users/${opts.id}`),
- *   opts => opts.id
- * );
- * ```
- */
-export const memoize = (f, keyFn = (a) => a) => {
-    const cache = new Map();
-    return (a) => {
-        const key = keyFn(a);
-        if (cache.has(key)) {
-            return cache.get(key);
-        }
-        const result = f(a);
-        cache.set(key, result);
-        return result;
-    };
-};
-/**
- * Creates a memoized version of a function using WeakMap.
- * Only works with object arguments, but allows garbage collection
- * of cached values when keys are no longer referenced.
- *
- * @example
- * ```ts
- * const processUser = memoizeWeak((user: User) => {
- *   return expensiveOperation(user);
- * });
- *
- * const user = { id: 1, name: "Alice" };
- * processUser(user); // computed
- * processUser(user); // cached
- * // When `user` is garbage collected, cached result is too
- * ```
- */
-export const memoizeWeak = (f) => {
-    const cache = new WeakMap();
-    return (a) => {
-        if (cache.has(a)) {
-            return cache.get(a);
-        }
-        const result = f(a);
-        cache.set(a, result);
-        return result;
-    };
-};

package/esm/src/Composition/not.js

@@ -1,25 +0,0 @@
-/**
- * Negates a predicate function.
- * Returns a new predicate that returns true when the original returns false, and vice versa.
- *
- * @example
- * ```ts
- * const isEven = (n: number) => n % 2 === 0;
- * const isOdd = not(isEven);
- *
- * isOdd(3); // true
- * isOdd(4); // false
- *
- * // With array methods
- * const numbers = [1, 2, 3, 4, 5];
- * numbers.filter(not(isEven)); // [1, 3, 5]
- *
- * // In pipelines
- * pipe(
- *   users,
- *   Array.filter(not(isAdmin)),
- *   Array.map(u => u.name)
- * );
- * ```
- */
-export const not = (predicate) => (...args) => !predicate(...args);

package/esm/src/Composition/on.js

@@ -1,12 +0,0 @@
-/**
- * Applies a projection to both arguments of a binary function before calling it.
- * Most useful for building comparators and equality checks over projected values.
- *
- * @example
- * ```ts
- * const byLength = on((a: number, b: number) => a - b, (s: string) => s.length);
- *
- * ["banana", "fig", "apple"].sort(byLength); // ["fig", "apple", "banana"]
- * ```
- */
-export const on = (f, g) => (a, b) => f(g(a), g(b));

package/esm/src/Composition/pipe.js

@@ -1,3 +0,0 @@
-export function pipe(a, ...fns) {
-    return fns.reduce((acc, fn) => fn(acc), a);
-}

package/esm/src/Composition/tap.js

@@ -1,33 +0,0 @@
-/**
- * Executes a side effect function and returns the original value unchanged.
- * Useful for logging, debugging, or other side effects within a pipeline.
- *
- * @example
- * ```ts
- * // Debugging a pipeline
- * pipe(
- *   Option.some(5),
- *   tap(x => console.log("Before map:", x)),
- *   Option.map(n => n * 2),
- *   tap(x => console.log("After map:", x)),
- *   Option.getOrElse(0)
- * );
- * // logs: "Before map: { kind: 'Some', value: 5 }"
- * // logs: "After map: { kind: 'Some', value: 10 }"
- * // returns: 10
- *
- * // Collecting intermediate values
- * const values: number[] = [];
- * pipe(
- *   [1, 2, 3],
- *   arr => arr.map(n => n * 2),
- *   tap(arr => values.push(...arr))
- * );
- * ```
- *
- * @see {@link Option.tap} for Option-specific tap that only runs on Some
- */
-export const tap = (f) => (a) => {
-    f(a);
-    return a;
-};

package/esm/src/Composition/uncurry.js

@@ -1,32 +0,0 @@
-// deno-lint-ignore no-explicit-any
-export function uncurry(f) {
-    // f.length determines the outer arity; inner.length determines the inner arity.
-    // The typed overloads guarantee these are 0, 1, or 2 total args.
-    // deno-lint-ignore no-explicit-any
-    return (...args) => {
-        const inner = f(...args.slice(0, f.length));
-        return inner.length === 0 ? inner() : inner(...args.slice(f.length));
-    };
-}
-/**
- * Converts a curried 3-argument function into a multi-argument function.
- *
- * @example
- * ```ts
- * const curriedAdd3 = (a: number) => (b: number) => (c: number) => a + b + c;
- * const add3 = uncurry3(curriedAdd3);
- * add3(1, 2, 3); // 6
- * ```
- */
-export const uncurry3 = (f) => (a, b, c) => f(a)(b)(c);
-/**
- * Converts a curried 4-argument function into a multi-argument function.
- *
- * @example
- * ```ts
- * const curriedAdd4 = (a: number) => (b: number) => (c: number) => (d: number) => a + b + c + d;
- * const add4 = uncurry4(curriedAdd4);
- * add4(1, 2, 3, 4); // 10
- * ```
- */
-export const uncurry4 = (f) => (a, b, c, d) => f(a)(b)(c)(d);

package/esm/src/Core/Deferred.js

@@ -1,30 +0,0 @@
-const _store = new WeakMap();
-export var Deferred;
-(function (Deferred) {
-    /**
-     * Wraps a `Promise` into a `Deferred`, structurally excluding rejection handlers,
-     * `.catch()`, `.finally()`, and chainable `.then()`.
-     *
-     * @example
-     * ```ts
-     * const d = Deferred.fromPromise(Promise.resolve("hello"));
-     * const value = await d; // "hello"
-     * ```
-     */
-    Deferred.fromPromise = (p) => {
-        const d = ({ then: ((f) => p.then(f)) });
-        _store.set(d, p);
-        return d;
-    };
-    /**
-     * Converts a `Deferred` back into a `Promise`.
-     *
-     * @example
-     * ```ts
-     * const p = Deferred.toPromise(Deferred.fromPromise(Promise.resolve(42)));
-     * // p is Promise<42>
-     * ```
-     */
-    Deferred.toPromise = (d) => _store.get(d) ??
-        new Promise((resolve) => d.then(resolve));
-})(Deferred || (Deferred = {}));

package/esm/src/Core/InternalTypes.js

@@ -1 +0,0 @@
-export {};

package/esm/src/Core/Lens.js

@@ -1,98 +0,0 @@
-export var Lens;
-(function (Lens) {
-    /**
-     * Constructs a Lens from a getter and a setter.
-     *
-     * @example
-     * ```ts
-     * const nameLens = Lens.make(
-     *   (user: User) => user.name,
-     *   (name) => (user) => ({ ...user, name }),
-     * );
-     * ```
-     */
-    Lens.make = (get, set) => ({ get, set });
-    /**
-     * Creates a Lens that focuses on a property of an object.
-     * Call with the structure type first, then the key.
-     *
-     * @example
-     * ```ts
-     * const nameLens = Lens.prop<User>()("name");
-     * ```
-     */
-    Lens.prop = () => (key) => Lens.make((s) => s[key], (a) => (s) => ({ ...s, [key]: a }));
-    /**
-     * Reads the focused value from a structure.
-     *
-     * @example
-     * ```ts
-     * pipe(user, Lens.get(nameLens)); // "Alice"
-     * ```
-     */
-    Lens.get = (lens) => (s) => lens.get(s);
-    /**
-     * Replaces the focused value within a structure, returning a new structure.
-     *
-     * @example
-     * ```ts
-     * pipe(user, Lens.set(nameLens)("Bob")); // new User with name "Bob"
-     * ```
-     */
-    Lens.set = (lens) => (a) => (s) => lens.set(a)(s);
-    /**
-     * Applies a function to the focused value, returning a new structure.
-     *
-     * @example
-     * ```ts
-     * pipe(user, Lens.modify(nameLens)(n => n.toUpperCase())); // "ALICE"
-     * ```
-     */
-    Lens.modify = (lens) => (f) => (s) => lens.set(f(lens.get(s)))(s);
-    /**
-     * Composes two Lenses: focuses through the outer, then through the inner.
-     * Use in a pipe chain to build up a deep focus step by step.
-     *
-     * @example
-     * ```ts
-     * const userCityLens = pipe(
-     *   Lens.prop<User>()("address"),
-     *   Lens.andThen(Lens.prop<Address>()("city")),
-     * );
-     * ```
-     */
-    Lens.andThen = (inner) => (outer) => Lens.make((s) => inner.get(outer.get(s)), (b) => (s) => outer.set(inner.set(b)(outer.get(s)))(s));
-    /**
-     * Composes a Lens with an Optional, producing an Optional.
-     * Use when the next step in the focus is optional (may be absent).
-     *
-     * @example
-     * ```ts
-     * const userBioOpt = pipe(
-     *   Lens.prop<User>()("profile"),
-     *   Lens.andThenOptional(Optional.prop<Profile>()("bio")),
-     * );
-     * ```
-     */
-    Lens.andThenOptional = (inner) => (outer) => ({
-        get: (s) => inner.get(outer.get(s)),
-        set: (b) => (s) => outer.set(inner.set(b)(outer.get(s)))(s),
-    });
-    /**
-     * Converts a Lens to an Optional. Every Lens is a valid Optional
-     * whose get always returns Some.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Lens.prop<User>()("address"),
-     *   Lens.toOptional,
-     *   Optional.andThen(Optional.prop<Address>()("landmark")),
-     * );
-     * ```
-     */
-    Lens.toOptional = (lens) => ({
-        get: (s) => ({ kind: "Some", value: lens.get(s) }),
-        set: lens.set,
-    });
-})(Lens || (Lens = {}));

package/esm/src/Core/Logged.js

@@ -1,111 +0,0 @@
-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 = {}));