What is an fp-ts Predicate?

Question

I'm trying to implement some simple data validation with fp-ts, and came across this codesandboxexample:

import * as E from "fp-ts/lib/Either";
import { getSemigroup, NonEmptyArray } from "fp-ts/lib/NonEmptyArray";
import { sequence } from "fp-ts/lib/Array";
import { pipe } from "fp-ts/lib/pipeable";
import { Predicate } from "fp-ts/lib/function";

type ValidationError = NonEmptyArray<string>;

type ValidationResult = E.Either<ValidationError, unknown>;

type ValidationsResult<T> = E.Either<ValidationError, T>;

interface Validator {
  (x: unknown): ValidationResult;
}

interface Name extends String {}

const applicativeV = E.getValidation(getSemigroup<string>());

const validateName: (
  validations: Array<Validator>,
  value: unknown
) => ValidationsResult<Name> = (validations, value) =>
  validations.length
    ? pipe(
        sequence(applicativeV)(validations.map((afb) => afb(value))),
        E.map(() => value as Name)
      )
    : E.right(value as Name);

const stringLengthPredicate: Predicate<unknown> = (v) =>
  typeof v === "string" && v.length > 4;

const lengthAtLeastFour: Validator = E.fromPredicate(
  stringLengthPredicate,
  () => ["value must be a string of at least 5 characters"]
);

const requiredLetterPredicate: Predicate<unknown> = (v) =>
  typeof v === "string" && v.includes("t");

const hasLetterT: Validator = E.fromPredicate(requiredLetterPredicate, () => [
  'value must be a string that includes the letter "t"'
]);

const validations = [hasLetterT, lengthAtLeastFour];

console.log(validateName(validations, "sim"));
// {left: ['value must be a string that includes the letter "t"', 'value must be a string of at least 4 characters']}

console.log(validateName(validations, "timmy"));
// {right: 'timmy'}

What is Predicate? To what effect is it used in this example? I don't see any explanation of what it does in the docs, just that it's part of the API and that it seems to modify a provided interface.

In programming, a predicate is just a function that takes one item and returns a boolean. It is often used for conditional logic like filtering `arr.filter(somePredicate)`. In your case, it's used for validation. It seems like it takes an item and returns `true` if the item is valid, `false`, if it isn't. — VLAZ, May 11 '21 at 05:48
`Predicate` is a function than takes argument of type A and returns a boolean (docs specify it in terms of a call signature: https://www.typescriptlang.org/docs/handbook/2/functions.html#call-signatures). It is a useful building block in validation framework - a boolean returned by a predicate can be interpreted as “is the argument valid” — Lesiak, May 11 '21 at 05:50

user1713450 · Accepted Answer · 2021-05-26T01:55:43.840

5

Predicate<A> = (a:A) => boolean

A predicate is a function that takes an argument and returns a boolean. It's the type taken by filter and also by fromPredicate belonging to many types like Option and Either.

For example,

import { filter } from 'fp-ts/Array'
import { pipe } from 'fp-ts/function'
import { fromPredicate } from 'fp-ts/Either'

const errorIfNotThree = fromPredicate<number>(x => x===3, () => 'not three!')
const f = pipe([1,2,3], filter(x => x===3))

errorIfNotThree(3) // right(3)
errorIfNotThree(5) // left('not three!')
f // [3]

In the above, x => x===3 is of type Predicate<number> because it's a function that takes a number and returns a boolean

edited May 26 '21 at 01:55

answered May 23 '21 at 05:16

user1713450

1,307
7
18

1

`Predicate = (a:A) => boolean` - this is a mistake, since the second `` creates another type variable shadowing the first, and this effectively means the function can accept any type of argument because the second `A` is unrelated to the first (and can be any type specified by the caller). Should be `Predicate = (a:A) => boolean`. – kaya3 May 23 '21 at 05:24

What is an fp-ts Predicate?

1 Answers1