Perlica

Appearance

Predicate overview ​

Instances ​

Predicate ​

ts
export interface Predicate<T> {
  (value: T): boolean;
}

Combinators ​

not ​

ts
export const not = <T>(self: Predicate<T>): Predicate<T>

Returns Predicate<T> with negates result.

ts
import { not, isNumber } from "perlica/Predicate"

const isNotNumber = not(isNumber);

expect(isNotNumber(4)).toBeFalse();
expect(isNotNumber("hello")).toBeTrue();

and ​

ts
export const and = <T>(self: Predicate<T>, that: Predicate<T>): Predicate<T>

Combines two predicates (self and that) into a new Predicate<T>.
Returns true if both returns true, otherwise returns false.

ts
import { and } from "perlica/Predicate"
import { lt, gt } from "perlica/Predicate/Number"

const between5And10 = and(lt(10), gt(5));

expect(between5And10(7)).toBeTrue();
expect(between5And10(2)).toBeFalse();
expect(between5And10(12)).toBeFalse();

or ​

ts
export const or = <T>(self: Predicate<T>, that: Predicate<T>): Predicate<T>

Combines two predicates (self and that) into a new Predicate<T>.
Returns true if at least one returns true, otherwise returns false.

ts
import { or } from "perlica/Predicate"
import { lt, gt} from "perlica/Predicate/Number"

const less5OrGreater10 = or(lt(5), gt(10));

expect(less5OrGreater10(7)).toBeFalse();
expect(less5OrGreater10(2)).toBeTrue();
expect(less5OrGreater10(12)).toBeTrue();

all ​

ts
export const all = <T>(predicates: Iterable<Predicate<T>>): Predicate<T>

Combining multiple predicates into a new Predicate<T>.
Returns true if all returns true, otherwise returns false.

ts
import { all, isNumber } from "perlica/Predicate"
import { lt, gt } from "perlica/Predicate/Number"

const myNumber = all([isNumber, lt(10), gt(5)]);

expect(myNumber(7)).toBeTrue();
expect(myNumber(2)).toBeFalse();
expect(myNumber(12)).toBeFalse();

any ​

ts
export const any = <T>(predicates: Iterable<Predicate<T>>): Predicate<T>

Combining multiple predicates into a new Predicate<T>.
Returns true if at least one returns true, otherwise returns false.

ts
import { any, isNumber, isString, isBoolean } from "perlica/Predicate"

const isNumberOrStringOrBoolean = any([isNumber, isString, isBoolean]);

expect(isNumberOrStringOrBoolean(4)).toBeTrue();
expect(isNumberOrStringOrBoolean("test")).toBeTrue();
expect(isNumberOrStringOrBoolean(true)).toBeTrue();

expect(isNumberOrStringOrBoolean(null)).toBeFalse();
expect(isNumberOrStringOrBoolean(undefined)).toBeFalse();
expect(isNumberOrStringOrBoolean({})).toBeFalse();

eq ​

ts
export const eq = <T>(that: T): Predicate<T>

Returns a new Predicate<T>.
Returns true if that is equal to a pre-defined value.

ts
import { eq } from "perlica/Predicate"

const predicate = eq(5);

expect(predicate(5)).toBeTrue();
expect(predicate(4)).toBeFalse();

ne ​

ts
export const ne = <T>(that: T): Predicate<T>

Returns a new Predicate<T>.
Returns true if that is not equal to a pre-defined value.

ts
import { ne } from "perlica/Predicate"

const predicate = ne(5);

expect(predicate(5)).toBeFalse();
expect(predicate(4)).toBeTrue();

Guards ​

isNull ​

ts
export const isNull = (value: unknown): value is null

Returns true if value is null, otherwise returns false.

ts
import { isNull } from "perlica/Predicate"

expect(isNull(null)).toBeTrue();
expect(isNull(undefined)).toBeFalse();
expect(isNull(4)).toBeFalse();
expect(isNull("hello")).toBeFalse();

isNotNull ​

ts
export const isNotNull = <T>(value: T): value is Exclude<T, null>

Returns true if value is not null, otherwise returns false.

ts
import { isNotNull } from "perlica/Predicate"

expect(isNotNull(null)).toBeFalse();
expect(isNotNull(undefined)).toBeTrue();
expect(isNotNull(4)).toBeTrue();
expect(isNotNull("hello")).toBeTrue();

isUndefined ​

ts
export const isUndefined = (value: unknown): value is undefined

Returns true if value is undefined, otherwise returns false.

ts
import { isUndefined } from "perlica/Predicate"

expect(isUndefined(null)).toBeFalse();
expect(isUndefined(undefined)).toBeTrue();
expect(isUndefined(4)).toBeFalse();
expect(isUndefined("hello")).toBeFalse();

isNotUndefined ​

ts
export const isNotUndefined = <T>(value: T): value is Exclude<T, undefined>

Returns true if value is not undefined, otherwise returns false.

ts
import { isNotUndefined } from "perlica/Predicate"

expect(isNotUndefined(null)).toBeTrue();
expect(isNotUndefined(undefined)).toBeFalse();
expect(isNotUndefined(4)).toBeTrue();
expect(isNotUndefined("hello")).toBeTrue();

isBoolean ​

ts
export const isBoolean = (value: unknown): value is boolean

Returns true if value is true or false, otherwise returns false.

ts
import { isBoolean } from "perlica/Predicate"

expect(isBoolean(true)).toBeTrue();
expect(isBoolean(false)).toBeTrue();
expect(isBoolean(null)).toBeFalse();
expect(isBoolean(4)).toBeFalse();

isNumber ​

ts
export const isNumber = (value: unknown): value is number

Returns true if value is number, otherwise returns false.

ts
import { isNumber } from "perlica/Predicate"

expect(isNumber(4)).toBeTrue();
expect(isNumber(4.4)).toBeTrue();

expect(isNumber(null)).toBeFalse();
expect(isNumber(true)).toBeFalse();
expect(isNumber("hello")).toBeFalse();

isInteger ​

ts
export const isInteger = (value: unknown): value is number

Returns true if value is integer, otherwise returns false.

ts
import { isInteger } from "perlica/Predicate"

expect(isInteger(4)).toBeTrue();
expect(isInteger(4.4)).toBeFalse();

isBigInt ​

ts
export const isInteger = (value: unknown): value is number

Returns true if value is bigint, otherwise returns false.

ts
import { isBigInt } from "perlica/Predicate"

expect(isBigInt(4)).toBeFalse();
expect(isBigInt(4n)).toBeTrue();

isString ​

ts
export const isString = (value: unknown): value is string

Returns true if value is string, otherwise returns false.

ts
import { isString } from "perlica/Predicate"

expect(isString("hello")).toBeTrue();
expect(isString(4)).toBeFalse();
expect(isString(null)).toBeFalse();
expect(isString(true)).toBeFalse();

isFunction ​

ts
export const isFunction = (value: unknown): value is Function

Returns true if value is Function, otherwise returns false.

ts
import { isFunction } from "perlica/Predicate"

expect(isFunction(isFunction)).toBeTrue();
expect(isFunction("isFunction")).toBeFalse();

isSymbol ​

ts
export const isSymbol = (value: unknown): value is symbol

Returns true if value is symbol, otherwise returns false.

ts
import { isSymbol } from "perlica/Predicate"

expect(isSymbol(Symbol.for("a"))).toBeTrue();
expect(isSymbol("a")).toBeFalse();

isTruthy ​

ts
export const isTruthy = (value: unknown): boolean

Returns true if value is not symbol, otherwise returns false.

ts
import { isTruthy } from "perlica/Predicate"

expect(isTruthy(1)).toBeTrue();
expect(isTruthy("a")).toBeTrue();

expect(isTruthy(0)).toBeFalse();
expect(isTruthy("")).toBeFalse();

isSet ​

ts
export const isSet = (value: unknown): value is Set<unknown>

Returns true if value is Set, otherwise returns false.

ts
import { isSet } from "perlica/Predicate"

expect(isSet(new Set())).toBeTrue();
expect(isSet({})).toBeFalse();

isMap ​

ts
export const isMap = (value: unknown): value is Map<unknown, unknown>

Returns true if value is Map, otherwise returns false.

ts
import { isMap } from "perlica/Predicate"

expect(isMap(new Map())).toBeTrue();
expect(isMap({})).toBeFalse();

isError ​

ts
export const isError = (value: unknown): value is Error

Returns true if value is Error, otherwise returns false.

ts
import { isError } from "perlica/Predicate"

expect(isError(new Error())).toBeTrue();
expect(isError({})).toBeFalse();
expect(isError(null)).toBeFalse();
expect(isError(undefined)).toBeFalse();

isNullable ​

ts
export const isNullable = <T>(value: T): value is Extract<T, null | undefined>

Returns true if value is null or undefined, otherwise returns false.

ts
import { isNullable } from "perlica/Predicate"

expect(isNullable(null)).toBeTrue();
expect(isNullable(undefined)).toBeTrue();
expect(isNullable(4)).toBeFalse();

isNotNullable ​

ts
export const isNotNullable = <T>(value: T): value is NonNullable<T>

Returns true if value is not null and not undefined, otherwise returns false.

ts
import { isNotNullable } from "perlica/Predicate"

expect(isNotNullable(null)).toBeFalse();
expect(isNotNullable(undefined)).toBeFalse();
expect(isNotNullable(4)).toBeTrue();

isPromise ​

ts
export const isPromise = (value: unknown): value is Promise<unknown>

Returns true if value is Promise, otherwise returns false.

ts
import { IsPromise } from "perlica/Predicate"

expect(IsPromise(Promise.resolve(4))).toBeTrue();
expect(IsPromise(4)).toBeFalse();

isRegExp ​

ts
export const isRegExp = (value: unknown): value is RegExp

Returns true if value is RegExp, otherwise returns false.

ts
import { isRegExp } from "perlica/Predicate"

expect(isRegExp(/4/)).toBeTrue();
expect(isRegExp(4)).toBeFalse();

isDate ​

ts
export const isDate = (value: unknown): value is Date

Returns true if value is Date, otherwise returns false.

ts
import { isDate } from "perlica/Predicate"

expect(isDate(new Date())).toBeTrue();
expect(isDate({})).toBeFalse();

isRecordOrArray ​

ts
export const isRecordOrArray = (value: unknown): value is { [x: PropertyKey]: unknown }

Returns true if value is record or array, otherwise returns false.

ts
import { isRecordOrArray } from "perlica/Predicate"

expect(isRecordOrArray({})).toBeTrue();
expect(isRecordOrArray([])).toBeTrue();

expect(isRecordOrArray(null)).toBeFalse();
expect(isRecordOrArray(undefined)).toBeFalse();
expect(isRecordOrArray(4)).toBeFalse();

isObject ​

ts
export const isObject = (value: unknown): value is object

Returns true if value is object (record, array, function), otherwise returns false.

ts
import { isObject } from "perlica/Predicate"

expect(isObject({})).toBeTrue();
expect(isObject([])).toBeTrue();
expect(isObject(() => {})).toBeTrue();

expect(isObject(null)).toBeFalse();
expect(isObject(undefined)).toBeFalse();
expect(isObject(4)).toBeFalse();

hasProperty ​

ts
export const hasProperty = <P extends PropertyKey>(
  value: unknown, property: P,
): value is { [K in P]: unknown }

Returns true if value is object and containing a property key, otherwise returns false.

ts
import { hasProperty } from "perlica/Predicate"

expect(hasProperty({}, "test")).toBeFalse();
expect(hasProperty("test", "test")).toBeFalse();
expect(hasProperty({ test: 4 }, "test")).toBeTrue();

isIterable ​

ts
export const isIterable = (value: unknown): value is Iterable<unknown>

Returns true if value is object and containing a Symbol.iterator key, otherwise returns false.

ts
import { isIterable } from "perlica/Predicate"

expect(isIterable([])).toBeTrue();
expect(isIterable({})).toBeFalse();

isAsyncIterable ​

ts
export const isAsyncIterable = (value: unknown): value is AsyncIterable<unknown>

Returns true if value is object and containing a Symbol.asyncIterator key, otherwise returns false.

ts
import { isAsyncIterable } from "perlica/Predicate"

expect(isAsyncIterable({ [Symbol.asyncIterator]() {} })).toBeTrue();
expect(isAsyncIterable({})).toBeFalse();

isTypedArray ​

ts
export const isTypedArray = (value: unknown): value is TypedArray

Returns true if value is TypedArray, otherwise returns false.

isInt8Array ​

ts
export const isInt8Array = (value: unknown): value is Int8Array

Returns true if value is Int8Array, otherwise returns false.

isUint8Array ​

ts
export const isUint8Array = (value: unknown): value is Uint8Array

Returns true if value is Uint8Array, otherwise returns false.

isUint8ClampedArray ​

ts
export const isUint8ClampedArray = (value: unknown): value is Uint8ClampedArray

Returns true if value is Uint8ClampedArray, otherwise returns false.

isInt16Array ​

ts
export const isInt16Array = (value: unknown): value is Int16Array

Returns true if value is Int16Array, otherwise returns false.

isUint16Array ​

ts
export const isUint16Array = (value: unknown): value is Uint16Array

Returns true if value is Uint16Array, otherwise returns false.

isInt32Array ​

ts
export const isInt32Array = (value: unknown): value is Int32Array

Returns true if value is Int32Array, otherwise returns false.

isUint32Array ​

ts
export const isUint32Array = (value: unknown): value is Uint32Array

Returns true if value is Uint32Array, otherwise returns false.

isFloat32Array ​

ts
export const isFloat32Array = (value: unknown): value is Float32Array

Returns true if value is Float32Array, otherwise returns false.

isFloat64Array ​

ts
export const isFloat64Array = (value: unknown): value is Float64Array

Returns true if value is Float64Array, otherwise returns false.

isBigInt64Array ​

ts
export const isBigInt64Array = (value: unknown): value is BigInt64Array

Returns true if value is BigInt64Array, otherwise returns false.

isBigUint64Array ​

ts
export const isBigUint64Array = (value: unknown): value is BigUint64Array

Returns true if value is BigUint64Array, otherwise returns false

String ​

isEmpty ​

ts
export const isEmpty = (self: string): self is ""

Returns true if self is empty, otherwise returns false.

ts
import { isEmpty } from "perlica/Predicate/String"

expect(isEmpty("hello")).toBeFalse();
expect(isEmpty("")).toBeTrue();

includes ​

ts
export const includes = (searchString: string, position?: number): Predicate<string>

Returns a new Predicate<T>.
Returns true if searchString appears as a substring of self, otherwise returns false.

ts
import { includes } from "perlica/Predicate/String"

const predicate = includes("test");

expect(predicate("Hello test world")).toBeTrue();
expect(predicate("Hello world")).toBeFalse();

startsWith ​

ts
export const startsWith = (searchString: string, position?: number): Predicate<string>

Returns a new Predicate<T>.
Returns true if searchString starts with a self, otherwise returns false.

ts
import { startsWith } from "perlica/Predicate/String"

const predicate = startsWith("test");

expect(predicate("test world")).toBeTrue();
expect(predicate("world")).toBeFalse();

endsWith ​

ts
export const endsWith = (searchString: string, position?: number): Predicate<string>

Returns a new Predicate<T>.
Returns true if searchString ends with a self, otherwise returns false.

ts
import { endsWith } from "perlica/Predicate/String"

const predicate = endsWith("test");

expect(predicate("world test")).toBeTrue();
expect(predicate("world")).toBeFalse();

isMatch ​

ts
export const isMatch = (regexp: RegExp): Predicate<string>

Returns a new Predicate<T>.
Returns true if a regular expression (regexp) to match self, otherwise returns false.

ts
import { isMatch } from "perlica/Predicate/String"

const predicate = isMatch(/Hello.*/);

expect(predicate("Hello world")).toBeTrue();
expect(predicate("Fello world")).toBeFalse();

max ​

ts
export const maxLen = (count: number): Predicate<string>

Returns a new Predicate<T>.
Returns true if value is length less or equal to a pre-defined count.

ts
import { max } from "perlica/Predicate/String"

const predicate = max(5);

expect(predicate("Hello")).toBeTrue();
expect(predicate("Hello world")).toBeFalse();

min ​

ts
export const minLen = (count: number): Predicate<string>

Returns a new Predicate<T>.
Returns true if value is length greater or equal to a pre-defined count.

ts
import { min } from "perlica/Predicate/String"

const predicate = min(5);

expect(predicate("Hello")).toBeTrue();
expect(predicate("Hello world")).toBeFalse();

len ​

ts
export const len = (count: number): Predicate<string>

Returns a new Predicate<T>.
Returns true if value is length equal to a pre-defined count.

ts
import { len } from "perlica/Predicate/String"

const predicate = len(5);

expect(predicate("Hello")).toBeTrue();
expect(predicate("Hi")).toBeFalse();
expect(predicate("Hello world")).toBeFalse();

Array ​

isEmpty ​

ts
export const isEmpty = <T>(self: T[]): self is []

Returns true if self is empty, otherwise returns false.

ts
import { isEmpty } from "perlica/Predicate/Array"
 *
expect(isEmpty([4])).toBeFalse();
expect(isEmpty([])).toBeTrue();

isNonEmpty ​

ts
export const isNonEmpty = <T>(self: T[]): self is [T, ...T[]]

Returns true if self is not empty, otherwise returns false.

ts
import { isNonEmpty } from "perlica/Predicate/Array"
 *
expect(isEmpty([4])).toBeTrue();
expect(isEmpty([])).toBeFalse();

max ​

ts
export const maxLen = <T>(count: number): predicate.Predicate<T[]>

Returns a new Predicate<T>.
Returns true if value is length less or equal to a pre-defined count.

ts
import { max } from "perlica/Predicate/Array"

const predicate = max(5);

expect(predicate([1, 2, 3, 4])).toBeTrue();
expect(predicate([1, 2, 3, 4, 5])).toBeFalse();

min ​

ts
export const minLen = <T>(count: number): Predicate<T[]>

Returns a new Predicate<T>.
Returns true if value is length greater or equal to a pre-defined count.

ts
import { min } from "perlica/Predicate/Array"

const predicate = min(4);

expect(predicate([1, 2, 3, 4])).toBeTrue();
expect(predicate([1, 2, 3])).toBeFalse();

len ​

ts
export const len = <T>(count: number): Predicate<T[]>

Returns a new Predicate<T>.
Return true if value is length equal to a pre-defined count.

ts
import { len } from "perlica/Predicate/Array"

const predicate = len(4);

expect(predicate([1, 2, 3, 4])).toBeTrue();
expect(predicate([1, 2])).toBeFalse();
expect(predicate([1, 2, 3, 4, 5])).toBeFalse();

Number ​

isPositive ​

ts
export const isPositive = (value: number): boolean

Returns true if value > 0, otherwise returns false.

ts
import { isPositive } from "perlica/Predicate/Number"

expect(isPositive(0)).toBeFalse();
expect(isPositive(4)).toBeTrue();
expect(isPositive(-4)).toBeFalse();

isNonNegative ​

ts
export const isNonNegative = (value: number): boolean

Returns true if value >= 0, otherwise returns false.

ts
import { isNonNegative } from "perlica/Predicate/Number"

expect(isNonNegative(0)).toBeTrue();
expect(isNonNegative(4)).toBeTrue();
expect(isNonNegative(-4)).toBeFalse();

isNegative ​

ts
export const isNegative = (value: number): boolean

Returns true if value < 0, otherwise returns false.

ts
import { isNegative } from "perlica/Predicate/Number"

expect(isNegative(0)).toBeFalse();
expect(isNegative(4)).toBeFalse();
expect(isNegative(-4)).toBeTrue();

isNonPositive ​

ts
export const isNonPositive = (value: number): boolean

Returns true if value <= 0, otherwise returns false.

ts
import { isNonPositive } from "perlica/Predicate/Number"

expect(isNonPositive(0)).toBeTrue();
expect(isNonPositive(4)).toBeFalse();
expect(isNonPositive(-4)).toBeTrue();

isFinite ​

ts
export const isFinite = (value: number): boolean

Returns true if value is finite, not Infinity or -Infinity, otherwise returns false.

ts
import { isFinite } from "perlica/Predicate/Number"

expect(isFinite(4 / 2)).toBeTrue();
expect(isFinite(4 / 0)).toBeFalse();

multipleOf ​

ts
export const multipleOf = (that: number): Predicate<number>

Returns a new Predicate<T>.
Returns true if value is evenly divisible by a pre-defined that.

ts
import { multipleOf } from "perlica/Predicate/Number"

const predicate = multipleOf(2);

expect(predicate(4)).toBeTrue();
expect(predicate(3)).toBeFalse();

lt ​

ts
export const lt = <T>(that: T): Predicate<T>

Returns a new Predicate<T>.
Returns true if that is less than a pre-defined value.

ts
import { lt } from "perlica/Predicate/Number"

const predicate = lt(4);

expect(predicate(5)).toBeFalse();
expect(predicate(4)).toBeFalse();
expect(predicate(3)).toBeTrue();

gt ​

ts
export const gt = <T>(that: T): Predicate<T>

Returns a new Predicate<T>.
Returns true if that is greater than a pre-defined value.

ts
import { gt } from "perlica/Predicate/Number"

const predicate = gt(4);

expect(predicate(5)).toBeTrue();
expect(predicate(4)).toBeFalse();
expect(predicate(3)).toBeFalse();

le ​

ts
export const le = <T>(that: T): Predicate<T>

Returns a new Predicate<T>.
Returns true if that is less than or equal to a pre-defined value.

ts
import { le } from "perlica/Predicate/Number"

const predicate = le(4);

expect(predicate(5)).toBeFalse();
expect(predicate(4)).toBeTrue();
expect(predicate(3)).toBeTrue();

ge ​

ts
export const ge = <T>(that: T): Predicate<T>

Returns a new Predicate<T>.
Returns true if that is greater than or equal to a pre-defined value.

ts
import { ge } from "perlica/Predicate/Number"

const predicate = ge(4);

expect(predicate(5)).toBeTrue();
expect(predicate(4)).toBeTrue();
expect(predicate(3)).toBeFalse();

BigInt ​

isPositive ​

ts
export const isPositive = (value: number): boolean

Returns true if value > 0, otherwise returns false.

ts
import { isPositive } from "perlica/Predicate/BigInt"

expect(isPositive(0n)).toBeFalse();
expect(isPositive(4n)).toBeTrue();
expect(isPositive(-4n)).toBeFalse();

isNonNegative ​

ts
export const isNonNegative = (value: number): boolean

Returns true if value >= 0, otherwise returns false.

ts
import { isNonNegative } from "perlica/Predicate/BigInt"

expect(isNonNegative(0n)).toBeTrue();
expect(isNonNegative(4n)).toBeTrue();
expect(isNonNegative(-4n)).toBeFalse();

isNegative ​

ts
export const isNegative = (value: number): boolean

Returns true if value < 0, otherwise returns false.

ts
import { isNegative } from "perlica/Predicate/BigInt"

expect(isNegative(0n)).toBeFalse();
expect(isNegative(4n)).toBeFalse();
expect(isNegative(-4n)).toBeTrue();

isNonPositive ​

ts
export const isNonPositive = (value: number): boolean

Returns true if value <= 0, otherwise returns false.

ts
import { isNonPositive } from "perlica/Predicate/BigInt"

expect(isNonPositive(0n)).toBeTrue();
expect(isNonPositive(4n)).toBeFalse();
expect(isNonPositive(-4n)).toBeTrue();

multipleOf ​

ts
export const multipleOf = (that: number): Predicate<number>

Returns a new Predicate<T>.
Returns true if value is evenly divisible by a pre-defined that.

ts
import { multipleOf } from "perlica/Predicate/BigInt"

const predicate = multipleOf(2);

expect(predicate(4n)).toBeTrue();
expect(predicate(3n)).toBeFalse();

lt ​

ts
export const lt = <T>(that: T): Predicate<T>

Returns a new Predicate<T>.
Returns true if that is less than a pre-defined value.

ts
import { lt } from "perlica/Predicate/BigInt"

const predicate = lt(4);

expect(predicate(5n)).toBeFalse();
expect(predicate(4n)).toBeFalse();
expect(predicate(3n)).toBeTrue();

gt ​

ts
export const gt = <T>(that: T): Predicate<T>

Returns a new Predicate<T>.
Returns true if that is greater than a pre-defined value.

ts
import { gt } from "perlica/Predicate/BigInt"

const predicate = gt(4);

expect(predicate(5n)).toBeTrue();
expect(predicate(4n)).toBeFalse();
expect(predicate(3n)).toBeFalse();

le ​

ts
export const le = <T>(that: T): Predicate<T>

Returns a new Predicate<T>.
Returns true if that is less than or equal to a pre-defined value.

ts
import { le } from "perlica/Predicate/BigInt"

const predicate = le(4);

expect(predicate(5n)).toBeFalse();
expect(predicate(4n)).toBeTrue();
expect(predicate(3n)).toBeTrue();

ge ​

ts
export const ge = <T>(that: T): Predicate<T>

Returns a new Predicate<T>.
Returns true if that is greater than or equal to a pre-defined value.

ts
import { ge } from "perlica/Predicate/BigInt"

const predicate = ge(4);

expect(predicate(5n)).toBeTrue();
expect(predicate(4n)).toBeTrue();
expect(predicate(3n)).toBeFalse();