@pithos/core 2.3.0 → 2.4.0

package/dist/eidos/facade/facade.js

@@ -0,0 +1,63 @@
+/**
+ * Functional Facade Pattern.
+ *
+ * In OOP, the Facade pattern requires a class that encapsulates multiple
+ * subsystems and exposes a simplified interface to clients.
+ *
+ * In functional TypeScript, this is absorbed by the language:
+ * a facade is just a function that orchestrates other functions.
+ * No wrapper needed — it's what functions naturally do.
+ *
+ * This module exists for documentation and discoverability. The function is
+ * marked `@deprecated` to guide developers toward idiomatic functional code.
+ *
+ * @module eidos/facade
+ * @since 2.4.0
+ *
+ * @see {@link https://pithos.dev/api/eidos/facade/ | Explanations, examples and live demo}
+ *
+ * @example
+ * ```ts
+ * // No import needed — just write a function:
+ *
+ * // Subsystems (could be from different modules)
+ * const validateUser = (data: UserInput) => { ... };
+ * const hashPassword = (password: string) => { ... };
+ * const saveToDb = (user: User) => { ... };
+ * const sendWelcomeEmail = (email: string) => { ... };
+ *
+ * // Facade: simplified interface hiding the complexity
+ * const registerUser = async (data: UserInput) => {
+ *   const validated = validateUser(data);
+ *   const hashedPassword = await hashPassword(validated.password);
+ *   const user = await saveToDb({ ...validated, password: hashedPassword });
+ *   await sendWelcomeEmail(user.email);
+ *   return user;
+ * };
+ *
+ * // Client only sees registerUser, not the subsystems
+ * await registerUser({ name: "Alice", email: "alice@example.com", password: "..." });
+ * ```
+ *
+ * @deprecated **Pattern absorbed by the language.**
+ *
+ * In functional TypeScript, a facade is just a function that calls other functions.
+ * This function is the identity — it exists only so you find this message.
+ *
+ * Write your facade directly:
+ * ```ts
+ * const checkout = (cart: Cart, payment: Payment) => {
+ *   const validated = validateCart(cart);
+ *   const charged = processPayment(payment, validated.total);
+ *   const order = createOrder(validated, charged);
+ *   sendConfirmation(order);
+ *   return order;
+ * };
+ * ```
+ *
+ * @see {@link https://pithos.dev/api/eidos/facade/ | Full explanation, examples and live demo}
+ */
+export function createFacade(fn) {
+    return fn;
+}
+//# sourceMappingURL=facade.js.map

package/dist/eidos/facade/facade.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"facade.js","sourceRoot":"","sources":["../../../src/eidos/facade/facade.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,MAAM,UAAU,YAAY,CAC1B,EAA6B;IAE7B,OAAO,EAAE,CAAC;AACZ,CAAC"}

package/dist/eidos/factory-method/factory-method.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Functional Factory Method Pattern.
+ *
+ * In OOP, the Factory Method pattern requires an abstract Creator class with
+ * an abstract `factoryMethod()`, and concrete subclasses that override it to
+ * produce different products. The Creator's business logic calls `factoryMethod()`
+ * without knowing which concrete product it will get.
+ *
+ * In functional TypeScript, this is just dependency injection: pass the factory
+ * as a parameter. The pattern is absorbed by the language — no wrapper needed.
+ *
+ * This module exists for documentation and discoverability. The function is
+ * marked `@deprecated` to guide developers toward idiomatic functional code.
+ *
+ * @module eidos/factory-method
+ * @since 2.4.0
+ *
+ * @see {@link https://pithos.dev/api/eidos/factory-method/ | Explanations, examples and live demo}
+ *
+ * @example
+ * ```ts
+ * // No import needed — just pass the factory as a parameter:
+ * type Product = { operation: () => string };
+ *
+ * const businessLogic = (createProduct: () => Product) => {
+ *   const product = createProduct();
+ *   return `Working with ${product.operation()}`;
+ * };
+ *
+ * // Different "concrete creators" are just different factory functions:
+ * const createProductA = (): Product => ({ operation: () => "ProductA" });
+ * const createProductB = (): Product => ({ operation: () => "ProductB" });
+ *
+ * businessLogic(createProductA); // "Working with ProductA"
+ * businessLogic(createProductB); // "Working with ProductB"
+ * ```
+ */
+/**
+ * A Factory is a function that creates a product.
+ * This is just a type alias for documentation.
+ *
+ * @internal Not exported in API docs — use inline `() => T` instead
+ * @template T - The product type
+ * @since 2.4.0
+ */
+export type Factory<T> = () => T;
+/**
+ * A ParameterizedFactory creates products based on input parameters.
+ *
+ * @internal Not exported in API docs — use inline `(input: In) => T` instead
+ * @template In - The input/configuration type
+ * @template T - The product type
+ * @since 2.4.0
+ */
+export type ParameterizedFactory<In, T> = (input: In) => T;
+/**
+ * @deprecated **Pattern absorbed by the language.**
+ *
+ * In functional TypeScript, the Factory Method is just dependency injection.
+ * Pass the factory as a parameter — no wrapper needed.
+ *
+ * This function is the identity — it exists only so you find this message.
+ *
+ * Write your code directly:
+ * ```ts
+ * const process = (createProduct: () => Product) => {
+ *   const product = createProduct();
+ *   return product.doSomething();
+ * };
+ * ```
+ *
+ * @see {@link https://pithos.dev/api/eidos/factory-method/ | Full explanation, examples and live demo}
+ * @since 2.4.0
+ */
+export declare function createFactoryMethod<T>(factory: () => T): () => T;
+//# sourceMappingURL=factory-method.d.ts.map

package/dist/eidos/factory-method/factory-method.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory-method.d.ts","sourceRoot":"","sources":["../../../src/eidos/factory-method/factory-method.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH;;;;;;;GAOG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC;AAEjC;;;;;;;GAOG;AACH,MAAM,MAAM,oBAAoB,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,KAAK,CAAC,CAAC;AAE3D;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,CAEhE"}

package/dist/eidos/factory-method/factory-method.js

@@ -0,0 +1,60 @@
+/**
+ * Functional Factory Method Pattern.
+ *
+ * In OOP, the Factory Method pattern requires an abstract Creator class with
+ * an abstract `factoryMethod()`, and concrete subclasses that override it to
+ * produce different products. The Creator's business logic calls `factoryMethod()`
+ * without knowing which concrete product it will get.
+ *
+ * In functional TypeScript, this is just dependency injection: pass the factory
+ * as a parameter. The pattern is absorbed by the language — no wrapper needed.
+ *
+ * This module exists for documentation and discoverability. The function is
+ * marked `@deprecated` to guide developers toward idiomatic functional code.
+ *
+ * @module eidos/factory-method
+ * @since 2.4.0
+ *
+ * @see {@link https://pithos.dev/api/eidos/factory-method/ | Explanations, examples and live demo}
+ *
+ * @example
+ * ```ts
+ * // No import needed — just pass the factory as a parameter:
+ * type Product = { operation: () => string };
+ *
+ * const businessLogic = (createProduct: () => Product) => {
+ *   const product = createProduct();
+ *   return `Working with ${product.operation()}`;
+ * };
+ *
+ * // Different "concrete creators" are just different factory functions:
+ * const createProductA = (): Product => ({ operation: () => "ProductA" });
+ * const createProductB = (): Product => ({ operation: () => "ProductB" });
+ *
+ * businessLogic(createProductA); // "Working with ProductA"
+ * businessLogic(createProductB); // "Working with ProductB"
+ * ```
+ */
+/**
+ * @deprecated **Pattern absorbed by the language.**
+ *
+ * In functional TypeScript, the Factory Method is just dependency injection.
+ * Pass the factory as a parameter — no wrapper needed.
+ *
+ * This function is the identity — it exists only so you find this message.
+ *
+ * Write your code directly:
+ * ```ts
+ * const process = (createProduct: () => Product) => {
+ *   const product = createProduct();
+ *   return product.doSomething();
+ * };
+ * ```
+ *
+ * @see {@link https://pithos.dev/api/eidos/factory-method/ | Full explanation, examples and live demo}
+ * @since 2.4.0
+ */
+export function createFactoryMethod(factory) {
+    return factory;
+}
+//# sourceMappingURL=factory-method.js.map

package/dist/eidos/factory-method/factory-method.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory-method.js","sourceRoot":"","sources":["../../../src/eidos/factory-method/factory-method.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAsBH;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,mBAAmB,CAAI,OAAgB;IACrD,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/eidos/flyweight/flyweight.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Functional Flyweight Pattern.
+ *
+ * In OOP, the Flyweight pattern requires separating intrinsic state (shared)
+ * from extrinsic state (unique), with a factory that caches and reuses objects
+ * with the same intrinsic state to minimize memory consumption.
+ *
+ * In functional TypeScript, this is memoization/caching. Arkhe provides
+ * `memoize` which caches function results based on arguments (the "intrinsic"
+ * state). The extrinsic state is passed at call time.
+ *
+ * This module re-exports `memoize` from Arkhe for discoverability.
+ *
+ * @module eidos/flyweight
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * import { memoize } from "@pithos/core/eidos/flyweight/flyweight";
+ * // or directly from Arkhe:
+ * import { memoize } from "../../arkhe/function/memoize.js";
+ *
+ * // Flyweight factory: creates/caches car configs by intrinsic state
+ * const getCarConfig = memoize((brand: string, model: string, color: string) => ({
+ *   brand,
+ *   model,
+ *   color,
+ *   // ... expensive computed properties
+ * }));
+ *
+ * // Extrinsic state (unique per instance) passed separately
+ * const car1 = { config: getCarConfig("BMW", "M5", "red"), plates: "ABC123", owner: "Alice" };
+ * const car2 = { config: getCarConfig("BMW", "M5", "red"), plates: "XYZ789", owner: "Bob" };
+ *
+ * // Same config object is reused (flyweight)
+ * car1.config === car2.config; // true
+ * ```
+ */
+export { memoize } from "../../arkhe/function/memoize.js";
+//# sourceMappingURL=flyweight.d.ts.map

package/dist/eidos/flyweight/flyweight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flyweight.d.ts","sourceRoot":"","sources":["../../../src/eidos/flyweight/flyweight.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAGH,OAAO,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/eidos/flyweight/flyweight.js

@@ -0,0 +1,41 @@
+/**
+ * Functional Flyweight Pattern.
+ *
+ * In OOP, the Flyweight pattern requires separating intrinsic state (shared)
+ * from extrinsic state (unique), with a factory that caches and reuses objects
+ * with the same intrinsic state to minimize memory consumption.
+ *
+ * In functional TypeScript, this is memoization/caching. Arkhe provides
+ * `memoize` which caches function results based on arguments (the "intrinsic"
+ * state). The extrinsic state is passed at call time.
+ *
+ * This module re-exports `memoize` from Arkhe for discoverability.
+ *
+ * @module eidos/flyweight
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * import { memoize } from "@pithos/core/eidos/flyweight/flyweight";
+ * // or directly from Arkhe:
+ * import { memoize } from "../../arkhe/function/memoize.js";
+ *
+ * // Flyweight factory: creates/caches car configs by intrinsic state
+ * const getCarConfig = memoize((brand: string, model: string, color: string) => ({
+ *   brand,
+ *   model,
+ *   color,
+ *   // ... expensive computed properties
+ * }));
+ *
+ * // Extrinsic state (unique per instance) passed separately
+ * const car1 = { config: getCarConfig("BMW", "M5", "red"), plates: "ABC123", owner: "Alice" };
+ * const car2 = { config: getCarConfig("BMW", "M5", "red"), plates: "XYZ789", owner: "Bob" };
+ *
+ * // Same config object is reused (flyweight)
+ * car1.config === car2.config; // true
+ * ```
+ */
+// Re-export from Arkhe for discoverability
+export { memoize } from "../../arkhe/function/memoize.js";
+//# sourceMappingURL=flyweight.js.map

package/dist/eidos/flyweight/flyweight.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flyweight.js","sourceRoot":"","sources":["../../../src/eidos/flyweight/flyweight.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,2CAA2C;AAC3C,OAAO,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/eidos/interpreter/interpreter.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Functional Interpreter Pattern.
+ *
+ * In OOP, the Interpreter pattern requires an Expression interface with
+ * `interpret(context)`, terminal expressions (literals), and non-terminal
+ * expressions (operators that combine other expressions).
+ *
+ * In functional TypeScript, this is absorbed by the combination of:
+ * - **Discriminated unions** for the AST (expression tree)
+ * - **Recursive functions** for evaluation (like Visitor's switch)
+ * - **Composite's fold** for tree traversal
+ *
+ * The pattern is essentially: define your grammar as types, write an
+ * evaluator function that pattern-matches on the AST.
+ *
+ * @module eidos/interpreter
+ * @since 2.4.0
+ *
+ * @see {@link https://pithos.dev/api/eidos/interpreter/ | Explanations, examples and live demo}
+ *
+ * @example
+ * ```ts
+ * type Expr =
+ *   | { type: "num"; value: number }
+ *   | { type: "add"; left: Expr; right: Expr }
+ *   | { type: "mul"; left: Expr; right: Expr };
+ *
+ * const evaluate = (expr: Expr): number => {
+ *   switch (expr.type) {
+ *     case "num": return expr.value;
+ *     case "add": return evaluate(expr.left) + evaluate(expr.right);
+ *     case "mul": return evaluate(expr.left) * evaluate(expr.right);
+ *   }
+ * };
+ *
+ * // (5 + 3) * 2
+ * const expr: Expr = {
+ *   type: "mul",
+ *   left: { type: "add", left: { type: "num", value: 5 }, right: { type: "num", value: 3 } },
+ *   right: { type: "num", value: 2 },
+ * };
+ *
+ * evaluate(expr); // 16
+ * ```
+ *
+ * @deprecated **Pattern absorbed by the language.**
+ *
+ * In TypeScript, the Interpreter pattern is just:
+ * 1. A discriminated union for your AST
+ * 2. A recursive function that switches on the `type` discriminant
+ *
+ * Instead of `interpret(expr, ctx, evaluator)`, call the evaluator directly:
+ *
+ * ```ts
+ * // Before (with interpret)
+ * const html = interpret(ast, ctx, evalNode);
+ *
+ * // After (just call it)
+ * const html = evalNode(ast, ctx);
+ * ```
+ *
+ * Minimal example:
+ *
+ * ```ts
+ * type Expr =
+ *   | { type: "num"; value: number }
+ *   | { type: "add"; left: Expr; right: Expr };
+ *
+ * const evaluate = (expr: Expr): number => {
+ *   switch (expr.type) {
+ *     case "num": return expr.value;
+ *     case "add": return evaluate(expr.left) + evaluate(expr.right);
+ *   }
+ * };
+ *
+ * evaluate({ type: "add", left: { type: "num", value: 5 }, right: { type: "num", value: 3 } }); // 8
+ * ```
+ *
+ * @see {@link https://pithos.dev/api/eidos/interpreter/ | Full explanation, examples and live Markdown interpreter demo}
+ */
+export declare function interpret<Expr, Context, Result>(expr: Expr, ctx: Context, evaluator: (expr: Expr, ctx: Context) => Result): Result;
+//# sourceMappingURL=interpreter.d.ts.map

package/dist/eidos/interpreter/interpreter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpreter.d.ts","sourceRoot":"","sources":["../../../src/eidos/interpreter/interpreter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+EG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAC7C,IAAI,EAAE,IAAI,EACV,GAAG,EAAE,OAAO,EACZ,SAAS,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,KAAK,MAAM,GAC9C,MAAM,CAER"}

package/dist/eidos/interpreter/interpreter.js

@@ -0,0 +1,84 @@
+/**
+ * Functional Interpreter Pattern.
+ *
+ * In OOP, the Interpreter pattern requires an Expression interface with
+ * `interpret(context)`, terminal expressions (literals), and non-terminal
+ * expressions (operators that combine other expressions).
+ *
+ * In functional TypeScript, this is absorbed by the combination of:
+ * - **Discriminated unions** for the AST (expression tree)
+ * - **Recursive functions** for evaluation (like Visitor's switch)
+ * - **Composite's fold** for tree traversal
+ *
+ * The pattern is essentially: define your grammar as types, write an
+ * evaluator function that pattern-matches on the AST.
+ *
+ * @module eidos/interpreter
+ * @since 2.4.0
+ *
+ * @see {@link https://pithos.dev/api/eidos/interpreter/ | Explanations, examples and live demo}
+ *
+ * @example
+ * ```ts
+ * type Expr =
+ *   | { type: "num"; value: number }
+ *   | { type: "add"; left: Expr; right: Expr }
+ *   | { type: "mul"; left: Expr; right: Expr };
+ *
+ * const evaluate = (expr: Expr): number => {
+ *   switch (expr.type) {
+ *     case "num": return expr.value;
+ *     case "add": return evaluate(expr.left) + evaluate(expr.right);
+ *     case "mul": return evaluate(expr.left) * evaluate(expr.right);
+ *   }
+ * };
+ *
+ * // (5 + 3) * 2
+ * const expr: Expr = {
+ *   type: "mul",
+ *   left: { type: "add", left: { type: "num", value: 5 }, right: { type: "num", value: 3 } },
+ *   right: { type: "num", value: 2 },
+ * };
+ *
+ * evaluate(expr); // 16
+ * ```
+ *
+ * @deprecated **Pattern absorbed by the language.**
+ *
+ * In TypeScript, the Interpreter pattern is just:
+ * 1. A discriminated union for your AST
+ * 2. A recursive function that switches on the `type` discriminant
+ *
+ * Instead of `interpret(expr, ctx, evaluator)`, call the evaluator directly:
+ *
+ * ```ts
+ * // Before (with interpret)
+ * const html = interpret(ast, ctx, evalNode);
+ *
+ * // After (just call it)
+ * const html = evalNode(ast, ctx);
+ * ```
+ *
+ * Minimal example:
+ *
+ * ```ts
+ * type Expr =
+ *   | { type: "num"; value: number }
+ *   | { type: "add"; left: Expr; right: Expr };
+ *
+ * const evaluate = (expr: Expr): number => {
+ *   switch (expr.type) {
+ *     case "num": return expr.value;
+ *     case "add": return evaluate(expr.left) + evaluate(expr.right);
+ *   }
+ * };
+ *
+ * evaluate({ type: "add", left: { type: "num", value: 5 }, right: { type: "num", value: 3 } }); // 8
+ * ```
+ *
+ * @see {@link https://pithos.dev/api/eidos/interpreter/ | Full explanation, examples and live Markdown interpreter demo}
+ */
+export function interpret(expr, ctx, evaluator) {
+    return evaluator(expr, ctx);
+}
+//# sourceMappingURL=interpreter.js.map

package/dist/eidos/interpreter/interpreter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpreter.js","sourceRoot":"","sources":["../../../src/eidos/interpreter/interpreter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+EG;AACH,MAAM,UAAU,SAAS,CACvB,IAAU,EACV,GAAY,EACZ,SAA+C;IAE/C,OAAO,SAAS,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;AAC9B,CAAC"}

package/dist/eidos/iterator/iterator.d.ts

@@ -0,0 +1,164 @@
+/**
+ * Functional Iterator Pattern.
+ *
+ * In OOP, the Iterator pattern requires a Collection interface, an Iterator
+ * interface, and concrete implementations that decouple traversal from the
+ * underlying data structure.
+ * In functional TypeScript, iterators are lazy sequences built on the native
+ * `Iterable` protocol, created via `createIterable` which decouples traversal
+ * logic from data sources.
+ *
+ * JavaScript already has the Iterator protocol (`Symbol.iterator`, `for...of`).
+ * The core of this module is the **constructor** layer:
+ * - `createIterable` - the GoF concept: decouple traversal from structure
+ * - `lazyRange` - lazy numeric sequences (finite or infinite)
+ * - `iterate` - unfold from a seed function
+ *
+ * A minimal set of **companion operators** (`map`, `filter`, `take`) and
+ * **consumers** (`toArray`, `reduce`) is included to make the constructors
+ * usable in practice (e.g. bounding an infinite `lazyRange` with `take`).
+ * These are not general-purpose collection utilities - they exist to serve
+ * the pattern.
+ *
+ * @module eidos/iterator
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * import { lazyRange, map, filter, take, toArray } from "@pithos/core/eidos/iterator/iterator";
+ *
+ * const result = toArray(
+ *   take(5)(
+ *     filter((n: number) => n % 2 === 0)(
+ *       lazyRange(0, Infinity)
+ *     )
+ *   )
+ * );
+ * // [0, 2, 4, 6, 8]
+ * ```
+ */
+import type { Option } from "../../zygos/option.js";
+/**
+ * Creates a lazy, re-iterable sequence from a factory that produces a "next" function.
+ *
+ * The factory is called each time `[Symbol.iterator]()` is invoked, ensuring
+ * the iterable can be traversed multiple times. Each "next" call returns
+ * `Some(value)` for the next element or `None` to signal completion.
+ *
+ * This is the core of the GoF Iterator pattern: it decouples traversal logic
+ * (the `next` function) from the data source.
+ *
+ * @template T - The element type
+ * @param factory - A function that creates a stateful "next" supplier
+ * @returns A lazy Iterable
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * // Iterate over a tree in depth-first order
+ * const treeIter = createIterable(() => {
+ *   const stack = [rootNode];
+ *   return () => {
+ *     if (stack.length === 0) return none;
+ *     const node = stack.pop();
+ *     if (!node) return none;
+ *     stack.push(...node.children);
+ *     return some(node.value);
+ *   };
+ * });
+ *
+ * for (const value of treeIter) { ... }
+ * ```
+ */
+export declare function createIterable<T>(factory: () => () => Option<T>): Iterable<T>;
+/**
+ * Creates a lazy numeric range.
+ *
+ * Supports both ascending and descending ranges, as well as infinite ranges
+ * (use `take` to bound them).
+ *
+ * @param start - Start value (inclusive)
+ * @param end - End value (exclusive), defaults to Infinity
+ * @param step - Step increment, defaults to 1
+ * @returns A lazy Iterable of numbers
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * toArray(lazyRange(0, 5));       // [0, 1, 2, 3, 4]
+ * toArray(lazyRange(0, 10, 3));   // [0, 3, 6, 9]
+ * toArray(lazyRange(5, 0, -1));   // [5, 4, 3, 2, 1]
+ * ```
+ */
+export declare function lazyRange(start: number, end?: number, step?: number): Iterable<number>;
+/**
+ * Creates an infinite iterable by repeatedly applying a function to a seed.
+ *
+ * Produces: seed, f(seed), f(f(seed)), ...
+ *
+ * @template T - The element type
+ * @param seed - The initial value
+ * @param f - The function to apply repeatedly
+ * @returns An infinite lazy Iterable
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * // Powers of 2
+ * toArray(take(5)(iterate(1, (n) => n * 2))); // [1, 2, 4, 8, 16]
+ * ```
+ */
+export declare function iterate<T>(seed: T, f: (value: T) => T): Iterable<T>;
+/**
+ * Lazily transforms each element.
+ *
+ * @template A - Input element type
+ * @template B - Output element type
+ * @param f - The mapping function
+ * @returns A function that transforms an iterable
+ * @since 2.4.0
+ */
+export declare function map<A, B>(f: (a: A) => B): (source: Iterable<A>) => Iterable<B>;
+/**
+ * Lazily filters elements by a predicate.
+ *
+ * @template A - Element type
+ * @param predicate - The filter predicate
+ * @returns A function that filters an iterable
+ * @since 2.4.0
+ */
+export declare function filter<A>(predicate: (a: A) => boolean): (source: Iterable<A>) => Iterable<A>;
+/**
+ * Lazily takes the first n elements.
+ *
+ * Essential for bounding infinite iterables.
+ *
+ * @template A - Element type
+ * @param n - Number of elements to take
+ * @returns A function that limits an iterable
+ * @since 2.4.0
+ */
+export declare function take<A>(n: number): (source: Iterable<A>) => Iterable<A>;
+/**
+ * Collects all elements into an array.
+ *
+ * Do not use on infinite iterables without `take` first.
+ *
+ * @template A - Element type
+ * @param source - The iterable to collect
+ * @returns An array of all elements
+ * @since 2.4.0
+ */
+export declare function toArray<A>(source: Iterable<A>): A[];
+/**
+ * Reduces an iterable to a single value.
+ *
+ * @template A - Element type
+ * @template B - Accumulator type
+ * @param f - The reducer function
+ * @param seed - The initial accumulator
+ * @returns A function that reduces an iterable
+ * @since 2.4.0
+ */
+export declare function reduce<A, B>(f: (acc: B, a: A) => B, seed: B): (source: Iterable<A>) => B;
+//# sourceMappingURL=iterator.d.ts.map

package/dist/eidos/iterator/iterator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterator.d.ts","sourceRoot":"","sources":["../../../src/eidos/iterator/iterator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAM5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,MAAM,MAAM,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAa7E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,MAAM,EACb,GAAG,GAAE,MAAiB,EACtB,IAAI,GAAE,MAAU,GACf,QAAQ,CAAC,MAAM,CAAC,CAUlB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAanE;AAMD;;;;;;;;GAQG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAU9E;AAED;;;;;;;GAOG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAY5F;AAED;;;;;;;;;GASG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAavE;AAMD;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAEnD;AAED;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAQxF"}