Test.Falsify.Predicate

Predicates

Intended for qualified import.

Documentation

data Predicate :: [Type] -> Type

N-ary predicate

A predicate of type

Predicate '[Int, Bool, Char, ..]

is essentially a function Int -> Bool -> Char -> .. -> Bool, along with some metadata about that function that allows us to render it in a human readable way. In particular, we construct an Expr for the values that the predicate has been applied to.

Instances

Monoid (Predicate a)

Defined in Test.Falsify.Predicate

Methods

mempty :: Predicate a

mappend :: Predicate a -> Predicate a -> Predicate a

mconcat :: [Predicate a] -> Predicate a

Semigroup (Predicate a)

Defined in Test.Falsify.Predicate

Methods

(<>) :: Predicate a -> Predicate a -> Predicate a

sconcat :: NonEmpty (Predicate a) -> Predicate a

stimes :: Integral b => b -> Predicate a -> Predicate a

Expressions

data Expr

Simple expression language

The internal details of this type are (currently) not exposed.

prettyExpr :: Expr -> String

Functions

data Fn a b

Function (used for composition of a Predicate with a function)

fn :: Show b => (Var, a -> b) -> Fn a b

Default constructor for a function

fnWith :: (Var, b -> String, a -> b) -> Fn a b

Generalization of fn that does not depend on Show

transparent :: (a -> b) -> Fn a b

Function that should not be visible in any rendered failure

Consider these two predicates:

p1, p2 :: Predicate '[Char, Char]
p1 = P.eq `P.on` (P.fn "ord"    ord)
p2 = P.eq `P.on` (P.transparent ord)

Both of these compare two characters on their codepoints (through ord), but they result in different failures. The first would give us something like

(ord x) /= (ord y)
x    : 'a'
y    : 'b'
ord x: 97
ord y: 98

whereas the second might give us something like

x /= y
x: 'a'
y: 'b'

which of these is more useful is of course application dependent.

Construction

alwaysPass :: Predicate xs

Constant True

alwaysFail :: Predicate xs

Constant False

unary

Arguments

:: (a -> Bool)

The predicate proper

-> (Expr -> Err)

Error message, given Expr describing the input

-> Predicate '[a]

Unary predicate

This is essentially a function a -> Bool; see Predicate for detailed discussion.

binary

Arguments

:: (a -> b -> Bool)

The predicate proper

-> (Expr -> Expr -> Err)

Error message, given Expr describing inputs

-> Predicate [a, b]

Binary predicate

This is essentially a function a -> b -> Bool; see Predicate for detailed discussion.

Auxiliary construction

satisfies :: (Var, a -> Bool) -> Predicate '[a]

Specialization of unary for unary relations

relatedBy :: (Var, a -> b -> Bool) -> Predicate [a, b]

Specialization of binary for relations

Combinators

dot :: Predicate (x ': xs) -> Fn y x -> Predicate (y ': xs)

Function composition (analogue of (.))

split :: Predicate (x' ': (y' ': xs)) -> (Fn x x', Fn y y') -> Predicate (x ': (y ': xs))

Analogue of 'Control.Arrow.(***)'

on :: Predicate (x ': (x ': xs)) -> Fn y x -> Predicate (y ': (y ': xs))

Analogue of on

flip :: Predicate (x ': (y ': zs)) -> Predicate (y ': (x ': zs))

Analogue of flip

matchEither :: Predicate (a ': xs) -> Predicate (b ': xs) -> Predicate (Either a b ': xs)

Match on the argument, and apply whichever predicate is applicable.

matchBool

Arguments

:: Predicate xs

Predicate to evaluate if the condition is true

-> Predicate xs

Predicate to evaluate if the condition is false

-> Predicate (Bool ': xs)

Conditional

This is a variation on choose that provides no evidence for which branch is taken.

Evaluation and partial evaluation

eval :: Predicate '[] -> Either Err ()

Evaluate fully applied predicate

(.$) :: Show x => Predicate (x ': xs) -> (Var, x) -> Predicate xs

Infix version of at

Typical usage example:

assert $
     P.relatedBy ("equiv", equiv)
  .$ ("x", x)
  .$ ("y", y)

at

Arguments

:: Predicate (x ': xs)

-> (Expr, String, x)

Renderded name, expression, and input proper

-> Predicate xs

Generation of (.$) that does not require a Show instance

Specific predicates

eq :: Eq a => Predicate [a, a]

Equal

ne :: Eq a => Predicate [a, a]

Not equal

lt :: Ord a => Predicate [a, a]

(Strictly) less than

le :: Ord a => Predicate [a, a]

Less than or equal to

gt :: Ord a => Predicate [a, a]

(Strictly) greater than

ge :: Ord a => Predicate [a, a]

Greater than or equal to

towards :: forall a. (Show a, Ord a, Num a) => a -> Predicate [a, a]

Check that values get closed to the specified target

expect :: (Show a, Eq a) => a -> Predicate '[a]

Specialization of eq, useful when expecting a specific value in a test

between :: (Show a, Ord a) => a -> a -> Predicate '[a]

Check that lo <= x <= hi

even :: Integral a => Predicate '[a]

Number is even

odd :: Integral a => Predicate '[a]

Number is odd

elem :: Eq a => Predicate [[a], a]

Membership check

pairwise :: forall a. Show a => Predicate [a, a] -> Predicate '[[a]]

Apply predicate to every pair of consecutive elements in the list