@nlozgachev/pipelined 0.6.5 → 0.7.0

package/types/src/Core/Logged.d.ts

@@ -0,0 +1,126 @@
+import { WithLog, WithValue } from "./InternalTypes.js";
+/**
+ * A value paired with an accumulated log.
+ *
+ * `Logged<W, A>` pairs a result `A` with a sequence of log entries `W`. When
+ * you sequence two `Logged` computations with `chain`, the logs are
+ * automatically concatenated — you never have to thread the log array through
+ * your code manually.
+ *
+ * @example
+ * ```ts
+ * const program = pipe(
+ *   Logged.make<string, number>(0),
+ *   Logged.chain(n => pipe(
+ *     Logged.tell("start"),
+ *     Logged.map(() => n + 1),
+ *   )),
+ *   Logged.chain(n => pipe(
+ *     Logged.tell("done"),
+ *     Logged.map(() => n * 10),
+ *   )),
+ * );
+ *
+ * Logged.run(program); // [10, ["start", "done"]]
+ * ```
+ */
+export type Logged<L, A> = WithValue<A> & WithLog<L>;
+export declare namespace Logged {
+    /**
+     * Wraps a pure value into a `Logged` with an empty log.
+     *
+     * @example
+     * ```ts
+     * Logged.make<string, number>(42); // { value: 42, log: [] }
+     * ```
+     */
+    const make: <W, A>(value: A) => Logged<W, A>;
+    /**
+     * 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"] }
+     * ```
+     */
+    const tell: <W>(entry: W) => Logged<W, undefined>;
+    /**
+     * Transforms the value inside a `Logged` without affecting the log.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Logged.of<string, number>(5),
+     *   Logged.map(n => n * 2),
+     * ); // { value: 10, log: [] }
+     * ```
+     */
+    const map: <W, A, B>(f: (a: A) => B) => (data: Logged<W, A>) => Logged<W, B>;
+    /**
+     * 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.of<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"]]
+     * ```
+     */
+    const chain: <W, A, B>(f: (a: A) => Logged<W, B>) => (data: Logged<W, A>) => Logged<W, B>;
+    /**
+     * 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"]]
+     * ```
+     */
+    const ap: <W, A>(arg: Logged<W, A>) => <B>(data: Logged<W, (a: A) => B>) => Logged<W, B>;
+    /**
+     * Runs a side effect on the value without changing the `Logged`.
+     * Useful for debugging or inspecting intermediate values.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Logged.of<string, number>(42),
+     *   Logged.tap(n => console.log("value:", n)),
+     * );
+     * ```
+     */
+    const tap: <W, A>(f: (a: A) => void) => (data: Logged<W, A>) => Logged<W, A>;
+    /**
+     * 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.of<string, number>(1),
+     *   Logged.chain(n => pipe(Logged.tell("incremented"), Logged.map(() => n + 1))),
+     * );
+     *
+     * const [value, log] = Logged.run(result);
+     * // value = 2, log = ["incremented"]
+     * ```
+     */
+    const run: <W, A>(data: Logged<W, A>) => readonly [A, ReadonlyArray<W>];
+}
+//# sourceMappingURL=Logged.d.ts.map

package/types/src/Core/Logged.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Logged.d.ts","sourceRoot":"","sources":["../../../src/src/Core/Logged.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAErD,yBAAiB,MAAM,CAAC;IACtB;;;;;;;OAOG;IACI,MAAM,IAAI,GAAI,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,KAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAAyB,CAAC;IAE3E;;;;;;;;OAQG;IACI,MAAM,IAAI,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,MAAM,CAAC,CAAC,EAAE,SAAS,CAAyC,CAAC;IAEhG;;;;;;;;;;OAUG;IACI,MAAM,GAAG,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAG/E,CAAC;IAEH;;;;;;;;;;;;;;;;;OAiBG;IACI,MAAM,KAAK,GACf,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAGxE,CAAC;IAEJ;;;;;;;;;;;;;;;OAeG;IACI,MAAM,EAAE,GACZ,CAAC,EAAE,CAAC,EAAE,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,KAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAGzE,CAAC;IAEL;;;;;;;;;;;OAWG;IACI,MAAM,GAAG,GAAI,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAGhF,CAAC;IAEF;;;;;;;;;;;;;;OAcG;IACI,MAAM,GAAG,GAAI,CAAC,EAAE,CAAC,EACtB,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KACjB,SAAS,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,CAA2B,CAAC;CAC7D"}

package/types/src/Core/Predicate.d.ts

@@ -0,0 +1,161 @@
+import { Refinement } from "./Refinement.js";
+/**
+ * A boolean-valued function over a type `A`.
+ *
+ * A `Predicate<A>` is the simpler sibling of `Refinement<A, B>`: it tests whether a
+ * value satisfies a condition at runtime but carries no compile-time narrowing guarantee.
+ * Use it when you need to combine, negate, or adapt boolean checks as first-class values
+ * and do not require the extra type information that a `Refinement` provides.
+ *
+ * Every `Refinement<A, B>` is a `Predicate<A>` — convert with `Predicate.fromRefinement`
+ * when you want to compose a narrowing check alongside plain predicates.
+ *
+ * @example
+ * ```ts
+ * const isAdult: Predicate<number> = n => n >= 18;
+ * const isRetired: Predicate<number> = n => n >= 65;
+ *
+ * const isWorkingAge: Predicate<number> = pipe(
+ *   isAdult,
+ *   Predicate.and(Predicate.not(isRetired))
+ * );
+ *
+ * isWorkingAge(30);  // true
+ * isWorkingAge(15);  // false
+ * isWorkingAge(70);  // false
+ * ```
+ */
+export type Predicate<A> = (a: A) => boolean;
+export declare namespace 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
+     * ```
+     */
+    const not: <A>(p: Predicate<A>) => Predicate<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
+     * ```
+     */
+    const and: <A>(second: Predicate<A>) => (first: Predicate<A>) => Predicate<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
+     * ```
+     */
+    const or: <A>(second: Predicate<A>) => (first: Predicate<A>) => Predicate<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
+     * ```
+     */
+    const using: <A, B>(f: (b: B) => A) => (p: Predicate<A>) => Predicate<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
+     * ```
+     */
+    const all: <A>(predicates: ReadonlyArray<Predicate<A>>) => Predicate<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
+     * ```
+     */
+    const any: <A>(predicates: ReadonlyArray<Predicate<A>>) => Predicate<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
+     * ```
+     */
+    const fromRefinement: <A, B extends A>(r: Refinement<A, B>) => Predicate<A>;
+}
+//# sourceMappingURL=Predicate.d.ts.map

package/types/src/Core/Predicate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Predicate.d.ts","sourceRoot":"","sources":["../../../src/src/Core/Predicate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;AAE7C,yBAAiB,SAAS,CAAC;IACzB;;;;;;;;;;;OAWG;IACI,MAAM,GAAG,GAAI,CAAC,EAAE,GAAG,SAAS,CAAC,CAAC,CAAC,KAAG,SAAS,CAAC,CAAC,CAAiB,CAAC;IAEtE;;;;;;;;;;;;;;;;OAgBG;IACI,MAAM,GAAG,GAAI,CAAC,EAAE,QAAQ,SAAS,CAAC,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC,CAAC,KAAG,SAAS,CAAC,CAAC,CAC3D,CAAC;IAExB;;;;;;;;;;;;;;;;OAgBG;IACI,MAAM,EAAE,GAAI,CAAC,EAAE,QAAQ,SAAS,CAAC,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC,CAAC,KAAG,SAAS,CAAC,CAAC,CAC1D,CAAC;IAExB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACI,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC,KAAG,SAAS,CAAC,CAAC,CAAmB,CAAC;IAEjG;;;;;;;;;;;;;;;;;OAiBG;IACI,MAAM,GAAG,GAAI,CAAC,EAAE,YAAY,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,KAAG,SAAS,CAAC,CAAC,CAC7C,CAAC;IAEhC;;;;;;;;;;;;;;;;OAgBG;IACI,MAAM,GAAG,GAAI,CAAC,EAAE,YAAY,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,KAAG,SAAS,CAAC,CAAC,CAC9C,CAAC;IAE/B;;;;;;;;;;;;;;;;;;;OAmBG;IACI,MAAM,cAAc,GAAI,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,SAAS,CAAC,CAAC,CAAM,CAAC;CACxF"}

package/types/src/Core/Refinement.d.ts

@@ -0,0 +1,138 @@
+import { Option } from "./Option.js";
+import { Result } from "./Result.js";
+/**
+ * A function from `A` to `A is B` — a type predicate paired with a runtime check.
+ *
+ * A `Refinement<A, B>` proves at compile time that a value of type `A` is actually
+ * the narrower type `B extends A`, backed by a runtime boolean test. Use it to
+ * express domain invariants (non-empty strings, positive numbers, valid emails) as
+ * first-class, composable values rather than one-off type guards scattered across
+ * the codebase.
+ *
+ * @example
+ * ```ts
+ * type NonEmptyString = string & { readonly _tag: "NonEmptyString" };
+ *
+ * const isNonEmpty: Refinement<string, NonEmptyString> =
+ *   Refinement.make(s => s.length > 0);
+ *
+ * pipe(
+ *   "hello",
+ *   Refinement.toFilter(isNonEmpty)
+ * ); // Some("hello")
+ * ```
+ */
+export type Refinement<A, B extends A> = (a: A) => a is B;
+export declare namespace 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);
+     * ```
+     */
+    const make: <A, B extends A>(f: (a: A) => boolean) => Refinement<A, B>;
+    /**
+     * 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)
+     * );
+     * ```
+     */
+    const compose: <A, B extends A, C extends B>(bc: Refinement<B, C>) => (ab: Refinement<A, B>) => Refinement<A, C>;
+    /**
+     * 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
+     * ```
+     */
+    const and: <A, C extends A>(second: Refinement<A, C>) => <B extends A>(first: Refinement<A, B>) => Refinement<A, B & C>;
+    /**
+     * 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
+     * ```
+     */
+    const or: <A, C extends A>(second: Refinement<A, C>) => <B extends A>(first: Refinement<A, B>) => Refinement<A, B | C>;
+    /**
+     * 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)
+     * ```
+     */
+    const toFilter: <A, B extends A>(r: Refinement<A, B>) => (a: A) => Option<B>;
+    /**
+     * 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")
+     * ```
+     */
+    const toResult: <A, B extends A, E>(r: Refinement<A, B>, onFail: (a: A) => E) => (a: A) => Result<E, B>;
+}
+//# sourceMappingURL=Refinement.d.ts.map

package/types/src/Core/Refinement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Refinement.d.ts","sourceRoot":"","sources":["../../../src/src/Core/Refinement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;AAE1D,yBAAiB,UAAU,CAAC;IAC1B;;;;;;;;;;;;;;;OAeG;IACI,MAAM,IAAI,GAAI,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,KAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CACpD,CAAC;IAExB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACI,MAAM,OAAO,GACjB,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,IAAI,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,MACjD,IAAI,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CACV,CAAC;IAEhC;;;;;;;;;;;;;;;;OAgBG;IACI,MAAM,GAAG,GACb,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,QAAQ,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,MACxC,CAAC,SAAS,CAAC,EAAE,OAAO,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CACnB,CAAC;IAE3C;;;;;;;;;;;;;;;;OAgBG;IACI,MAAM,EAAE,GACZ,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,QAAQ,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,MACxC,CAAC,SAAS,CAAC,EAAE,OAAO,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CACnB,CAAC;IAE3C;;;;;;;;;;;;;;;OAeG;IACI,MAAM,QAAQ,GAAI,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC,KAAG,MAAM,CAAC,CAAC,CAC1C,CAAC;IAExC;;;;;;;;;;;;;;;OAeG;IACI,MAAM,QAAQ,GAClB,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,KAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CACvC,CAAC;CACjD"}

package/types/src/Core/State.d.ts

@@ -0,0 +1,192 @@
+/**
+ * A synchronous computation that threads a piece of mutable state `S` through
+ * a pipeline without exposing mutation at call sites.
+ *
+ * At runtime a `State<S, A>` is just a function from an initial state to a pair
+ * `[value, nextState]`. Nothing runs until you supply the initial state with
+ * `State.run`, `State.evaluate`, or `State.execute`.
+ *
+ * @example
+ * ```ts
+ * type Counter = number;
+ *
+ * const increment: State<Counter, undefined> = State.modify(n => n + 1);
+ * const getCount:  State<Counter, Counter>   = State.get();
+ *
+ * const program = pipe(
+ *   increment,
+ *   State.chain(() => increment),
+ *   State.chain(() => getCount),
+ * );
+ *
+ * State.run(0)(program); // [2, 2]  — value is 2, final state is 2
+ * ```
+ */
+export type State<S, A> = (s: S) => readonly [A, S];
+export declare namespace State {
+    /**
+     * Lifts a pure value into a State computation. The state passes through unchanged.
+     *
+     * @example
+     * ```ts
+     * State.run(10)(State.resolve(42)); // [42, 10] — value 42, state unchanged
+     * ```
+     */
+    const resolve: <S, A>(value: A) => State<S, A>;
+    /**
+     * Produces the current state as the value, without modifying it.
+     *
+     * @example
+     * ```ts
+     * const readStack: State<string[], string[]> = State.get();
+     * State.run(["a", "b"])(readStack); // [["a", "b"], ["a", "b"]]
+     * ```
+     */
+    const get: <S>() => State<S, S>;
+    /**
+     * Reads a projection of the state without modifying it.
+     * Equivalent to `pipe(State.get(), State.map(f))` but more direct.
+     *
+     * @example
+     * ```ts
+     * type AppState = { count: number; label: string };
+     * const readCount: State<AppState, number> = State.gets(s => s.count);
+     * State.run({ count: 5, label: "x" })(readCount); // [5, { count: 5, label: "x" }]
+     * ```
+     */
+    const gets: <S, A>(f: (s: S) => A) => State<S, A>;
+    /**
+     * Replaces the current state with a new value. Produces no meaningful value.
+     *
+     * @example
+     * ```ts
+     * const reset: State<number, undefined> = State.put(0);
+     * State.run(99)(reset); // [undefined, 0]
+     * ```
+     */
+    const put: <S>(newState: S) => State<S, undefined>;
+    /**
+     * Applies a function to the current state to produce the next state.
+     * Produces no meaningful value.
+     *
+     * @example
+     * ```ts
+     * const push = (item: string): State<string[], undefined> =>
+     *   State.modify(stack => [...stack, item]);
+     *
+     * State.run(["a"])(push("b")); // [undefined, ["a", "b"]]
+     * ```
+     */
+    const modify: <S>(f: (s: S) => S) => State<S, undefined>;
+    /**
+     * Transforms the value produced by a State computation.
+     * The state transformation is unchanged.
+     *
+     * @example
+     * ```ts
+     * const readLength: State<string[], number> = pipe(
+     *   State.get<string[]>(),
+     *   State.map(stack => stack.length),
+     * );
+     *
+     * State.run(["a", "b", "c"])(readLength); // [3, ["a", "b", "c"]]
+     * ```
+     */
+    const map: <S, A, B>(f: (a: A) => B) => (st: State<S, A>) => State<S, B>;
+    /**
+     * Sequences two State computations. The state output of the first is passed
+     * as the state input to the second.
+     *
+     * Data-last — the first computation is the data being piped.
+     *
+     * @example
+     * ```ts
+     * const push = (item: string): State<string[], undefined> =>
+     *   State.modify(stack => [...stack, item]);
+     *
+     * const program = pipe(
+     *   push("a"),
+     *   State.chain(() => push("b")),
+     *   State.chain(() => State.get<string[]>()),
+     * );
+     *
+     * State.evaluate([])(program); // ["a", "b"]
+     * ```
+     */
+    const chain: <S, A, B>(f: (a: A) => State<S, B>) => (st: State<S, A>) => State<S, B>;
+    /**
+     * Applies a function wrapped in a State to a value wrapped in a State.
+     * The function computation runs first; its output state is the input to the
+     * argument computation.
+     *
+     * @example
+     * ```ts
+     * const addCounted = (n: number) => (m: number) => n + m;
+     * const program = pipe(
+     *   State.resolve<number, typeof addCounted>(addCounted),
+     *   State.ap(State.gets((s: number) => s * 2)),
+     *   State.ap(State.gets((s: number) => s)),
+     * );
+     *
+     * State.evaluate(3)(program); // 6 + 3 = 9
+     * ```
+     */
+    const ap: <S, A>(arg: State<S, A>) => <B>(fn: State<S, (a: A) => B>) => State<S, B>;
+    /**
+     * Runs a side effect on the produced value without changing the State computation.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   State.get<number>(),
+     *   State.tap(n => console.log("current:", n)),
+     *   State.chain(() => State.modify(n => n + 1)),
+     * );
+     * ```
+     */
+    const tap: <S, A>(f: (a: A) => void) => (st: State<S, A>) => State<S, A>;
+    /**
+     * Runs a State computation with an initial state, returning both the
+     * produced value and the final state as a pair.
+     *
+     * Data-last — the computation is the data being piped.
+     *
+     * @example
+     * ```ts
+     * const program = pipe(
+     *   State.modify<number>(n => n + 1),
+     *   State.chain(() => State.get<number>()),
+     * );
+     *
+     * State.run(0)(program); // [1, 1]
+     * ```
+     */
+    const run: <S>(initialState: S) => <A>(st: State<S, A>) => readonly [A, S];
+    /**
+     * Runs a State computation with an initial state, returning only the
+     * produced value (discarding the final state).
+     *
+     * @example
+     * ```ts
+     * State.evaluate([])(pipe(
+     *   State.modify<string[]>(s => [...s, "x"]),
+     *   State.chain(() => State.get<string[]>()),
+     * )); // ["x"]
+     * ```
+     */
+    const evaluate: <S>(initialState: S) => <A>(st: State<S, A>) => A;
+    /**
+     * Runs a State computation with an initial state, returning only the
+     * final state (discarding the produced value).
+     *
+     * @example
+     * ```ts
+     * State.execute(0)(pipe(
+     *   State.modify<number>(n => n + 10),
+     *   State.chain(() => State.modify<number>(n => n * 2)),
+     * )); // 20
+     * ```
+     */
+    const execute: <S>(initialState: S) => <A>(st: State<S, A>) => S;
+}
+//# sourceMappingURL=State.d.ts.map

package/types/src/Core/State.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"State.d.ts","sourceRoot":"","sources":["../../../src/src/Core/State.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,KAAK,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAEpD,yBAAiB,KAAK,CAAC;IACrB;;;;;;;OAOG;IACI,MAAM,OAAO,GAAI,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAsB,CAAC;IAE1E;;;;;;;;OAQG;IACI,MAAM,GAAG,GAAI,CAAC,OAAK,KAAK,CAAC,CAAC,EAAE,CAAC,CAAkB,CAAC;IAEvD;;;;;;;;;;OAUG;IACI,MAAM,IAAI,GAAI,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAqB,CAAC;IAE5E;;;;;;;;OAQG;IACI,MAAM,GAAG,GAAI,CAAC,EAAE,UAAU,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,SAAS,CAAkC,CAAC;IAE1F;;;;;;;;;;;OAWG;IACI,MAAM,MAAM,GAAI,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,SAAS,CAA6B,CAAC;IAE3F;;;;;;;;;;;;;OAaG;IACI,MAAM,GAAG,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAG5E,CAAC;IAEF;;;;;;;;;;;;;;;;;;;OAmBG;IACI,MAAM,KAAK,GACf,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAGnE,CAAC;IAEJ;;;;;;;;;;;;;;;;OAgBG;IACI,MAAM,EAAE,GACZ,CAAC,EAAE,CAAC,EAAE,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAIrE,CAAC;IAEJ;;;;;;;;;;;OAWG;IACI,MAAM,GAAG,GAAI,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,MAAM,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAI5E,CAAC;IAEF;;;;;;;;;;;;;;;OAeG;IACI,MAAM,GAAG,GAAI,CAAC,EAAE,cAAc,CAAC,MAAM,CAAC,EAAE,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,SAAS,CAAC,CAAC,EAAE,CAAC,CAC7D,CAAC;IAEnB;;;;;;;;;;;OAWG;IACI,MAAM,QAAQ,GAAI,CAAC,EAAE,cAAc,CAAC,MAAM,CAAC,EAAE,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,CAAwB,CAAC;IAE/F;;;;;;;;;;;OAWG;IACI,MAAM,OAAO,GAAI,CAAC,EAAE,cAAc,CAAC,MAAM,CAAC,EAAE,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,CAAwB,CAAC;CAC/F"}

package/types/src/Core/Task.d.ts

@@ -171,6 +171,36 @@ export declare namespace Task {
         when: (a: A) => boolean;
         delay?: number;
     }) => (task: Task<A>) => Task<A>;
+    /**
+     * Resolves with the value of the first Task to complete. All Tasks start
+     * immediately; the rest are abandoned once one resolves.
+     *
+     * @example
+     * ```ts
+     * const fast = Task.from(() => new Promise<string>(r => setTimeout(() => r("fast"), 10)));
+     * const slow = Task.from(() => new Promise<string>(r => setTimeout(() => r("slow"), 200)));
+     *
+     * await Task.race([fast, slow])(); // "fast"
+     * ```
+     */
+    const race: <A>(tasks: ReadonlyArray<Task<A>>) => Task<A>;
+    /**
+     * Runs an array of Tasks one at a time in order, collecting all results.
+     * Each Task starts only after the previous one resolves.
+     *
+     * @example
+     * ```ts
+     * let log: number[] = [];
+     * const makeTask = (n: number) => Task.from(() => {
+     *   log.push(n);
+     *   return Promise.resolve(n);
+     * });
+     *
+     * await Task.sequential([makeTask(1), makeTask(2), makeTask(3)])();
+     * // log = [1, 2, 3] — tasks ran in order
+     * ```
+     */
+    const sequential: <A>(tasks: ReadonlyArray<Task<A>>) => Task<ReadonlyArray<A>>;
     /**
      * Converts a `Task<A>` into a `Task<Result<E, A>>`, resolving to `Err` if the
      * Task does not complete within the given time.