Distribution.Compat.Semigroup

Collapse margins, any margin = margin

Any like semigroup, where ExecutablePrivate is 'Any True'

(<>) = union

Beware: stimes will crash if the given number does not fit into an Int.

Concatenation of StrictBuilder is right-biased: the right builder will be run first. This allows a builder to run tail-recursively when it was accumulated left-to-right.

Additive

Additive

ORs the flags.

ORs the masks.

(<>) 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

(<>) = union

(<>) = (><)

Composes left-to-right, short-circuits on False

Composes left-to-right, short-circuits on non-EQ

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

Note: there aren't Monoid instance.

(<>) = union

(<>) @(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

(<>) = union

The Semigroup instance for ParsecT is used to append the result of several parsers, for example:

(many $ char a) <> (many $ char b)

The above will parse a string like "aabbb" and return a successful parse result "aabbb". Compare against the below which will produce a result of "bbb" for the same input:

(many $ char a) >> (many $ char b)
(many $ char a) *> (many $ char b)

mempty = ExecutablePublic

This instance is not good.

We need it for PackageDescription.Configuration.addBuildableCondition. More correct method would be some kind of "create empty clone".

More concretely, addBuildableCondition will make `libVisibility = False` libraries when `buildable: false`. This may cause problems.

mempty = empty

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

mempty = empty

mempty = empty

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

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

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

mempty = empty

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