Data.Validity

Trivially valid

Integer is not trivially valid under the hood, but instantiating Validity correctly would force validity to depend on a specific (big integer library integer-gmp versus integer-simple). This is rather impractical so for the time being we have opted for assuming that an Integer is always valid. Even though this is not technically sound, it is good enough for now.

Valid according to isValidNatural

Trivially valid

Trivially valid

Trivially valid

Trivially valid

Trivially valid:

Trivially valid:

Trivially valid

Trivially valid

Trivially valid

Trivially valid

Valid values the same as it's base type:

Valid values the same as it's base type:

A nonempty list is valid if all the elements are valid.

See the instance for 'Validity [a]' for more information.

Valid values the same as it's base type:

Valid values the same as it's base type:

Valid values the same as it's base type:

Valid values the same as it's base type:

A Maybe thing is valid if the thing inside is valid or it's nothing It makes sense to assume that Nothing is valid. If Nothing wasn't valid, you wouldn't have used a Maybe in the datastructure.

A list of things is valid if all of the things are valid.

This means that the empty list is considered valid. If the empty list should not be considered valid as part of your custom data type, make sure to write a custom Validity instance

Valid if the contained numbers are valid and the denominator is strictly positive.

Valid according to the contained Integer.

Any Either of things is valid if the contents are valid in either of the cases.

Any tuple of things is valid if both of its elements are valid

Valid values the same as it's base type:

Valid values the same as it's base type:

Any triple of things is valid if all three of its elements are valid

Any quadruple of things is valid if all four of its elements are valid

Any quintuple of things is valid if all five of its elements are valid

Any sextuple of things is valid if all six of its elements are valid

mappend takes the longer of two lifetimes.

mempty on comparisons always returns EQ. Without newtypes this equals pure (pure EQ).

mempty :: Comparison a
mempty = Comparison _ _ -> EQ

mempty on equivalences always returns True. Without newtypes this equals pure (pure True).

mempty :: Equivalence a
mempty = Equivalence _ _ -> True

mempty on predicates always returns True. Without newtypes this equals pure True.

mempty :: Predicate a
mempty = _ -> True

Lift a semigroup into Maybe forming a Monoid according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup S may be turned into a monoid simply by adjoining an element e not in S and defining e*e = e and e*s = s = s*e for all s ∈ S."

Since 4.11.0: constraint on inner a value generalised from Monoid to Semigroup.

This constraint is arguably too strong. However, as some types (such as Natural) have undefined complement, this is the only safe choice.

This constraint is arguably too strong. However, as some types (such as Natural) have undefined complement, this is the only safe choice.

mempty @(Op a b) without newtypes is mempty @(b->a) = _ -> mempty.

mempty :: Op a b
mempty = Op _ -> mempty

(<>) on comparisons combines results with (<>) @Ordering. Without newtypes this equals liftA2 (liftA2 (<>)).

(<>) :: Comparison a -> Comparison a -> Comparison a
Comparison cmp <> Comparison cmp' = Comparison a a' ->
  cmp a a' <> cmp a a'

(<>) on equivalences uses logical conjunction (&&) on the results. Without newtypes this equals liftA2 (liftA2 (&&)).

(<>) :: Equivalence a -> Equivalence a -> Equivalence a
Equivalence equiv <> Equivalence equiv' = Equivalence a b ->
  equiv a b && equiv' a b

(<>) on predicates uses logical conjunction (&&) on the results. Without newtypes this equals liftA2 (&&).

(<>) :: Predicate a -> Predicate a -> Predicate a
Predicate pred <> Predicate pred' = Predicate a ->
  pred a && pred' a

This constraint is arguably too strong. However, as some types (such as Natural) have undefined complement, this is the only safe choice.

(<>) @(Op a b) without newtypes is (<>) @(b->a) = liftA2 (<>). This lifts the Semigroup operation (<>) over the output of a.

(<>) :: Op a b -> Op a b -> Op a b
Op f <> Op g = Op a -> f a <> g a