Maintainer	bastiaan.heeren@ou.nl
Stability	provisional
Portability	portable (depends on ghc)
Safe Haskell	None
Language	Haskell98

Ideas.Common.Algebra.Group

Contents

Monoids
Groups
Monoids with a zero element
CoMonoid, CoGroup, and CoMonoidZero (for matching)

Description

Synopsis

Monoids

class Monoid a where

The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following laws:

```
mappend mempty x = x
```
```
mappend x mempty = x
```

mappend x (mappend y z) = mappend (mappend x y) z

```
mconcat = foldr mappend mempty
```

The method names refer to the monoid of lists under concatenation, but there are many other instances.

Some types can be viewed as a monoid in more than one way, e.g. both addition and multiplication on numbers. In such cases we often define newtypes and make those instances of Monoid, e.g. Sum and Product.

Minimal complete definition

mempty, mappend

Methods

mempty :: a

Identity of mappend

mappend :: a -> a -> a

An associative operation

mconcat :: [a] -> a

Fold a list using the monoid. For most types, the default definition for mconcat will be used, but the function is included in the class definition so that an optimized version can be provided for specific types.

Instances

Monoid Ordering
Monoid ()
Monoid All
Monoid Any
Monoid ByteString
Monoid ByteString
Monoid IntSet
Monoid Doc
Monoid XMLBuilder
Monoid Rating
Monoid Status
Monoid Message
Monoid Result
Monoid TestSuite
Monoid Location
Monoid Id
Monoid Environment
Monoid Substitution
Monoid StrategyCfg
Monoid Text
Monoid Script
Monoid DomainReasoner
Monoid [a]
Ord a => Monoid (Max a)
Ord a => Monoid (Min a)
Monoid a => Monoid (Dual a)
Monoid (Endo a)
Num a => Monoid (Sum a)
Num a => Monoid (Product a)
Monoid (First a)
Monoid (Last a)
Monoid a => Monoid (Maybe a)	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 `ee = e` and `es = s = s*e` for all `s ∈ S`." Since there is no "Semigroup" typeclass providing just `mappend`, we use `Monoid` instead.
Monoid (IntMap a)
Ord a => Monoid (Set a)
Monoid (Seq a)
Monoid (ArbGen a)
Monoid (Recognizer a)
Monoid (Prefix a)
Monoid (Option a)
Monoid a => Monoid (WithZero a)
SemiRing a => Monoid (Multiplicative a)
SemiRing a => Monoid (Additive a)
Boolean a => Monoid (Or a)
Boolean a => Monoid (And a)
(CoGroup a, Group a) => Monoid (SmartGroup a)
(CoMonoidZero a, MonoidZero a) => Monoid (SmartZero a)
(CoMonoid a, Monoid a) => Monoid (Smart a)
Monoid b => Monoid (a -> b)
(Monoid a, Monoid b) => Monoid (a, b)
Monoid a => Monoid (Const a b)
Monoid (Proxy k s)
Ord k => Monoid (Map k v)
Monoid (Trans a b)
(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c)
Alternative f => Monoid (Alt * f a)
Monoid t => Monoid (Encoder a s t)
(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d)
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e)

(<>) :: Monoid m => m -> m -> m infixr 6

An infix synonym for mappend.

Since: 4.5.0.0

Groups

class Monoid a => Group a where Source

Minimal complete definition: inverse or appendInverse

Minimal complete definition

Nothing

Methods

inverse :: a -> a Source

appendInv :: a -> a -> a Source

Instances

Field a => Group (Multiplicative a) Source
Ring a => Group (Additive a) Source
(CoGroup a, Group a) => Group (SmartGroup a) Source

(<>-) :: Group a => a -> a -> a infixl 6 Source

Monoids with a zero element

class Monoid a => MonoidZero a where Source

Methods

mzero :: a Source

Instances

Monoid a => MonoidZero (WithZero a) Source
SemiRing a => MonoidZero (Multiplicative a) Source
Boolean a => MonoidZero (Or a) Source
Boolean a => MonoidZero (And a) Source
(CoGroup a, MonoidZero a, Group a) => MonoidZero (SmartGroup a) Source
(CoMonoidZero a, MonoidZero a) => MonoidZero (SmartZero a) Source
(CoMonoid a, MonoidZero a) => MonoidZero (Smart a) Source

data WithZero a Source

Instances

Functor WithZero Source
Applicative WithZero Source
Foldable WithZero Source
Traversable WithZero Source
Eq a => Eq (WithZero a) Source
Ord a => Ord (WithZero a) Source
Monoid a => Monoid (WithZero a) Source
CoMonoid a => CoMonoidZero (WithZero a) Source
CoMonoid a => CoMonoid (WithZero a) Source
Monoid a => MonoidZero (WithZero a) Source

fromWithZero :: WithZero a -> Maybe a Source

CoMonoid, CoGroup, and CoMonoidZero (for matching)

class CoMonoid a where Source

Methods

isEmpty :: a -> Bool Source

isAppend :: a -> Maybe (a, a) Source

Instances

CoMonoid [a] Source
CoMonoid (Set a) Source
CoMonoid a => CoMonoid (WithZero a) Source
CoSemiRing a => CoMonoid (Multiplicative a) Source
CoSemiRing a => CoMonoid (Additive a) Source
CoBoolean a => CoMonoid (Or a) Source
CoBoolean a => CoMonoid (And a) Source
CoMonoid a => CoMonoid (SmartGroup a) Source
CoMonoid a => CoMonoid (SmartZero a) Source
CoMonoid a => CoMonoid (Smart a) Source

class CoMonoid a => CoGroup a where Source

Minimal complete definition

isInverse

Methods

isInverse :: a -> Maybe a Source

isAppendInv :: a -> Maybe (a, a) Source

Instances

CoField a => CoGroup (Multiplicative a) Source
CoRing a => CoGroup (Additive a) Source
CoGroup a => CoGroup (SmartGroup a) Source

class CoMonoid a => CoMonoidZero a where Source

Methods

isMonoidZero :: a -> Bool Source

Instances

CoMonoid a => CoMonoidZero (WithZero a) Source
CoSemiRing a => CoMonoidZero (Multiplicative a) Source
CoBoolean a => CoMonoidZero (Or a) Source
CoBoolean a => CoMonoidZero (And a) Source
CoMonoidZero a => CoMonoidZero (SmartGroup a) Source
CoMonoidZero a => CoMonoidZero (SmartZero a) Source
CoMonoidZero a => CoMonoidZero (Smart a) Source

associativeList :: CoMonoid a => a -> [a] Source