Predicate

Predicate: object

Type Declaration

all

all: <A>(predicates) => Predicate<A>

Combines an array of predicates with AND: passes only when every predicate holds. Returns true for an empty array (vacuous truth).

Type Parameters

A

A

Parameters

predicates

readonly Predicate<A>[]

Returns

Predicate<A>

Example

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

and

and: <A>(that) => (predicate) => Predicate<A>

Combines two predicates with logical AND: passes only when both hold.

Data-last — the first predicate is the data being piped.

Type Parameters

A

A

Parameters

that

Predicate<A>

Returns

(predicate) => Predicate<A>

Example

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

any

any: <A>(predicates) => Predicate<A>

Combines an array of predicates with OR: passes when at least one holds. Returns false for an empty array.

Type Parameters

A

A

Parameters

predicates

readonly Predicate<A>[]

Returns

Predicate<A>

Example

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

from

from: object

from.Refinement

Refinement: <A, B>(refinement) => Predicate<A> = fromRefinement

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.

This is a zero-cost runtime type cast.

Type Parameters

A

A

B

B

Parameters

Refinement<A, B>

Returns

Predicate<A>

See

Refinement.to.Predicate for the inverse converter under the Refinement namespace.

Example

type NonEmptyString = string & { readonly _tag: "NonEmpty" };
const isNonEmpty: Refinement<string, NonEmptyString> =
  Refinement.from.Predicate(s => s.length > 0);

const isValidUsername: Predicate<string> = pipe(
  Predicate.from.Refinement(isNonEmpty),
  Predicate.and(s => s.length <= 20)
);

isValidUsername("alice");  // true
isValidUsername("");       // false

match

match: <A, B, C>(branches, fallback) => (value) => B | C

Performs declarative conditional branching over [predicate, handler] pairs, returning the handler result of the first matching predicate or evaluating the fallback.

Type Parameters

A

A

B

B

C

C = B

Parameters

branches

readonly (readonly [Predicate<A>, (value) => B])[]

fallback

(value) => C

Returns

(value) => B | C

Example

const classifyNumber = Predicate.match(
  [
    [(n: number) => n < 0, () => "negative"],
    [(n: number) => n === 0, () => "zero"],
  ],
  () => "positive",
);
classifyNumber(-5); // "negative"

not

not: <A>(predicate) => Predicate<A>

Negates a predicate: the result passes exactly when the original fails.

Type Parameters

A

A

Parameters

predicate

Predicate<A>

Returns

Predicate<A>

Example

const isBlank: Predicate<string> = s => s.trim().length === 0;
const isNotBlank = Predicate.not(isBlank);

isNotBlank("hello");  // true
isNotBlank("   ");    // false

or

or: <A>(that) => (predicate) => Predicate<A>

Combines two predicates with logical OR: passes when either holds.

Data-last — the first predicate is the data being piped.

Type Parameters

A

A

Parameters

that

Predicate<A>

Returns

(predicate) => Predicate<A>

Example

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

using

using: <A, B>(transform) => (predicate) => Predicate<B>

Adapts a Predicate<A> to work on a different input type B by applying transform to extract the relevant A from a B before running the check.

Data-last — the predicate is the data being piped; transform is the extractor.

Type Parameters

A

A

B

B

Parameters

transform

(value) => A

Returns

(predicate) => Predicate<B>

Example

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