Algebra

Documentation

class Semigroup a where

The class of semigroups (types with an associative binary operation).

Since: 4.9.0.0

Methods

(<>) :: a -> a -> a infixr 6

An associative operation.

(a <> b) <> c = a <> (b <> c)

If a is also a Monoid we further require

(<>) = mappend

sconcat :: NonEmpty a -> a

Reduce a non-empty list with <>

The default definition should be sufficient, but this can be overridden for efficiency.

stimes :: Integral b => b -> a -> a

Repeat a value n times.

Given that this works on a Semigroup it is allowed to fail if you request 0 or fewer repetitions, and the default definition will do so.

By making this a member of the class, idempotent semigroups and monoids can upgrade this to execute in O(1) by picking stimes = stimesIdempotent or stimes = stimesIdempotentMonoid respectively.

Instances

Semigroup Ordering

Methods

(<>) :: Ordering -> Ordering -> Ordering

sconcat :: NonEmpty Ordering -> Ordering

stimes :: Integral b => b -> Ordering -> Ordering

Semigroup ()

Methods

(<>) :: () -> () -> ()

sconcat :: NonEmpty () -> ()

stimes :: Integral b => b -> () -> ()

Semigroup Void

Methods

(<>) :: Void -> Void -> Void

sconcat :: NonEmpty Void -> Void

stimes :: Integral b => b -> Void -> Void

Semigroup All

Methods

(<>) :: All -> All -> All

sconcat :: NonEmpty All -> All

stimes :: Integral b => b -> All -> All

Semigroup Any

Methods

(<>) :: Any -> Any -> Any

sconcat :: NonEmpty Any -> Any

stimes :: Integral b => b -> Any -> Any

Semigroup [a]

Methods

(<>) :: [a] -> [a] -> [a]

sconcat :: NonEmpty [a] -> [a]

stimes :: Integral b => b -> [a] -> [a]

Semigroup a => Semigroup (Maybe a)

Methods

(<>) :: Maybe a -> Maybe a -> Maybe a

sconcat :: NonEmpty (Maybe a) -> Maybe a

stimes :: Integral b => b -> Maybe a -> Maybe a

Semigroup a => Semigroup (Identity a)

Methods

(<>) :: Identity a -> Identity a -> Identity a

sconcat :: NonEmpty (Identity a) -> Identity a

stimes :: Integral b => b -> Identity a -> Identity a

Ord a => Semigroup (Min a)

Methods

(<>) :: Min a -> Min a -> Min a

sconcat :: NonEmpty (Min a) -> Min a

stimes :: Integral b => b -> Min a -> Min a

Ord a => Semigroup (Max a)

Methods

(<>) :: Max a -> Max a -> Max a

sconcat :: NonEmpty (Max a) -> Max a

stimes :: Integral b => b -> Max a -> Max a

Semigroup (First a)

Methods

(<>) :: First a -> First a -> First a

sconcat :: NonEmpty (First a) -> First a

stimes :: Integral b => b -> First a -> First a

Semigroup (Last a)

Methods

(<>) :: Last a -> Last a -> Last a

sconcat :: NonEmpty (Last a) -> Last a

stimes :: Integral b => b -> Last a -> Last a

Monoid m => Semigroup (WrappedMonoid m)

Methods

(<>) :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m

sconcat :: NonEmpty (WrappedMonoid m) -> WrappedMonoid m

stimes :: Integral b => b -> WrappedMonoid m -> WrappedMonoid m

Semigroup a => Semigroup (Option a)

Methods

(<>) :: Option a -> Option a -> Option a

sconcat :: NonEmpty (Option a) -> Option a

stimes :: Integral b => b -> Option a -> Option a

Semigroup (NonEmpty a)

Methods

(<>) :: NonEmpty a -> NonEmpty a -> NonEmpty a

sconcat :: NonEmpty (NonEmpty a) -> NonEmpty a

stimes :: Integral b => b -> NonEmpty a -> NonEmpty a

Semigroup a => Semigroup (Dual a)

Methods

(<>) :: Dual a -> Dual a -> Dual a

sconcat :: NonEmpty (Dual a) -> Dual a

stimes :: Integral b => b -> Dual a -> Dual a

Semigroup (Endo a)

Methods

(<>) :: Endo a -> Endo a -> Endo a

sconcat :: NonEmpty (Endo a) -> Endo a

stimes :: Integral b => b -> Endo a -> Endo a

Num a => Semigroup (Sum a)

Methods

(<>) :: Sum a -> Sum a -> Sum a

sconcat :: NonEmpty (Sum a) -> Sum a

stimes :: Integral b => b -> Sum a -> Sum a

Num a => Semigroup (Product a)

Methods

(<>) :: Product a -> Product a -> Product a

sconcat :: NonEmpty (Product a) -> Product a

stimes :: Integral b => b -> Product a -> Product a

Semigroup (First a)

Methods

(<>) :: First a -> First a -> First a

sconcat :: NonEmpty (First a) -> First a

stimes :: Integral b => b -> First a -> First a

Semigroup (Last a)

Methods

(<>) :: Last a -> Last a -> Last a

sconcat :: NonEmpty (Last a) -> Last a

stimes :: Integral b => b -> Last a -> Last a

Semigroup b => Semigroup (a -> b)

Methods

(<>) :: (a -> b) -> (a -> b) -> a -> b

sconcat :: NonEmpty (a -> b) -> a -> b

stimes :: Integral b => b -> (a -> b) -> a -> b

Semigroup (Either a b)

Methods

(<>) :: Either a b -> Either a b -> Either a b

sconcat :: NonEmpty (Either a b) -> Either a b

stimes :: Integral b => b -> Either a b -> Either a b

(Semigroup a, Semigroup b) => Semigroup (a, b)

Methods

(<>) :: (a, b) -> (a, b) -> (a, b)

sconcat :: NonEmpty (a, b) -> (a, b)

stimes :: Integral b => b -> (a, b) -> (a, b)

Semigroup (Proxy k s)

Methods

(<>) :: Proxy k s -> Proxy k s -> Proxy k s

sconcat :: NonEmpty (Proxy k s) -> Proxy k s

stimes :: Integral b => b -> Proxy k s -> Proxy k s

(Semigroup a, Semigroup b, Semigroup c) => Semigroup (a, b, c)

Methods

(<>) :: (a, b, c) -> (a, b, c) -> (a, b, c)

sconcat :: NonEmpty (a, b, c) -> (a, b, c)

stimes :: Integral b => b -> (a, b, c) -> (a, b, c)

Semigroup a => Semigroup (Const k a b)

Methods

(<>) :: Const k a b -> Const k a b -> Const k a b

sconcat :: NonEmpty (Const k a b) -> Const k a b

stimes :: Integral b => b -> Const k a b -> Const k a b

Alternative f => Semigroup (Alt * f a)

Methods

(<>) :: Alt * f a -> Alt * f a -> Alt * f a

sconcat :: NonEmpty (Alt * f a) -> Alt * f a

stimes :: Integral b => b -> Alt * f a -> Alt * f a

(Semigroup a, Semigroup b, Semigroup c, Semigroup d) => Semigroup (a, b, c, d)

Methods

(<>) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)

sconcat :: NonEmpty (a, b, c, d) -> (a, b, c, d)

stimes :: Integral b => b -> (a, b, c, d) -> (a, b, c, d)

(Semigroup a, Semigroup b, Semigroup c, Semigroup d, Semigroup e) => Semigroup (a, b, c, d, e)

Methods

(<>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e)

sconcat :: NonEmpty (a, b, c, d, e) -> (a, b, c, d, e)

stimes :: Integral b => b -> (a, b, c, d, e) -> (a, b, c, d, e)

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

Instances

Monoid Ordering

Methods

mempty :: Ordering

mappend :: Ordering -> Ordering -> Ordering

mconcat :: [Ordering] -> Ordering

Monoid ()

Methods

mempty :: ()

mappend :: () -> () -> ()

mconcat :: [()] -> ()

Monoid All

Methods

mempty :: All

mappend :: All -> All -> All

mconcat :: [All] -> All

Monoid Any

Methods

mempty :: Any

mappend :: Any -> Any -> Any

mconcat :: [Any] -> Any

Monoid [a]

Methods

mempty :: [a]

mappend :: [a] -> [a] -> [a]

mconcat :: [[a]] -> [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 e*e = e and e*s = s = s*e for all s ∈ S." Since there is no "Semigroup" typeclass providing just mappend, we use Monoid instead.

Methods

mempty :: Maybe a

mappend :: Maybe a -> Maybe a -> Maybe a

mconcat :: [Maybe a] -> Maybe a

Monoid a => Monoid (IO a)

Methods

mempty :: IO a

mappend :: IO a -> IO a -> IO a

mconcat :: [IO a] -> IO a

Monoid a => Monoid (Identity a)

Methods

mempty :: Identity a

mappend :: Identity a -> Identity a -> Identity a

mconcat :: [Identity a] -> Identity a

(Ord a, Bounded a) => Monoid (Min a)

Methods

mempty :: Min a

mappend :: Min a -> Min a -> Min a

mconcat :: [Min a] -> Min a

(Ord a, Bounded a) => Monoid (Max a)

Methods

mempty :: Max a

mappend :: Max a -> Max a -> Max a

mconcat :: [Max a] -> Max a

Monoid m => Monoid (WrappedMonoid m)

Methods

mempty :: WrappedMonoid m

mappend :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m

mconcat :: [WrappedMonoid m] -> WrappedMonoid m

Semigroup a => Monoid (Option a)

Methods

mempty :: Option a

mappend :: Option a -> Option a -> Option a

mconcat :: [Option a] -> Option a

Monoid a => Monoid (Dual a)

Methods

mempty :: Dual a

mappend :: Dual a -> Dual a -> Dual a

mconcat :: [Dual a] -> Dual a

Monoid (Endo a)

Methods

mempty :: Endo a

mappend :: Endo a -> Endo a -> Endo a

mconcat :: [Endo a] -> Endo a

Num a => Monoid (Sum a)

Methods

mempty :: Sum a

mappend :: Sum a -> Sum a -> Sum a

mconcat :: [Sum a] -> Sum a

Num a => Monoid (Product a)

Methods

mempty :: Product a

mappend :: Product a -> Product a -> Product a

mconcat :: [Product a] -> Product a

Monoid (First a)

Methods

mempty :: First a

mappend :: First a -> First a -> First a

mconcat :: [First a] -> First a

Monoid (Last a)

Methods

mempty :: Last a

mappend :: Last a -> Last a -> Last a

mconcat :: [Last a] -> Last a

Monoid b => Monoid (a -> b)

Methods

mempty :: a -> b

mappend :: (a -> b) -> (a -> b) -> a -> b

mconcat :: [a -> b] -> a -> b

(Monoid a, Monoid b) => Monoid (a, b)

Methods

mempty :: (a, b)

mappend :: (a, b) -> (a, b) -> (a, b)

mconcat :: [(a, b)] -> (a, b)

Monoid (Proxy k s)

Methods

mempty :: Proxy k s

mappend :: Proxy k s -> Proxy k s -> Proxy k s

mconcat :: [Proxy k s] -> Proxy k s

(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c)

Methods

mempty :: (a, b, c)

mappend :: (a, b, c) -> (a, b, c) -> (a, b, c)

mconcat :: [(a, b, c)] -> (a, b, c)

Monoid a => Monoid (Const k a b)

Methods

mempty :: Const k a b

mappend :: Const k a b -> Const k a b -> Const k a b

mconcat :: [Const k a b] -> Const k a b

Alternative f => Monoid (Alt * f a)

Methods

mempty :: Alt * f a

mappend :: Alt * f a -> Alt * f a -> Alt * f a

mconcat :: [Alt * f a] -> Alt * f a

(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d)

Methods

mempty :: (a, b, c, d)

mappend :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)

mconcat :: [(a, b, c, d)] -> (a, b, c, d)

(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e)

Methods

mempty :: (a, b, c, d, e)

mappend :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e)

mconcat :: [(a, b, c, d, e)] -> (a, b, c, d, e)

class Monoid a => Group a where

Minimal complete definition

invert

Methods

invert :: a -> a

Instances

Group ()

Methods

invert :: () -> ()

Group a => Group (Identity a)

Methods

invert :: Identity a -> Identity a

Group a => Group (Dual a)

Methods

invert :: Dual a -> Dual a

Group (Sum Int)

Methods

invert :: Sum Int -> Sum Int

Group (Sum Integer)

Methods

invert :: Sum Integer -> Sum Integer

Group (Sum Word)

Methods

invert :: Sum Word -> Sum Word

Group b => Group (a -> b)

Methods

invert :: (a -> b) -> a -> b

(Group a, Group b) => Group (a, b)

Methods

invert :: (a, b) -> (a, b)

Group (Proxy k a)

Methods

invert :: Proxy k a -> Proxy k a

(Group a, Group b, Group c) => Group (a, b, c)

Methods

invert :: (a, b, c) -> (a, b, c)

Group a => Group (Const k a b)

Methods

invert :: Const k a b -> Const k a b

(Group a, Group b, Group c, Group d) => Group (a, b, c, d)

Methods

invert :: (a, b, c, d) -> (a, b, c, d)

(Group a, Group b, Group c, Group d, Group e) => Group (a, b, c, d, e)

Methods

invert :: (a, b, c, d, e) -> (a, b, c, d, e)

class Semigroup a => Abelian a

Instances

Abelian ()

Abelian All

Abelian Any

Abelian a => Abelian (Identity a)

Abelian (Min Int)

Abelian (Min Integer)

Abelian (Min Word)

Abelian (Min Natural)

Abelian (Max Int)

Abelian (Max Integer)

Abelian (Max Word)

Abelian (Max Natural)

Abelian a => Abelian (Dual a)

Abelian (Sum Int)

Abelian (Sum Integer)

Abelian (Sum Word)

Abelian (Sum Natural)

Abelian (Product Int)

Abelian (Product Integer)

Abelian (Product Word)

Abelian (Product Natural)

Abelian b => Abelian (a -> b)

(Abelian a, Abelian b) => Abelian (a, b)

Abelian (Proxy k a)

(Abelian a, Abelian b, Abelian c) => Abelian (a, b, c)

Abelian a => Abelian (Const k a b)

(Abelian a, Abelian b, Abelian c, Abelian d) => Abelian (a, b, c, d)

(Abelian a, Abelian b, Abelian c, Abelian d, Abelian e) => Abelian (a, b, c, d, e)

class Semigroup a => Idempotent a

Instances

Idempotent ()

Idempotent a => Idempotent (Identity a)

Ord a => Idempotent (Min a)

Ord a => Idempotent (Max a)

Idempotent a => Idempotent (Dual a)

Idempotent b => Idempotent (a -> b)

(Idempotent a, Idempotent b) => Idempotent (a, b)

Idempotent (Proxy k a)

(Idempotent a, Idempotent b, Idempotent c) => Idempotent (a, b, c)

Idempotent a => Idempotent (Const k a b)

(Idempotent a, Idempotent b, Idempotent c, Idempotent d) => Idempotent (a, b, c, d)

(Idempotent a, Idempotent b, Idempotent c, Idempotent d, Idempotent e) => Idempotent (a, b, c, d, e)

(+) :: Semigroup (Sum a) => a -> a -> a

(-) :: (Semigroup (Sum a), Group (Sum a)) => a -> a -> a

(*) :: Semigroup (Product a) => a -> a -> a

(/) :: (Semigroup (Product a), Group (Product a)) => a -> a -> a