A predicate that matches any value

A predicate checking if the input is equal to the given value

>>> 1 `shouldSatisfy` P.eq 1

A predicate checking if the input is greater than the given value

>>> 1 `shouldSatisfy` P.gt 0

A predicate checking if the input is greater than or equal to the given value

>>> 1 `shouldSatisfy` P.gte 0

A predicate checking if the input is less than the given value

>>> 1 `shouldSatisfy` P.lt 10

A predicate checking if the input is less than or equal to the given value

>>> 1 `shouldSatisfy` P.lte 10

A predicate checking if the input is Just, wrapping a value matching the given predicate.

>>> Just 1 `shouldSatisfy` P.just (P.gt 0)

A predicate checking if the input is Nothing

>>> Nothing `shouldSatisfy` P.nothing

A predicate checking if the input is Left, wrapping a value matching the given predicate.

>>> Left 1 `shouldSatisfy` P.left (P.gt 0)

A predicate checking if the input is Right, wrapping a value matching the given predicate.

>>> Right 1 `shouldSatisfy` P.right (P.gt 0)

A predicate checking if the input is a list matching exactly the given predicates.

>>> [1, 2, 3] `shouldSatisfy` P.list [P.eq 1, P.eq 2, P.eq 3]
>>> [1, 2, 3] `shouldNotSatisfy` P.list [P.eq 1, P.eq 2]
>>> [1, 2, 3] `shouldNotSatisfy` P.list [P.eq 1, P.eq 2, P.eq 3, P.eq 4]

Since: 0.2.1

A predicate checking if the input matches a tuple matching the given predicates. Works for tuples up to 6 elements.

>>> (1, 10, "hello world") `shouldSatisfy` P.tup (P.eq 1, P.gt 2, P.hasPrefix "hello ")

A predicate checking if the input matches the given constructor.

It takes one argument, which is the constructor, except with all fields taking a Predicate instead of the normal value. Skeletest will rewrite the expression so it typechecks correctly.

>>> User "user1" "user1@example.com" `shouldSatisfy` P.con User{name = P.eq "user1", email = P.contains "@"}

Record fields that are omitted are not checked at all; i.e. P.con Foo{} and P.con Foo{a = P.anything} are equivalent.

A predicate checking if the input is equal to the given value within some tolerance.

Useful for checking equality with floats, which might not be exactly equal. For more information, see: https://jvns.ca/blog/2023/01/13/examples-of-floating-point-problems/.

>>> (0.1 + 0.2) `shouldSatisfy` P.approx P.tol 0.3
>>> (0.1 + 0.2) `shouldSatisfy` P.approx P.tol{P.rel = Just 1e-6} 0.3
>>> (0.1 + 0.2) `shouldSatisfy` P.approx P.tol{P.abs = 1e-12} 0.3
>>> (0.1 + 0.2) `shouldSatisfy` P.approx P.tol{P.rel = Just 1e-6, P.abs = 1e-12} 0.3
>>> (0.1 + 0.2) `shouldSatisfy` P.approx P.tol{P.rel = Nothing} 0.3
>>> (0.1 + 0.2) `shouldSatisfy` P.approx P.tol{P.rel = Nothing, P.abs = 1e-12} 0.3

The default tolerance for approx.

The tolerance to use in approx.

An input satisfies a tolerance if it's within the relative tolerance (rel * input) or the absolute tolerance of the reference value.

A predicate checking if the input matches the given predicate, after applying the given function.

>>> "hello" `shouldSatisfy` (P.eq 5 P.<<< length)

Same as <<<, except with the arguments flipped.

>>> "hello" `shouldSatisfy` (length P.>>> P.eq 5)

A predicate checking if the input does not match the given predicate

>>> Just 2 `shouldSatisfy` P.just (P.not (P.eq 1))

A predicate checking if the input matches both of the given predicates

>>> 1 `shouldSatisfy` P.gt 0 P.&& P.lt 2

A predicate checking if the input matches one of the given predicates

>>> 1 `shouldSatisfy` P.lt 5 P.|| P.gt 10

A predicate checking if the input matches all of the given predicates

>>> 1 `shouldSatisfy` P.and [P.gt 0, P.lt 2]

A predicate checking if the input matches any of the given predicates

>>> 1 `shouldSatisfy` P.or [P.lt 5, P.gt 10]

A predicate checking if the input is a list-like type where some element matches the given predicate.

>>> [1, 2, 3] `shouldSatisfy` P.any (P.eq 1)

A predicate checking if the input is a list-like type where all elements match the given predicate.

>>> [1, 2, 3] `shouldSatisfy` P.all (P.gt 0)

A predicate checking if the input is a list-like type where the given element is present. Equivalent to P.any . P.eq.

>>> [1, 2, 3] `shouldSatisfy` P.elem 1

A predicate checking if the input has the given prefix

>>> [1, 2, 3] `shouldSatisfy` P.hasPrefix [1, 2]
>>> "hello world" `shouldSatisfy` P.hasPrefix "hello "

A predicate checking if the input contains the given subsequence

>>> [1, 2, 3] `shouldSatisfy` P.hasInfix [2]
>>> "hello world" `shouldSatisfy` P.hasInfix "ello"

A predicate checking if the input has the given suffix

>>> [1, 2, 3] `shouldSatisfy` P.hasSuffix [2, 3]
>>> "hello world" `shouldSatisfy` P.hasSuffix " world"

A predicate checking if the input is an IO action that returns a value matching the given predicate.

>>> pure 1 `shouldSatisfy` P.returns (P.eq 1)

A predicate checking if the input is an IO action that throws an exception matching the given predicate.

>>> throwIO MyException `shouldSatisfy` P.throws (P.eq MyException)

Verify if two functions are isomorphic.

prop "reverse . reverse === id" $ do
  let genList = Gen.list (Gen.linear 0 10) $ Gen.int (Gen.linear 0 1000)
  (reverse . reverse) P.=== id `shouldSatisfy` P.isoWith genList

See (===).

A predicate checking if the input matches the snapshot. See the "Snapshot tests" section in the README.

>>> user `shouldSatisfy` P.matchesSnapshot