Build a rule that fails with given error if the given predicate succeeds.

failureIf predc = failureUnless (not . predc)

Examples

>>> runValidator (validate (failureIf (>0) "Positive")) 5
Failure ("Positive" :| [])
>>> runValidator (validate (failureIf (>0) "Positive")) 0
Success 0
>>> runValidator (validate (failureIf (>0) "Positive")) (-1)
Success (-1)

Build a rule that fails with given error unless the given predicate succeeds.

failureUnless predc = failureIf (not . predc)

Examples

>>> runValidator (validate (failureUnless (>0) "NonPositive")) 5
Success 5
>>> runValidator (validate (failureUnless (>0) "NonPositive")) 0
Failure ("NonPositive" :| [])
>>> runValidator (validate (failureUnless (>0) "NonPositive")) (-1)
Failure ("NonPositive" :| [])

Like failureIf but uses Unit as the ValidationRule error type.

failureIf' predc = failureUnless' (not . predc)

label (const (err :| [])) (failureIf' predc) = failureIf predc err

Examples

>>> runValidator (validate (failureIf' (>0))) 5
Failure ()
>>> runValidator (validate (failureIf' (>0))) 0
Success 0
>>> runValidator (validate (failureIf' (>0))) (-1)
Success (-1)

Like failureUnless but uses Unit as the ValidationRule error type.

failureUnless' predc = failureIf' (not . predc)

label (const (err :| [])) (failureUnless' predc) = failureUnless predc err

Examples

>>> runValidator (validate (failureUnless' (>0))) 5
Success 5
>>> runValidator (validate (failureUnless' (>0))) 0
Failure ()
>>> runValidator (validate (failureUnless' (>0))) (-1)
Failure ()

Build a rule that succeeds if given rule fails and vice versa.

Examples

>>> let rule = negateRule "NonPositive" (failureIf (>0) "Positive")
>>> runValidator (validate rule) 5
Success 5
>>> runValidator (validate rule) 0
Failure "NonPositive"
>>> runValidator (validate rule) (-1)
Failure "NonPositive"

Like negateRule but uses Unit as the ValidationRule error type.

Build a rule that only succeeds if both of the given rules succeed. The very first failure is yielded.

This is the same as the semigroup operation (i.e (<>)) on ValidationRule.

rule1 `andAlso` (rule2 `andAlso` rule3) = (rule1 `andAlso` rule2) `andAlso` rule3

mempty `andAlso` rule = rule

rule `andAlso` mempty = rule

Examples

>>> let rule = failureIf (>0) "Positive" `andAlso` failureIf even "Even"
>>> runValidator (validate rule) 5
Failure ("Positive" :| [])
>>> runValidator (validate rule) (-2)
Failure ("Even" :| [])
>>> runValidator (validate rule) (-1)
Success (-1)

A ValidationRule that always fails with supplied error. This is the identity of orElse (i.e (</>)).

falseRule `orElse` rule = rule

rule `orElse` falseRule = rule

Examples

>>> runValidator (validate falseRule) 42
Failure ()

Build a rule that succeeds if either of the given rules succeed. If both fail, the errors are combined.

rule1 `orElse` (rule2 `orElse` rule3) = (rule1 `orElse` rule2) `orElse` rule3

falseRule e `orElse` rule = rule

rule `orElse` falseRule e = rule

Examples

>>> let rule = failureIf (>0) "Positive" `orElse` failureIf even "Even"
>>> runValidator (validate rule) 5
Success 5
>>> runValidator (validate rule) 4
Failure ("Positive" :| ["Even"])
>>> runValidator (validate rule) 0
Success 0
>>> runValidator (validate rule) (-1)
Success (-1)

Build a rule that only succeeds if all of the given rules succeed. The very first failure is yielded.

satisfyAll = fold

satisfyAll = foldl1 andAlso

satisfyAll = foldr1 andAlso

satisfyAll = foldl andAlso mempty

satisfyAll = foldr andAlso mempty

Build a rule that succeeds if any of the given rules succeed. If all fail, the errors are combined.

satisfyAny = foldl1 orElse

satisfyAny = foldr1 orElse

satisfyAny = foldl orElse falseRule

satisfyAny = foldr orElse falseRule

A synonym for orElse. Satisfies associativity law and hence forms a semigroup.

Build an any rule.

atleastContains x = failureUnless (any x)

Build a minimum length (inclusive) rule.

lengthAbove x = minLengthOf (x + 1)

lengthAbove x = failureUnless ((>n) . length)

Build a maximum length (inclusive) rule.

lengthBelow x = maxLengthOf (x - 1)

lengthBelow x = failureUnless ((<n) . length)

Build an inRange rule for length.

lengthWithin (min, max) = minLengthOf min `andAlso` maxLengthOf max

lengthWithin r = failureUnless (inRange r . length)

Build a maximum length (inclusive) rule.

maxLengthOf n = failureUnless ((<=n) . length)

Build a maximum value (inclusive) rule.

maxValueOf x = failureUnless (<=x)

Build a minimum length (inclusive) rule.

minLengthOf x = failureUnless ((>=n) . length)

Build a minimum value (inclusive) rule.

minValueOf x = failureUnless (>=x)

Build an equality rule for value.

mustBe x = failureUnless (==x)

Build an elem rule.

mustContain x = atleastContains (==x)

mustContain x = failureUnless (elem x)

Build a maximum length rule.

notEmpty = minLengthOf 1

notEmpty = failureIf null

Build an equality rule for length.

ofLength x = failureUnless ((==x) . length)

Build an all rule.

onlyContains x = failureUnless (all x)

Build a minimum value (exclusive) rule.

valueAbove x = minValueOf (x + 1)

valueAbove x = failureUnless (>x)

Build a maximum value (exclusive) rule.

valueBelow x = minValueOf (x - 1)

valueBelow x = failureUnless (<x)

Build an inRange rule for value.

valueWithin (m, n) = minValueOf m `andAlso` maxValueOf n

valueWithin (m, n) = failureUnless (x -> m <= x && x <= n)

Like atleastContains but uses Unit as the ValidationRule error type.

Like lengthAbove but uses Unit as the ValidationRule error type.

Like lengthBelow but uses Unit as the ValidationRule error type.

Like lengthWithin but uses Unit as the ValidationRule error type.

Like maxLengthOf but uses Unit as the ValidationRule error type.

Like maxValueOf but uses Unit as the ValidationRule error type.

Like minLengthOf but uses Unit as the ValidationRule error type.

Like minValueOf but uses Unit as the ValidationRule error type.

Like mustBe but uses Unit as the ValidationRule error type.

Like mustContain but uses Unit as the ValidationRule error type.

Like notEmpty but uses Unit as the ValidationRule error type.

Like ofLength but uses Unit as the ValidationRule error type.

Like onlyContains but uses Unit as the ValidationRule error type.

Like valueAbove but uses Unit as the ValidationRule error type.

Like valueBelow but uses Unit as the ValidationRule error type.

Like valueWithin but uses Unit as the ValidationRule error type.

Build a rule that runs given rule only if input is Just.

Yields Success when input is Nothing.

Examples

>>> runValidator (validate (optionally (failureIf even "Even"))) (Just 5)
Success (Just 5)
>>> runValidator (validate (optionally (failureIf even "Even"))) (Just 6)
Failure ("Even" :| [])
>>> runValidator (validate (optionally (failureIf even "Even"))) Nothing
Success Nothing