@pithos/core 2.2.2 → 2.4.0

package/dist/eidos/strategy/strategy.js

@@ -0,0 +1,167 @@
+/**
+ * Functional Strategy Pattern.
+ *
+ * In OOP, the Strategy pattern requires an interface, concrete classes, and a
+ * context class to swap algorithms at runtime. In functional TypeScript, a
+ * strategy is simply a function - the pattern becomes composition.
+ *
+ * @module eidos/strategy
+ * @since 2.4.0
+ *
+ * @see {@link https://pithos.dev/api/eidos/strategy/ | Explanations, examples and live demo}
+ *
+ * @example
+ * ```ts
+ * import { type Strategy, createStrategies, safeStrategy } from "@pithos/core/eidos/strategy";
+ *
+ * const sorting = createStrategies({
+ *   asc: (data: number[]) => [...data].sort((a, b) => a - b),
+ *   desc: (data: number[]) => [...data].sort((a, b) => b - a),
+ * });
+ *
+ * sorting.execute("asc", [3, 1, 2]);  // [1, 2, 3]
+ * sorting.use("desc")([3, 1, 2]);     // [3, 2, 1]
+ * ```
+ */
+import { ok, err } from "../../zygos/result/result.js";
+import { some, none } from "../../zygos/option.js";
+import { ensure } from "../../bridges/ensure.js";
+/**
+ * Creates a strategy resolver from a record of named strategies.
+ * Replaces the GoF Context class - instead of `setStrategy()` + `execute()`,
+ * you simply pick a function by key and call it.
+ *
+ * @template K - Union of strategy keys
+ * @template In - The input type
+ * @template Out - The output type
+ * @param strategies - Record mapping keys to strategy functions
+ * @returns Resolver with `use` (get fn) and `execute` (run by key)
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * const pricing = createStrategies({
+ *   regular: (price: number) => price,
+ *   vip: (price: number) => price * 0.8,
+ *   premium: (price: number) => price * 0.7,
+ * });
+ *
+ * const applyVip = pricing.use("vip");
+ * applyVip(100); // 80
+ *
+ * pricing.execute("premium", 100); // 70
+ *
+ * // Safe lookup for dynamic keys (e.g. from config)
+ * const key: string = getFromConfig();
+ * pricing.get(key); // Option<Strategy<number, number>>
+ * ```
+ */
+export function createStrategies(strategies) {
+    return {
+        /** Get a strategy by key. Typed keys only. */
+        use: (key) => strategies[key],
+        /** Execute a strategy by key with the given input. */
+        execute: (key, input) => strategies[key](input),
+        /** Safe lookup for dynamic/runtime keys. Returns `Option<Strategy>`. */
+        get: (key) => {
+            if (key in strategies) {
+                // INTENTIONAL: key validated by `in` check, TS can't narrow string to K
+                return some(strategies[key]);
+            }
+            return none;
+        },
+    };
+}
+/**
+ * Wraps a strategy to return a zygos `Result` instead of throwing.
+ * Catches any exception and wraps it in `Err<Error>`.
+ *
+ * @deprecated Use `Result.fromThrowable` from `@zygos/result/result` instead.
+ *
+ * ```ts
+ * import { Result } from "../../zygos/result/result.js";
+ *
+ * const safeParseJson = Result.fromThrowable(
+ *   (input: string) => JSON.parse(input),
+ *   (e) => e instanceof Error ? e : new Error(String(e)),
+ * );
+ * safeParseJson('{"ok":true}'); // Ok({ ok: true })
+ * safeParseJson("invalid");     // Err(SyntaxError(...))
+ * ```
+ *
+ * @see {@link https://pithos.dev/api/eidos/strategy/ | Full explanation, examples and live demo}
+ * @template In - The input type
+ * @template Out - The output type
+ * @param strategy - The strategy to make safe
+ * @returns A new strategy returning `Result<Out, Error>`
+ * @since 2.4.0
+ */
+export function safeStrategy(strategy) {
+    return (input) => {
+        try {
+            return ok(strategy(input));
+        }
+        catch (error) {
+            return err(error instanceof Error ? error : new Error(String(error)));
+        }
+    };
+}
+/**
+ * Composes a primary strategy with a fallback.
+ * If the primary throws, the fallback is executed instead.
+ *
+ * @template In - The input type
+ * @template Out - The output type
+ * @param primary - The strategy to try first
+ * @param fallback - The strategy to use if primary throws
+ * @returns A new combined strategy
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * const fromCache: Strategy<string, Data> = (key) => cache.get(key);
+ * const fromApi: Strategy<string, Data> = (key) => api.fetch(key);
+ *
+ * const fetchData = withFallback(fromCache, fromApi);
+ * fetchData("user:123"); // tries cache, falls back to API
+ * ```
+ */
+export function withFallback(primary, fallback) {
+    return (input) => {
+        try {
+            return primary(input);
+        }
+        catch {
+            return fallback(input);
+        }
+    };
+}
+/**
+ * Validates input against a kanon schema before executing the strategy.
+ * Bridges kanon validation, zygos Result, and the strategy pattern.
+ *
+ * @template S - The kanon schema type
+ * @template Out - The output type of the strategy
+ * @param schema - Kanon schema to validate input against
+ * @param strategy - Strategy to execute on validated input
+ * @returns A function accepting unknown input and returning `Result<Out, string>`
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * import { number } from "@pithos/core/kanon";
+ *
+ * const double = withValidation(
+ *   number().min(0),
+ *   (n) => n * 2,
+ * );
+ *
+ * double(5);       // Ok(10)
+ * double(-1);      // Err("Number must be >= 0")
+ * double("hello"); // Err("Expected number")
+ * ```
+ */
+export function withValidation(schema, strategy) {
+    return (input) => ensure(schema, input).map(strategy);
+}
+//# sourceMappingURL=strategy.js.map

package/dist/eidos/strategy/strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy.js","sourceRoot":"","sources":["../../../src/eidos/strategy/strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,MAAM,sBAAsB,CAAC;AAC/C,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAezC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,UAAU,gBAAgB,CAC9B,UAAwC;IAExC,OAAO;QACL,8CAA8C;QAC9C,GAAG,EAAE,CAAC,GAAM,EAAqB,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC;QACnD,sDAAsD;QACtD,OAAO,EAAE,CAAC,GAAM,EAAE,KAAS,EAAO,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC;QAC3D,wEAAwE;QACxE,GAAG,EAAE,CAAC,GAAW,EAA6B,EAAE;YAC9C,IAAI,GAAG,IAAI,UAAU,EAAE,CAAC;gBACtB,wEAAwE;gBACxE,OAAO,IAAI,CAAC,UAAU,CAAC,GAAQ,CAAC,CAAC,CAAC;YACpC,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,YAAY,CAC1B,QAA2B;IAE3B,OAAO,CAAC,KAAS,EAAE,EAAE;QACnB,IAAI,CAAC;YACH,OAAO,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;QAC7B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,GAAG,CAAC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACxE,CAAC;IACH,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,YAAY,CAC1B,OAA0B,EAC1B,QAA2B;IAE3B,OAAO,CAAC,KAAS,EAAO,EAAE;QACxB,IAAI,CAAC;YACH,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC;QACxB,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC;QACzB,CAAC;IACH,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,cAAc,CAC5B,MAAS,EACT,QAAiC;IAEjC,OAAO,CAAC,KAAc,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;AACjE,CAAC"}

package/dist/eidos/template/template.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Functional Template Method Pattern.
+ *
+ * In OOP, the Template Method pattern requires an abstract class that defines
+ * the algorithm skeleton with abstract/hook methods, and concrete subclasses
+ * that override specific steps.
+ *
+ * In functional TypeScript, a template is just `(steps) => algorithm`.
+ * The base pattern is absorbed by the language — no wrapper needed.
+ *
+ * However, {@link templateWithDefaults} provides real value: it handles
+ * merging default step implementations with caller overrides.
+ *
+ * @module eidos/template
+ * @since 2.4.0
+ *
+ * @see {@link https://pithos.dev/api/eidos/template/ | Explanations, examples and live demo}
+ *
+ * @example
+ * ```ts
+ * // No import needed for basic templates — just write a function:
+ * const processData = (steps: { parse: (raw: string) => number[]; analyze: (data: number[]) => string }) =>
+ *   (raw: string) => steps.analyze(steps.parse(raw));
+ *
+ * const csvProcessor = processData({
+ *   parse: (raw) => raw.split(",").map(Number),
+ *   analyze: (data) => `sum: ${data.reduce((a, b) => a + b, 0)}`,
+ * });
+ *
+ * // For templates with defaults, use templateWithDefaults:
+ * import { templateWithDefaults } from "@pithos/core/eidos/template/template";
+ *
+ * const report = templateWithDefaults(
+ *   (steps: { header: () => string; body: (d: string) => string }) =>
+ *     (data: string) => `${steps.header()}\n${steps.body(data)}`,
+ *   { header: () => "=== Report ===", body: (d) => d },
+ * );
+ *
+ * report({ header: () => "Custom" })("content");
+ * ```
+ *
+ * @deprecated **Pattern absorbed by the language.**
+ *
+ * In functional TypeScript, a template is just `(steps) => algorithm`.
+ * This function is the identity — it exists only so you find this message.
+ *
+ * Write your template directly:
+ * ```ts
+ * const gameAI = (steps: { collect: () => number; attack: (n: number) => string }) =>
+ *   () => steps.attack(steps.collect());
+ * ```
+ *
+ * For templates with default steps, use {@link templateWithDefaults} which
+ * provides actual value (merging defaults with overrides).
+ *
+ * @see {@link https://pithos.dev/api/eidos/template/ | Full explanation, examples and live demo}
+ */
+export declare function template<Steps extends Record<string, (...args: any[]) => unknown>, Fn>(skeleton: (steps: Steps) => Fn): (steps: Steps) => Fn;
+/**
+ * Creates a template method with default steps that can be partially overridden.
+ *
+ * This is the functional equivalent of an abstract class with hook methods
+ * that have default implementations. Only the steps you want to customize
+ * need to be provided.
+ *
+ * @template Steps - The record type describing the customizable steps
+ * @template Fn - The resulting algorithm function type
+ * @param skeleton - A function that wires the steps into an algorithm
+ * @param defaults - Default implementations for all steps
+ * @returns A function that accepts partial step overrides and returns the algorithm
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * const report = templateWithDefaults(
+ *   (steps: {
+ *     header: () => string;
+ *     body: (data: string) => string;
+ *     footer: () => string;
+ *   }) =>
+ *     (data: string) => [steps.header(), steps.body(data), steps.footer()].join("\n"),
+ *   {
+ *     header: () => "=== Report ===",
+ *     body: (data) => data,
+ *     footer: () => "=== End ===",
+ *   },
+ * );
+ *
+ * // Only override what you need
+ * const custom = report({ header: () => "** Custom **" });
+ * custom("content"); // "** Custom **\ncontent\n=== End ==="
+ * ```
+ */
+export declare function templateWithDefaults<Steps extends object, Fn>(skeleton: (steps: Steps) => Fn, defaults: NoInfer<Steps>): (overrides?: Partial<NoInfer<Steps>>) => Fn;
+//# sourceMappingURL=template.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../../src/eidos/template/template.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,wBAAgB,QAAQ,CAGtB,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,EACzD,EAAE,EAEF,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,EAAE,GAC7B,CAAC,KAAK,EAAE,KAAK,KAAK,EAAE,CAEtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,SAAS,MAAM,EAAE,EAAE,EAC3D,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,EAAE,EAC9B,QAAQ,EAAE,OAAO,CAAC,KAAK,CAAC,GACvB,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,CAY7C"}

package/dist/eidos/template/template.js

@@ -0,0 +1,110 @@
+/**
+ * Functional Template Method Pattern.
+ *
+ * In OOP, the Template Method pattern requires an abstract class that defines
+ * the algorithm skeleton with abstract/hook methods, and concrete subclasses
+ * that override specific steps.
+ *
+ * In functional TypeScript, a template is just `(steps) => algorithm`.
+ * The base pattern is absorbed by the language — no wrapper needed.
+ *
+ * However, {@link templateWithDefaults} provides real value: it handles
+ * merging default step implementations with caller overrides.
+ *
+ * @module eidos/template
+ * @since 2.4.0
+ *
+ * @see {@link https://pithos.dev/api/eidos/template/ | Explanations, examples and live demo}
+ *
+ * @example
+ * ```ts
+ * // No import needed for basic templates — just write a function:
+ * const processData = (steps: { parse: (raw: string) => number[]; analyze: (data: number[]) => string }) =>
+ *   (raw: string) => steps.analyze(steps.parse(raw));
+ *
+ * const csvProcessor = processData({
+ *   parse: (raw) => raw.split(",").map(Number),
+ *   analyze: (data) => `sum: ${data.reduce((a, b) => a + b, 0)}`,
+ * });
+ *
+ * // For templates with defaults, use templateWithDefaults:
+ * import { templateWithDefaults } from "@pithos/core/eidos/template/template";
+ *
+ * const report = templateWithDefaults(
+ *   (steps: { header: () => string; body: (d: string) => string }) =>
+ *     (data: string) => `${steps.header()}\n${steps.body(data)}`,
+ *   { header: () => "=== Report ===", body: (d) => d },
+ * );
+ *
+ * report({ header: () => "Custom" })("content");
+ * ```
+ *
+ * @deprecated **Pattern absorbed by the language.**
+ *
+ * In functional TypeScript, a template is just `(steps) => algorithm`.
+ * This function is the identity — it exists only so you find this message.
+ *
+ * Write your template directly:
+ * ```ts
+ * const gameAI = (steps: { collect: () => number; attack: (n: number) => string }) =>
+ *   () => steps.attack(steps.collect());
+ * ```
+ *
+ * For templates with default steps, use {@link templateWithDefaults} which
+ * provides actual value (merging defaults with overrides).
+ *
+ * @see {@link https://pithos.dev/api/eidos/template/ | Full explanation, examples and live demo}
+ */
+export function template(skeleton) {
+    return skeleton;
+}
+/**
+ * Creates a template method with default steps that can be partially overridden.
+ *
+ * This is the functional equivalent of an abstract class with hook methods
+ * that have default implementations. Only the steps you want to customize
+ * need to be provided.
+ *
+ * @template Steps - The record type describing the customizable steps
+ * @template Fn - The resulting algorithm function type
+ * @param skeleton - A function that wires the steps into an algorithm
+ * @param defaults - Default implementations for all steps
+ * @returns A function that accepts partial step overrides and returns the algorithm
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * const report = templateWithDefaults(
+ *   (steps: {
+ *     header: () => string;
+ *     body: (data: string) => string;
+ *     footer: () => string;
+ *   }) =>
+ *     (data: string) => [steps.header(), steps.body(data), steps.footer()].join("\n"),
+ *   {
+ *     header: () => "=== Report ===",
+ *     body: (data) => data,
+ *     footer: () => "=== End ===",
+ *   },
+ * );
+ *
+ * // Only override what you need
+ * const custom = report({ header: () => "** Custom **" });
+ * custom("content"); // "** Custom **\ncontent\n=== End ==="
+ * ```
+ */
+export function templateWithDefaults(skeleton, defaults) {
+    return (overrides) => {
+        // Stryker disable next-line ConditionalExpression: Stryker can't find related tests due to vitest.related config
+        if (!overrides)
+            return skeleton(defaults);
+        const merged = { ...defaults };
+        for (const key of Object.keys(overrides)) {
+            if (overrides[key] !== undefined) {
+                merged[key] = overrides[key];
+            }
+        }
+        return skeleton(merged);
+    };
+}
+//# sourceMappingURL=template.js.map

package/dist/eidos/template/template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.js","sourceRoot":"","sources":["../../../src/eidos/template/template.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,MAAM,UAAU,QAAQ,CAMtB,QAA8B;IAE9B,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,UAAU,oBAAoB,CAClC,QAA8B,EAC9B,QAAwB;IAExB,OAAO,CAAC,SAAS,EAAE,EAAE;QACnB,iHAAiH;QACjH,IAAI,CAAC,SAAS;YAAE,OAAO,QAAQ,CAAC,QAAQ,CAAC,CAAC;QAC1C,MAAM,MAAM,GAAG,EAAE,GAAG,QAAQ,EAAE,CAAC;QAC/B,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAoB,EAAE,CAAC;YAC5D,IAAI,SAAS,CAAC,GAAG,CAAC,KAAK,SAAS,EAAE,CAAC;gBACjC,MAAM,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,GAAG,CAAuB,CAAC;YACrD,CAAC;QACH,CAAC;QACD,OAAO,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC1B,CAAC,CAAC;AACJ,CAAC"}

package/dist/eidos/visitor/visitor.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Functional Visitor Pattern.
+ *
+ * In OOP, the Visitor pattern requires a Component interface with `accept()`,
+ * concrete components that call `visitor.visitX(this)`, and Visitor interfaces
+ * with a method per component type. This "double dispatch" works around the
+ * limitation that OOP languages dispatch only on the receiver type.
+ *
+ * In functional TypeScript, this is absorbed by discriminated unions + switch:
+ * - Define your types as a union with a discriminant (`type`, `kind`, `_tag`)
+ * - Use `switch` on the discriminant — TypeScript narrows the type in each case
+ * - Exhaustiveness is checked at compile time
+ *
+ * No wrapper needed — it's native language behavior.
+ *
+ * @module eidos/visitor
+ * @since 2.4.0
+ *
+ * @see {@link https://pithos.dev/api/eidos/visitor/ | Explanations, examples and live demo}
+ *
+ * @example
+ * ```ts
+ * // No import needed — just use discriminated unions + switch:
+ *
+ * type Shape =
+ *   | { type: "circle"; radius: number }
+ *   | { type: "rectangle"; width: number; height: number }
+ *   | { type: "triangle"; base: number; height: number };
+ *
+ * // "Visitor 1" - calculate area
+ * const area = (shape: Shape): number => {
+ *   switch (shape.type) {
+ *     case "circle": return Math.PI * shape.radius ** 2;
+ *     case "rectangle": return shape.width * shape.height;
+ *     case "triangle": return (shape.base * shape.height) / 2;
+ *   }
+ * };
+ *
+ * // "Visitor 2" - describe shape
+ * const describe = (shape: Shape): string => {
+ *   switch (shape.type) {
+ *     case "circle": return `Circle with radius ${shape.radius}`;
+ *     case "rectangle": return `Rectangle ${shape.width}x${shape.height}`;
+ *     case "triangle": return `Triangle base=${shape.base}`;
+ *   }
+ * };
+ *
+ * // Same data, different "visitors" (functions)
+ * const shapes: Shape[] = [
+ *   { type: "circle", radius: 5 },
+ *   { type: "rectangle", width: 3, height: 4 },
+ * ];
+ *
+ * shapes.map(area);     // [78.54, 12]
+ * shapes.map(describe); // ["Circle with radius 5", "Rectangle 3x4"]
+ * ```
+ *
+ * @deprecated **Pattern absorbed by the language.**
+ *
+ * In functional TypeScript, the Visitor pattern is just a switch on a
+ * discriminated union. TypeScript narrows the type in each case branch.
+ *
+ * Write your visitor directly:
+ * ```ts
+ * const visit = (shape: Shape): number => {
+ *   switch (shape.type) {
+ *     case "circle": return Math.PI * shape.radius ** 2;
+ *     case "rectangle": return shape.width * shape.height;
+ *   }
+ * };
+ * ```
+ *
+ * This function is the identity — it exists only so you find this message.
+ *
+ * @see {@link https://pithos.dev/api/eidos/visitor/ | Full explanation, examples and live demo}
+ */
+export declare function visit<T, R>(value: T, visitor: (v: T) => R): R;
+//# sourceMappingURL=visitor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"visitor.d.ts","sourceRoot":"","sources":["../../../src/eidos/visitor/visitor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAE7D"}

package/dist/eidos/visitor/visitor.js

@@ -0,0 +1,80 @@
+/**
+ * Functional Visitor Pattern.
+ *
+ * In OOP, the Visitor pattern requires a Component interface with `accept()`,
+ * concrete components that call `visitor.visitX(this)`, and Visitor interfaces
+ * with a method per component type. This "double dispatch" works around the
+ * limitation that OOP languages dispatch only on the receiver type.
+ *
+ * In functional TypeScript, this is absorbed by discriminated unions + switch:
+ * - Define your types as a union with a discriminant (`type`, `kind`, `_tag`)
+ * - Use `switch` on the discriminant — TypeScript narrows the type in each case
+ * - Exhaustiveness is checked at compile time
+ *
+ * No wrapper needed — it's native language behavior.
+ *
+ * @module eidos/visitor
+ * @since 2.4.0
+ *
+ * @see {@link https://pithos.dev/api/eidos/visitor/ | Explanations, examples and live demo}
+ *
+ * @example
+ * ```ts
+ * // No import needed — just use discriminated unions + switch:
+ *
+ * type Shape =
+ *   | { type: "circle"; radius: number }
+ *   | { type: "rectangle"; width: number; height: number }
+ *   | { type: "triangle"; base: number; height: number };
+ *
+ * // "Visitor 1" - calculate area
+ * const area = (shape: Shape): number => {
+ *   switch (shape.type) {
+ *     case "circle": return Math.PI * shape.radius ** 2;
+ *     case "rectangle": return shape.width * shape.height;
+ *     case "triangle": return (shape.base * shape.height) / 2;
+ *   }
+ * };
+ *
+ * // "Visitor 2" - describe shape
+ * const describe = (shape: Shape): string => {
+ *   switch (shape.type) {
+ *     case "circle": return `Circle with radius ${shape.radius}`;
+ *     case "rectangle": return `Rectangle ${shape.width}x${shape.height}`;
+ *     case "triangle": return `Triangle base=${shape.base}`;
+ *   }
+ * };
+ *
+ * // Same data, different "visitors" (functions)
+ * const shapes: Shape[] = [
+ *   { type: "circle", radius: 5 },
+ *   { type: "rectangle", width: 3, height: 4 },
+ * ];
+ *
+ * shapes.map(area);     // [78.54, 12]
+ * shapes.map(describe); // ["Circle with radius 5", "Rectangle 3x4"]
+ * ```
+ *
+ * @deprecated **Pattern absorbed by the language.**
+ *
+ * In functional TypeScript, the Visitor pattern is just a switch on a
+ * discriminated union. TypeScript narrows the type in each case branch.
+ *
+ * Write your visitor directly:
+ * ```ts
+ * const visit = (shape: Shape): number => {
+ *   switch (shape.type) {
+ *     case "circle": return Math.PI * shape.radius ** 2;
+ *     case "rectangle": return shape.width * shape.height;
+ *   }
+ * };
+ * ```
+ *
+ * This function is the identity — it exists only so you find this message.
+ *
+ * @see {@link https://pithos.dev/api/eidos/visitor/ | Full explanation, examples and live demo}
+ */
+export function visit(value, visitor) {
+    return visitor(value);
+}
+//# sourceMappingURL=visitor.js.map

package/dist/eidos/visitor/visitor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"visitor.js","sourceRoot":"","sources":["../../../src/eidos/visitor/visitor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AACH,MAAM,UAAU,KAAK,CAAO,KAAQ,EAAE,OAAoB;IACxD,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC;AACxB,CAAC"}

package/dist/zygos/result/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Barrel re-export for Result.
+ *
+ * Provides a single import point for all Result-related exports.
+ *
+ * @example
+ * ```typescript
+ * import { Result, ok, err, Ok, Err, ResultAsync } from '@pithos/core/zygos/result';
+ *
+ * const r: Result<number, string> = ok(42);
+ * const safe = Result.fromThrowable(JSON.parse);
+ * const combined = Result.combine([ok(1), ok(2)]);
+ * ```
+ *
+ * @since 2.4.0
+ */
+export { Result, Ok, Err, ok, err, safeTry, safeAsyncTry, fromOption, fromEither, toEither, } from "./result.js";
+export { ResultAsync, okAsync, errAsync, } from "./result-async.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/zygos/result/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/zygos/result/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAEL,MAAM,EAGN,EAAE,EACF,GAAG,EAGH,EAAE,EACF,GAAG,EAGH,OAAO,EACP,YAAY,EAGZ,UAAU,EACV,UAAU,EACV,QAAQ,GACT,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,WAAW,EACX,OAAO,EACP,QAAQ,GACT,MAAM,mBAAmB,CAAC"}

package/dist/zygos/result/index.js

@@ -0,0 +1,29 @@
+/**
+ * Barrel re-export for Result.
+ *
+ * Provides a single import point for all Result-related exports.
+ *
+ * @example
+ * ```typescript
+ * import { Result, ok, err, Ok, Err, ResultAsync } from '@pithos/core/zygos/result';
+ *
+ * const r: Result<number, string> = ok(42);
+ * const safe = Result.fromThrowable(JSON.parse);
+ * const combined = Result.combine([ok(1), ok(2)]);
+ * ```
+ *
+ * @since 2.4.0
+ */
+export { 
+// Type + Namespace (declaration merging: works as both)
+Result, 
+// Classes
+Ok, Err, 
+// Constructors
+ok, err, 
+// Utilities
+safeTry, safeAsyncTry, 
+// Conversions
+fromOption, fromEither, toEither, } from "./result.js";
+export { ResultAsync, okAsync, errAsync, } from "./result-async.js";
+//# sourceMappingURL=index.js.map

package/dist/zygos/result/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/zygos/result/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO;AACL,wDAAwD;AACxD,MAAM;AAEN,UAAU;AACV,EAAE,EACF,GAAG;AAEH,eAAe;AACf,EAAE,EACF,GAAG;AAEH,YAAY;AACZ,OAAO,EACP,YAAY;AAEZ,cAAc;AACd,UAAU,EACV,UAAU,EACV,QAAQ,GACT,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,WAAW,EACX,OAAO,EACP,QAAQ,GACT,MAAM,mBAAmB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pithos/core",
-  "version": "2.2.2",
+  "version": "2.4.0",
   "description": "Advanced JavaScript/TypeScript superset providing utilities, validation, and functional patterns",
   "type": "module",
   "publishConfig": {
@@ -27,6 +27,29 @@
     "./arkhe/types/utilities/*": "./dist/arkhe/types/utilities/*.js",
     "./arkhe/util/*": "./dist/arkhe/util/*.js",
     "./bridges/*": "./dist/bridges/*.js",
+    "./eidos/abstract-factory/*": "./dist/eidos/abstract-factory/*.js",
+    "./eidos/adapter/*": "./dist/eidos/adapter/*.js",
+    "./eidos/bridge/*": "./dist/eidos/bridge/*.js",
+    "./eidos/builder/*": "./dist/eidos/builder/*.js",
+    "./eidos/chain/*": "./dist/eidos/chain/*.js",
+    "./eidos/command/*": "./dist/eidos/command/*.js",
+    "./eidos/composite/*": "./dist/eidos/composite/*.js",
+    "./eidos/decorator/*": "./dist/eidos/decorator/*.js",
+    "./eidos/facade/*": "./dist/eidos/facade/*.js",
+    "./eidos/factory-method/*": "./dist/eidos/factory-method/*.js",
+    "./eidos/flyweight/*": "./dist/eidos/flyweight/*.js",
+    "./eidos/interpreter/*": "./dist/eidos/interpreter/*.js",
+    "./eidos/iterator/*": "./dist/eidos/iterator/*.js",
+    "./eidos/mediator/*": "./dist/eidos/mediator/*.js",
+    "./eidos/memento/*": "./dist/eidos/memento/*.js",
+    "./eidos/observer/*": "./dist/eidos/observer/*.js",
+    "./eidos/prototype/*": "./dist/eidos/prototype/*.js",
+    "./eidos/proxy/*": "./dist/eidos/proxy/*.js",
+    "./eidos/singleton/*": "./dist/eidos/singleton/*.js",
+    "./eidos/state/*": "./dist/eidos/state/*.js",
+    "./eidos/strategy/*": "./dist/eidos/strategy/*.js",
+    "./eidos/template/*": "./dist/eidos/template/*.js",
+    "./eidos/visitor/*": "./dist/eidos/visitor/*.js",
     "./kanon/core/consts/*": "./dist/kanon/core/consts/*.js",
     "./kanon/core/*": "./dist/kanon/core/*.js",
     "./kanon/helpers/*": "./dist/kanon/helpers/*.js",
@@ -60,7 +83,8 @@
     "./taphos/string/*": "./dist/taphos/string/*.js",
     "./taphos/util/*": "./dist/taphos/util/*.js",
     "./zygos/*": "./dist/zygos/*.js",
-    "./zygos/result/*": "./dist/zygos/result/*.js"
+    "./zygos/result/*": "./dist/zygos/result/*.js",
+    "./zygos/result": "./dist/zygos/result/index.js"
   },
   "files": [
     "dist",
@@ -77,7 +101,8 @@
     "lodash-alternative",
     "zod-alternative",
     "neverthrow-alternative",
-    "fp-ts-alternative"
+    "fp-ts-alternative",
+    "effect-alternative"
   ],
   "author": "Pierre Moati <mopi1402>",
   "license": "MIT",