@nlozgachev/pipelined 0.11.0 → 0.13.0

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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"}

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

@@ -1,158 +0,0 @@
-import { Option } from "./Option.js";
-import type { Lens } from "./Lens.js";
-/** Keys of T for which undefined is assignable (i.e. optional fields). */
-type OptionalKeys<T> = {
-    [K in keyof T]-?: undefined extends T[K] ? K : never;
-}[keyof T];
-/**
- * Optional<S, A> focuses on a value A inside a structure S that may or may
- * not be present. Like a Lens, but get returns Option<A>.
- *
- * Compose with other Optionals via `andThen`, or with a Lens via `andThenLens`.
- * Convert a Lens to an Optional with `Lens.toOptional`.
- *
- * @example
- * ```ts
- * type Profile = { username: string; bio?: string };
- *
- * const bioOpt = Optional.prop<Profile>()("bio");
- *
- * pipe(profile, Optional.get(bioOpt));               // Some("hello") or None
- * pipe(profile, Optional.set(bioOpt)("hello"));      // new Profile with bio set
- * pipe(profile, Optional.modify(bioOpt)(s => s + "!")); // appends if present
- * ```
- */
-export type Optional<S, A> = {
-    readonly get: (s: S) => Option<A>;
-    readonly set: (a: A) => (s: S) => S;
-};
-export declare namespace Optional {
-    /**
-     * Constructs an Optional from a getter (returning Option<A>) and a setter.
-     *
-     * @example
-     * ```ts
-     * const firstChar = Optional.make(
-     *   (s: string) => s.length > 0 ? Option.some(s[0]) : Option.none(),
-     *   (c) => (s) => s.length > 0 ? c + s.slice(1) : s,
-     * );
-     * ```
-     */
-    const make: <S, A>(get: (s: S) => Option<A>, set: (a: A) => (s: S) => S) => Optional<S, A>;
-    /**
-     * Creates an Optional that focuses on an optional property of an object.
-     * Only keys whose type includes undefined (i.e. `field?: T`) are accepted.
-     * Call with the structure type first, then the key.
-     *
-     * @example
-     * ```ts
-     * type Profile = { username: string; bio?: string };
-     * const bioOpt = Optional.prop<Profile>()("bio");
-     * ```
-     */
-    const prop: <S>() => <K extends OptionalKeys<S>>(key: K) => Optional<S, NonNullable<S[K]>>;
-    /**
-     * Creates an Optional that focuses on an element at a given index in an array.
-     * Returns None when the index is out of bounds; set is a no-op when out of bounds.
-     *
-     * @example
-     * ```ts
-     * const firstItem = Optional.index<string>(0);
-     *
-     * pipe(["a", "b"], Optional.get(firstItem)); // Some("a")
-     * pipe([], Optional.get(firstItem));         // None
-     * ```
-     */
-    const index: <A>(i: number) => Optional<A[], A>;
-    /**
-     * Reads the focused value from a structure, returning Option<A>.
-     *
-     * @example
-     * ```ts
-     * pipe(profile, Optional.get(bioOpt)); // Some("...") or None
-     * ```
-     */
-    const get: <S, A>(opt: Optional<S, A>) => (s: S) => Option<A>;
-    /**
-     * Replaces the focused value within a structure.
-     * For indexed focuses, this is a no-op when the index is out of bounds.
-     *
-     * @example
-     * ```ts
-     * pipe(profile, Optional.set(bioOpt)("hello"));
-     * ```
-     */
-    const set: <S, A>(opt: Optional<S, A>) => (a: A) => (s: S) => S;
-    /**
-     * Applies a function to the focused value if it is present; returns the
-     * structure unchanged if the focus is absent.
-     *
-     * @example
-     * ```ts
-     * pipe(profile, Optional.modify(bioOpt)(s => s.toUpperCase()));
-     * ```
-     */
-    const modify: <S, A>(opt: Optional<S, A>) => (f: (a: A) => A) => (s: S) => S;
-    /**
-     * Returns the focused value or a default when the focus is absent.
-     *
-     * @example
-     * ```ts
-     * pipe(profile, Optional.getOrElse(bioOpt)(() => "no bio"));
-     * ```
-     */
-    const getOrElse: <S, A>(opt: Optional<S, A>) => (defaultValue: () => A) => (s: S) => A;
-    /**
-     * Extracts a value from an Optional focus using handlers for the present
-     * and absent cases.
-     *
-     * @example
-     * ```ts
-     * pipe(profile, Optional.fold(bioOpt)(() => "no bio", (bio) => bio.toUpperCase()));
-     * ```
-     */
-    const fold: <S, A>(opt: Optional<S, A>) => <B>(onNone: () => B, onSome: (a: A) => B) => (s: S) => B;
-    /**
-     * Pattern matches on an Optional focus using a named-case object.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   profile,
-     *   Optional.match(bioOpt)({ none: () => "no bio", some: (bio) => bio }),
-     * );
-     * ```
-     */
-    const match: <S, A>(opt: Optional<S, A>) => <B>(cases: {
-        none: () => B;
-        some: (a: A) => B;
-    }) => (s: S) => B;
-    /**
-     * Composes two Optionals: focuses through the outer, then through the inner.
-     * Returns None if either focus is absent.
-     *
-     * @example
-     * ```ts
-     * const deepOpt = pipe(
-     *   Optional.prop<User>()("address"),
-     *   Optional.andThen(Optional.prop<Address>()("landmark")),
-     * );
-     * ```
-     */
-    const andThen: <A, B>(inner: Optional<A, B>) => <S>(outer: Optional<S, A>) => Optional<S, B>;
-    /**
-     * Composes an Optional with a Lens, producing an Optional.
-     * The Lens focuses within the value found by the Optional.
-     *
-     * @example
-     * ```ts
-     * const cityOpt = pipe(
-     *   Optional.prop<User>()("address"),
-     *   Optional.andThenLens(Lens.prop<Address>()("city")),
-     * );
-     * ```
-     */
-    const andThenLens: <A, B>(inner: Lens<A, B>) => <S>(outer: Optional<S, A>) => Optional<S, B>;
-}
-export {};
-//# sourceMappingURL=Optional.d.ts.map

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

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

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

@@ -1,161 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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;IAC1B;;;;;;;;;;;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,CAAiC,CAAC;IAEpH;;;;;;;;;;;;;;;;OAgBG;IACI,MAAM,EAAE,GAAI,CAAC,EAAE,QAAQ,SAAS,CAAC,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC,CAAC,KAAG,SAAS,CAAC,CAAC,CAAiC,CAAC;IAEnH;;;;;;;;;;;;;;;;;;;;;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,CAAyC,CAAC;IAEtH;;;;;;;;;;;;;;;;OAgBG;IACI,MAAM,GAAG,GAAI,CAAC,EAAE,YAAY,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,KAAG,SAAS,CAAC,CAAC,CAAwC,CAAC;IAErH;;;;;;;;;;;;;;;;;;;OAmBG;IACI,MAAM,cAAc,GAAI,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,SAAS,CAAC,CAAC,CAAM,CAAC;CACvF"}