@nlozgachev/pipelined 0.12.0 → 0.13.0

package/types/src/Composition/uncurry.d.ts

@@ -1,54 +0,0 @@
-/**
- * Converts a curried function into a multi-argument function.
- * Useful when you want to call a curried function with all arguments at once.
- *
- * Handles functions with 0, 1, or 2 curried arguments.
- *
- * @example
- * ```ts
- * // Thunks: () => () => C becomes () => C
- * const nested = () => () => 42;
- * uncurry(nested)(); // 42
- *
- * // Original curried function
- * Option.map(n => n * 2)(Option.some(5)); // Some(10)
- *
- * // Uncurried - all arguments at once
- * const mapUncurried = uncurry(Option.map);
- * mapUncurried(n => n * 2, Option.some(5)); // Some(10)
- *
- * // Combined with flip for data-first uncurried
- * const mapDataFirst = uncurry(flip(Option.map));
- * mapDataFirst(Option.some(5), n => n * 2); // Some(10)
- * ```
- *
- * @see {@link flip} for reversing curried argument order
- * @see {@link uncurry3} for 3-argument curried functions
- * @see {@link uncurry4} for 4-argument curried functions
- */
-export declare function uncurry<C>(f: () => () => C): () => C;
-export declare function uncurry<A, C>(f: (a: A) => () => C): (a: A) => C;
-export declare function uncurry<A, B, C>(f: (a: A) => (b: B) => C): (a: A, b: B) => C;
-/**
- * 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 declare const uncurry3: <A, B, C, D>(f: (a: A) => (b: B) => (c: C) => D) => (a: A, b: B, c: C) => D;
-/**
- * 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 declare const uncurry4: <A, B, C, D, E>(f: (a: A) => (b: B) => (c: C) => (d: D) => E) => (a: A, b: B, c: C, d: D) => E;
-//# sourceMappingURL=uncurry.d.ts.map

package/types/src/Composition/uncurry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"uncurry.d.ts","sourceRoot":"","sources":["../../../src/src/Composition/uncurry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC;AACtD,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;AACjE,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;AAY9E;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,KAAG,CAAe,CAAC;AAEhH;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,KAAG,CACrG,CAAC"}

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

@@ -1,49 +0,0 @@
-declare const _deferred: unique symbol;
-/**
- * A nominally typed, one-shot async value that supports `await` but enforces infallibility.
- *
- * Two design choices work together to make the guarantee structural rather than documentary:
- *
- * - The phantom `[_deferred]` symbol makes the type **nominal**: only values produced by
- *   `Deferred.fromPromise` satisfy it. A plain object `{ then: ... }` does not.
- * - The single-parameter `.then()` **excludes rejection handlers** by construction. There is
- *   no second argument to pass, so chaining and `.catch()` are impossible.
- *
- * This makes `Deferred<A>` the natural return type for `Task<A>`, which is guaranteed to
- * never reject.
- *
- * @example
- * ```ts
- * const value = await Deferred.fromPromise(Promise.resolve(42));
- * // value === 42
- * ```
- */
-export type Deferred<A> = {
-    readonly [_deferred]: A;
-    readonly then: (onfulfilled: (value: A) => void) => void;
-};
-export declare namespace 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"
-     * ```
-     */
-    const fromPromise: <A>(p: Promise<A>) => Deferred<A>;
-    /**
-     * Converts a `Deferred` back into a `Promise`.
-     *
-     * @example
-     * ```ts
-     * const p = Deferred.toPromise(Deferred.fromPromise(Promise.resolve(42)));
-     * // p is Promise<42>
-     * ```
-     */
-    const toPromise: <A>(d: Deferred<A>) => Promise<A>;
-}
-export {};
-//# sourceMappingURL=Deferred.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Deferred.d.ts","sourceRoot":"","sources":["../../../src/src/Core/Deferred.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,SAAS,EAAE,OAAO,MAAM,CAAC;AAIvC;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI;IACzB,QAAQ,CAAC,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,KAAK,IAAI,CAAC;CACzD,CAAC;AAEF,yBAAiB,QAAQ,CAAC;IACzB;;;;;;;;;OASG;IACI,MAAM,WAAW,GAAI,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,KAAG,QAAQ,CAAC,CAAC,CAIxD,CAAC;IAEF;;;;;;;;OAQG;IACI,MAAM,SAAS,GAAI,CAAC,EAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,KAAG,OAAO,CAAC,CAAC,CAEZ,CAAC;CAC5C"}

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

@@ -1,23 +0,0 @@
-import { NonEmptyList } from "../Types/NonEmptyList.js";
-export type WithKind<K extends string> = {
-    readonly kind: K;
-};
-export type WithValue<T> = {
-    readonly value: T;
-};
-export type WithError<T> = {
-    readonly error: T;
-};
-export type WithErrors<T> = {
-    readonly errors: NonEmptyList<T>;
-};
-export type WithFirst<T> = {
-    readonly first: T;
-};
-export type WithSecond<T> = {
-    readonly second: T;
-};
-export type WithLog<T> = {
-    readonly log: ReadonlyArray<T>;
-};
-//# sourceMappingURL=InternalTypes.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"InternalTypes.d.ts","sourceRoot":"","sources":["../../../src/src/Core/InternalTypes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAExD,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,MAAM,IAAI;IAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;CAAE,CAAC;AAE9D,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI;IAAE,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAA;CAAE,CAAC;AAEjD,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI;IAAE,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAA;CAAE,CAAC;AAEjD,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IAAE,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,CAAA;CAAE,CAAC;AAEjE,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI;IAAE,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAA;CAAE,CAAC;AAEjD,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IAAE,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAA;CAAE,CAAC;AAEnD,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI;IAAE,QAAQ,CAAC,GAAG,EAAE,aAAa,CAAC,CAAC,CAAC,CAAA;CAAE,CAAC"}

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

@@ -1,118 +0,0 @@
-import type { Optional } from "./Optional.js";
-/**
- * Lens<S, A> focuses on a single value A inside a structure S, providing
- * a composable way to read and immutably update nested data.
- *
- * A Lens always succeeds: the focused value is guaranteed to exist.
- * For optional or indexed focuses, use Optional<S, A>.
- *
- * @example
- * ```ts
- * type Address = { city: string; zip: string };
- * type User = { name: string; address: Address };
- *
- * const addressLens = Lens.prop<User>()("address");
- * const cityLens    = Lens.prop<Address>()("city");
- * const userCityLens = pipe(addressLens, Lens.andThen(cityLens));
- *
- * pipe(user, Lens.get(userCityLens));             // "Berlin"
- * pipe(user, Lens.set(userCityLens)("Hamburg"));  // new User with city updated
- * pipe(user, Lens.modify(userCityLens)(c => c.toUpperCase())); // "BERLIN"
- * ```
- */
-export type Lens<S, A> = {
-    readonly get: (s: S) => A;
-    readonly set: (a: A) => (s: S) => S;
-};
-export declare namespace Lens {
-    /**
-     * Constructs a Lens from a getter and a setter.
-     *
-     * @example
-     * ```ts
-     * const nameLens = Lens.make(
-     *   (user: User) => user.name,
-     *   (name) => (user) => ({ ...user, name }),
-     * );
-     * ```
-     */
-    const make: <S, A>(get: (s: S) => A, set: (a: A) => (s: S) => S) => Lens<S, A>;
-    /**
-     * 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");
-     * ```
-     */
-    const prop: <S>() => <K extends keyof S>(key: K) => Lens<S, S[K]>;
-    /**
-     * Reads the focused value from a structure.
-     *
-     * @example
-     * ```ts
-     * pipe(user, Lens.get(nameLens)); // "Alice"
-     * ```
-     */
-    const get: <S, A>(lens: Lens<S, A>) => (s: S) => A;
-    /**
-     * Replaces the focused value within a structure, returning a new structure.
-     *
-     * @example
-     * ```ts
-     * pipe(user, Lens.set(nameLens)("Bob")); // new User with name "Bob"
-     * ```
-     */
-    const set: <S, A>(lens: Lens<S, A>) => (a: A) => (s: S) => S;
-    /**
-     * Applies a function to the focused value, returning a new structure.
-     *
-     * @example
-     * ```ts
-     * pipe(user, Lens.modify(nameLens)(n => n.toUpperCase())); // "ALICE"
-     * ```
-     */
-    const modify: <S, A>(lens: Lens<S, A>) => (f: (a: A) => A) => (s: 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")),
-     * );
-     * ```
-     */
-    const andThen: <A, B>(inner: Lens<A, B>) => <S>(outer: Lens<S, A>) => Lens<S, B>;
-    /**
-     * 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")),
-     * );
-     * ```
-     */
-    const andThenOptional: <A, B>(inner: Optional<A, B>) => <S>(outer: Lens<S, A>) => Optional<S, B>;
-    /**
-     * 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")),
-     * );
-     * ```
-     */
-    const toOptional: <S, A>(lens: Lens<S, A>) => Optional<S, A>;
-}
-//# sourceMappingURL=Lens.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Lens.d.ts","sourceRoot":"","sources":["../../../src/src/Core/Lens.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,EAAE,CAAC,IAAI;IACxB,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;CACpC,CAAC;AAEF,yBAAiB,IAAI,CAAC;IACrB;;;;;;;;;;OAUG;IACI,MAAM,IAAI,GAAI,CAAC,EAAE,CAAC,EACxB,KAAK,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EAChB,KAAK,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KACxB,IAAI,CAAC,CAAC,EAAE,CAAC,CAAmB,CAAC;IAEhC;;;;;;;;OAQG;IACI,MAAM,IAAI,GAAI,CAAC,QAAQ,CAAC,SAAS,MAAM,CAAC,EAAE,KAAK,CAAC,KAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAIpE,CAAC;IAEH;;;;;;;OAOG;IACI,MAAM,GAAG,GAAI,CAAC,EAAE,CAAC,EAAE,MAAM,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC,KAAG,CAAgB,CAAC;IAExE;;;;;;;OAOG;IACI,MAAM,GAAG,GAAI,CAAC,EAAE,CAAC,EAAE,MAAM,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC,MAAM,GAAG,CAAC,KAAG,CAAmB,CAAC;IAErF;;;;;;;OAOG;IACI,MAAM,MAAM,GAAI,CAAC,EAAE,CAAC,EAAE,MAAM,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,KAAG,CAAgC,CAAC;IAE/G;;;;;;;;;;;OAWG;IACI,MAAM,OAAO,GAAI,CAAC,EAAE,CAAC,EAAE,OAAO,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAInF,CAAC;IAEH;;;;;;;;;;;OAWG;IACI,MAAM,eAAe,GAAI,CAAC,EAAE,CAAC,EAAE,OAAO,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAGnG,CAAC;IAEH;;;;;;;;;;;;OAYG;IACI,MAAM,UAAU,GAAI,CAAC,EAAE,CAAC,EAAE,MAAM,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAG/D,CAAC;CACH"}

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

@@ -1,126 +0,0 @@
-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.make<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.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"]]
-     * ```
-     */
-    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.make<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.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"]
-     * ```
-     */
-    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

@@ -1 +0,0 @@
-{"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;IACvB;;;;;;;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,GAAI,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,CAG7F,CAAC;IAEF;;;;;;;;;;;;;;;OAeG;IACI,MAAM,EAAE,GAAI,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,CAG3F,CAAC;IAEH;;;;;;;;;;;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,EACvB,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAChB,SAAS,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,CAA2B,CAAC;CAC5D"}

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

@@ -1,209 +0,0 @@
-import { WithKind, WithValue } from "./InternalTypes.js";
-import { Result } from "./Result.js";
-/**
- * Option represents an optional value: every Option is either Some (contains a value) or None (empty).
- * Use Option instead of null/undefined to make optionality explicit and composable.
- *
- * @example
- * ```ts
- * const findUser = (id: string): Option<User> =>
- *   users.has(id) ? Option.some(users.get(id)!) : Option.none();
- *
- * pipe(
- *   findUser("123"),
- *   Option.map(user => user.name),
- *   Option.getOrElse(() => "Unknown")
- * );
- * ```
- */
-export type Option<T> = Some<T> | None;
-export type Some<A> = WithKind<"Some"> & WithValue<A>;
-export type None = WithKind<"None">;
-export declare namespace Option {
-    /**
-     * Creates a Some containing the given value.
-     */
-    const some: <A>(value: A) => Some<A>;
-    /**
-     * Type guard that checks if a Option is Some.
-     */
-    const isSome: <A>(data: Option<A>) => data is Some<A>;
-    /**
-     * Creates a None (empty Option).
-     */
-    const none: () => None;
-    /**
-     * Type guard that checks if a Option is None.
-     */
-    const isNone: <A>(data: Option<A>) => data is None;
-    /**
-     * Creates a Option from a nullable value.
-     * Returns None if the value is null or undefined, Some otherwise.
-     *
-     * @example
-     * ```ts
-     * Option.fromNullable(null); // None
-     * Option.fromNullable(42); // Some(42)
-     * ```
-     */
-    const fromNullable: <A>(value: A | null | undefined) => Option<A>;
-    /**
-     * Extracts the value from a Option, returning null if None.
-     */
-    const toNullable: <A>(data: Option<A>) => A | null;
-    /**
-     * Extracts the value from a Option, returning undefined if None.
-     */
-    const toUndefined: <A>(data: Option<A>) => A | undefined;
-    /**
-     * Creates a Option from a possibly undefined value.
-     * Returns None if undefined, Some otherwise.
-     */
-    const fromUndefined: <A>(value: A | undefined) => Option<A>;
-    /**
-     * Converts an Option to a Result.
-     * Some becomes Ok, None becomes Err with the provided error.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Option.some(42),
-     *   Option.toResult(() => "Value was missing")
-     * ); // Ok(42)
-     *
-     * pipe(
-     *   Option.none(),
-     *   Option.toResult(() => "Value was missing")
-     * ); // Err("Value was missing")
-     * ```
-     */
-    const toResult: <E>(onNone: () => E) => <A>(data: Option<A>) => Result<E, A>;
-    /**
-     * Creates an Option from a Result.
-     * Ok becomes Some, Err becomes None (the error is discarded).
-     *
-     * @example
-     * ```ts
-     * Option.fromResult(Result.ok(42)); // Some(42)
-     * Option.fromResult(Result.err("oops")); // None
-     * ```
-     */
-    const fromResult: <E, A>(data: Result<E, A>) => Option<A>;
-    /**
-     * Transforms the value inside a Option if it exists.
-     *
-     * @example
-     * ```ts
-     * pipe(Option.some(5), Option.map(n => n * 2)); // Some(10)
-     * pipe(Option.none(), Option.map(n => n * 2)); // None
-     * ```
-     */
-    const map: <A, B>(f: (a: A) => B) => (data: Option<A>) => Option<B>;
-    /**
-     * Chains Option computations. If the first is Some, passes the value to f.
-     * If the first is None, propagates None.
-     *
-     * @example
-     * ```ts
-     * const parseNumber = (s: string): Option<number> => {
-     *   const n = parseInt(s, 10);
-     *   return isNaN(n) ? Option.none() : Option.some(n);
-     * };
-     *
-     * pipe(Option.some("42"), Option.chain(parseNumber)); // Some(42)
-     * pipe(Option.some("abc"), Option.chain(parseNumber)); // None
-     * ```
-     */
-    const chain: <A, B>(f: (a: A) => Option<B>) => (data: Option<A>) => Option<B>;
-    /**
-     * Extracts the value from a Option by providing handlers for both cases.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Option.some(5),
-     *   Option.fold(
-     *     () => "No value",
-     *     n => `Value: ${n}`
-     *   )
-     * ); // "Value: 5"
-     * ```
-     */
-    const fold: <A, B>(onNone: () => B, onSome: (a: A) => B) => (data: Option<A>) => B;
-    /**
-     * Pattern matches on a Option, returning the result of the matching case.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   optionUser,
-     *   Option.match({
-     *     some: user => `Hello, ${user.name}`,
-     *     none: () => "Hello, stranger"
-     *   })
-     * );
-     * ```
-     */
-    const match: <A, B>(cases: {
-        none: () => B;
-        some: (a: A) => B;
-    }) => (data: Option<A>) => B;
-    /**
-     * Returns the value inside an Option, or a default value if None.
-     * The default is a thunk `() => B` — evaluated only when the Option is None.
-     * The default can be a different type, widening the result to `A | B`.
-     *
-     * @example
-     * ```ts
-     * pipe(Option.some(5), Option.getOrElse(() => 0)); // 5
-     * pipe(Option.none(), Option.getOrElse(() => 0)); // 0
-     * pipe(Option.none<string>(), Option.getOrElse(() => null)); // null — typed as string | null
-     * ```
-     */
-    const getOrElse: <A, B>(defaultValue: () => B) => (data: Option<A>) => A | B;
-    /**
-     * Executes a side effect on the value without changing the Option.
-     * Useful for logging or debugging.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Option.some(5),
-     *   Option.tap(n => console.log("Value:", n)),
-     *   Option.map(n => n * 2)
-     * );
-     * ```
-     */
-    const tap: <A>(f: (a: A) => void) => (data: Option<A>) => Option<A>;
-    /**
-     * Filters a Option based on a predicate.
-     * Returns None if the predicate returns false or if the Option is already None.
-     *
-     * @example
-     * ```ts
-     * pipe(Option.some(5), Option.filter(n => n > 3)); // Some(5)
-     * pipe(Option.some(2), Option.filter(n => n > 3)); // None
-     * ```
-     */
-    const filter: <A>(predicate: (a: A) => boolean) => (data: Option<A>) => Option<A>;
-    /**
-     * Recovers from a None by providing a fallback Option.
-     * The fallback can produce a different type, widening the result to `Option<A | B>`.
-     */
-    const recover: <A, B>(fallback: () => Option<B>) => (data: Option<A>) => Option<A | B>;
-    /**
-     * Applies a function wrapped in a Option to a value wrapped in a Option.
-     *
-     * @example
-     * ```ts
-     * const add = (a: number) => (b: number) => a + b;
-     * pipe(
-     *   Option.some(add),
-     *   Option.ap(Option.some(5)),
-     *   Option.ap(Option.some(3))
-     * ); // Some(8)
-     * ```
-     */
-    const ap: <A>(arg: Option<A>) => <B>(data: Option<(a: A) => B>) => Option<B>;
-}
-//# sourceMappingURL=Option.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Option.d.ts","sourceRoot":"","sources":["../../../src/src/Core/Option.ts"],"names":[],"mappings":"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"}