Test.Syd.Validity

A Value is valid if the recursive components are valid.

A ByteString is NOT trivially valid.

The offset and the length both need to be positive. Note that the length does not need to be greater than, or equal to, the offset.

TODO there's nothing we can do about the foreign pointer, I think?

A lazy ByteString is valid according to its chunks.

Trivially valid

My guess is that short bytestrings are not trivially valid but there is no way to access the internals.

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

A Scientific is valid according to the validity of its coefficient and exponent.

A text is valid if the internal structure is consistent.

A lazy text value is valid if all the internal chunks are valid and nonempty

Trivially valid

Valid values the same as it's base type:

Valid values the same as it's base type:

A Tree of things is valid if all the things in the Tree are valid.

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 Vector of things is valid if all the elements are valid.

TODO make a more comprehensive instance that looks at implementation and the underlying Array

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

A IntMap of things is valid if all the keys and values are valid and the IntMap itself is valid.

A Sequence of things is valid if all the elements are valid.

A HashSet of things is valid if all the elements are valid and the underlying HashMap is valid.

A Set of things is valid if all the elements are valid and the Set itself is valid.

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

Valid according to the contained Integer.

A Map of things is valid if all the keys and values are valid and the Map itself is valid.

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

A HashMap of things is valid if all the keys and values are valid.

The 'unordered-containers' package does not export any more functionality concerning a HashMap, so no more accurate validity instance can be made.

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.

"String-Concatenation" for OsString. This is not the same as (</>).

Additive

Additive

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 = empty

mappend = union

O(n+m)

To obtain good performance, the smaller set must be presented as the first argument.

Examples

>>> mappend (fromList [1,2]) (fromList [2,3])fromList [1,2,3]

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

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

mempty = empty

mappend = union

If a key occurs in both maps, the mapping from the first will be the mapping in the result.

Examples

>>> mappend (fromList [(1,'a'),(2,'b')]) (fromList [(2,'c'),(3,'d')])fromList [(1,'a'),(2,'b'),(3,'d')]

The Monoid instance for ParsecT is used for the same purposes as the Semigroup instance.