Copyright | © 2016–2017 Mark Karpov |
---|---|
License | BSD 3 clause |
Maintainer | Mark Karpov <markkarpov92@gmail.com> |
Stability | experimental |
Portability | portable |
Safe Haskell | Safe |
Language | Haskell2010 |
This module provides a generalized approach to checking and verification of data. It's useful, for example, for validation of fields on web forms.
Typically, there are a number of transformations and checks you may want to perform on a particular type of data, such as text. Thus, it makes sense to create all those transformations and checks once and then combine them to get more complex validators that may vary on per-field basis.
Certainly, if we can normalize and validate, we should normalize first. However, if we have many normalizing operations, we need a way to specify in which order they should be performed, or result can be unpredictable.
To specify the order in which transformations are performed, normalizer
and normalizerM
functions take a “priority” argument, which is just a
Natural
number. The bigger the number, the later the function will be
applied, so the transformation with priority 0 will always run first.
This method applies to validators just as well. It's possible to create a vocabulary of validators that can be mixed together and the result will be always deterministic.
To support more real-world use cases, every check can be performed inside of a monad, allowing to query a database for example.
One last thing to note is that every normalizer and every validator should have a unique priority number. Normalizers (and validators) with the same priority will overwrite each other. This is by design. Note that normalizer won't override validator with the same priority though, their priority-spaces are separate.
- normalizer :: Monad m => Natural -> (a -> a) -> Checker m e a
- normalizerM :: Monad m => Natural -> (a -> m a) -> Checker m e a
- validator :: Monad m => Natural -> (a -> Maybe e) -> Checker m e a
- validatorM :: Monad m => Natural -> (a -> m (Maybe e)) -> Checker m e a
- data Checker m e a
- runChecker :: Checker Identity e a -> a -> Either e a
- runCheckerM :: Monad m => Checker m e a -> a -> m (Either e a)
Normalizers
:: Monad m | |
=> Natural | Priority |
-> (a -> a) | Normalizing transformation |
-> Checker m e a | Normalizing |
Create a normalizing Checker
. Every normalizer has a priority—the
bigger the number, the later the normalizer runs. Every normalizer you
use should have a unique priority number.
:: Monad m | |
=> Natural | Priority |
-> (a -> m a) | Normalizing transformation |
-> Checker m e a | Normalizing |
The same as normalizer
, but allows to perform normalization inside of
a monad.
Validators
:: Monad m | |
=> Natural | Priority |
-> (a -> Maybe e) |
|
-> Checker m e a | Validating |
Create a validating Checker
. Every validator has a priority—the
bigger the number, the later the validation step runs. Every validator
you use should have a unique priority number.
:: Monad m | |
=> Natural | Priority |
-> (a -> m (Maybe e)) |
|
-> Checker m e a | Validating |
The same as validator
, but allows to perform normalization inside of
a monad.
Checkers
Run a Checker
on given value. This is version for cases when all
transformations and validations are pure.
Version of runChecker
that can run transformations and checks in any
monad.