Types and functions to check properties of your data. To make best use of these functions you should check out Data.Functor.Contravariant. For an introduction see the README.

A newtype around unvalidated values so one cannot use the value until it is validated. You can create an Unvalidated via unvalidated

WARNING The Unvalidated data construcotr should NOT be used in real code and is exported solely to be used in -XDeriving-clauses

, but it is often more convient to write an orphan instance: If for example you have a JSON api and want to validate incoming data, you can write (using -XStandaloneDeriving, -XDerivingStrategies, -XDerivingVia):

import Data.Aeson(FromJSON)
deriving via (a :: Type) instance (FromJSON a) => FromJSON (Unvalidated a)

The result of (possibly many) checks. It is either valid or a sequence of all the errors that occurred during the check. The semigroup operation is eager to collect all possible erros.

The type of a (lifted) check. A Check takes an unvalidated data and produces a CheckResult. It may need an additional context m. If the context is trivial ('m ≡ Identity') helper types/functions are postfixed by an apostrophe `'`. A Check is not a validation function, as it does not produce any values (to validated data using a Check use validateBy). The reason for this is that it gives Check some useful instances, as it now is contravariant in a and not invariant in a like e.g. `a -> Either b a`

• Contravariant

newtype Even = Even { getEven :: Int }
checkEven :: Check' Text Even
checkEven = (== 0) . (`mod` 2) . getEven ?> mappend "Number is not even: " . show

newtype Odd = Odd { getOdd :: Int }
checkOdd :: Check' Text Odd
checkOdd = Even . (+1) . getOdd >$< checkEven

• Semigroup/Monoid: Allows for easy composition of checks

newtype EvenAndOdd = EvenAndOdd { getEvenAndOdd :: Int }
checkevenAndOdd :: Check' Text EvenAndOdd
checkEvenAndOdd = contramap (Even . getEvenAndOdd) checkEven
                  <> contramap (Odd . getEvenAndOdd) checkOdd

• MFunctor: Changing the effect

import Data.List(isPrefixOf)
newtype Url = Url { getUrl :: String }

check404 :: Check () IO Url -- checks if the url returns 404

checkHttps :: Check' () Identity Url
checkHttps = ("https" `isPrefixOf`) ?>> ()

checkUrl :: Check () IO Url
checkUrl = check404 <> hoist generalize checkHttps

For more information see the README.

The general way to construct a Check: Take the data to be checked and return a CheckResult.

Construction by predicates

Constructing a check from a predicate (if a prediceate returns True, the check passes) and a function constructing the error from the input. Naming conventions:

• Functions that work on trivial contexts are postfixed by an apostrophe `'`.
• Check constructors that discard the argument on error end with `_`.
• All infix operators start with ? and end with > (So ?> is the "normal" version).
• Additional >: discards its argument: ?>>, ?~>>.
• Tilde works with non-trivial contexts: ?~>, ?~>>.