Predicate HOF ^{_{(High-Order-Functions)}}

A collections of higher-order-functions to combine and negate predicates, without evaluating said predicates.

Fully written in TypeScript, and no dependencies.

Currently, the functions available are:

• not,           negates the predicate.
• all,           true only if ALL the predicates returns true.
• any,           true if ANY the predicate returns true.
• none,            true only if NONE of the predicates return true.
• onlyOne,     true if ONLY ONE of the predicates return true.

They all work with predicates taking in any number of arguments, as long as all the predicates take in the same (or subtype/supertype) parameters for example:

interface Parent {
    x: number
}
interface Child extends Parent {
    y: string
}

const parentPredicate = (x: Parent) => true
const childPredicate = (x: Child) => true

// Both works:
all(parentPredicate, childPredicate)
all(childPredicate, parentPredicate)

If you're getting type errors, check the "Fixing type errors" section below

Install

npm i predicate-hof

Examples

I didn't define the predicates below for simplicity-sake, so you can just use your imagination on how they work :)

import { all } from 'predicate-hof'

const canBuyAGun = all(isAbove18, hasNoCriminalRecord, hasMoney)
canBuyAGun(bob) // true,  bob is cool
canBuyAGun(brokeAssTimmy) // false, go get a job Timmy

import { any } from 'predicate-hof'

const toCallCops = any(hasDoneSmthBad, hasStolenMyPurse, isBlack)
toCallCops(bob) // false, bob is still cool
toCallCops(obama) // true,  he didn't do anything wrong but...

import { not } from 'predicate-hof'

isAlive(bob) // true, always alive in my heart
not(isAlive)(johnFKennedy) // true

wasAssassinated(johnFKennedy) // true, rip Mr President :(
not(wasAssassinated)(epstein) // :^)

Here's examples for binary-predicates

import { any } from 'predicate-hof'

isLessThan(1, 3) // true, 1 < 3
isEqual(1, 1) // true, 1 === 1

const isLessThanOrEqual = any(isLessThan, isEqual)
isLessThanOrEqual(1, 5) // true, 1 <= 5
isLessThanOrEqual(1, 1) // true, 1 <= 1

Fixing type errors

If the predicate parameters don't match exactly, TypeScript might complain:

const numOnly = (n: number) => true
const numAndStr = (n: number, str: string) => true

all(numOnly, numAndStr) // numAndStr gives type error

A fix would be to ensure the predicate that accepts the most parameters is the first to be passed:

// 'numAndStr' takes more parameters,
// so it should be at the front.
all(numAndStr, numOnly)

If that doesn't work, or is not possible to do, you can specify the generic type (which is an array of the parameter type(s)):

// number is 1st argument
// string is 2nd argument
all<[number, string]>(numOnly, numAndStr)