Algebra.Monoid

Will be used in order to generate type classes for generic algebras. An algebra is a vector space that also is a monoid. Should we use the Monoid class from base library despite its unfortunate method name mappend?

Documentation

class C a where

We expect a monoid to adher to associativity and the identity behaving decently. Nothing more, really.

Minimal complete definition

idt, (<*>)

Methods

idt :: a

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

cumulate :: [a] -> a

Instances

C All

Methods

idt :: All

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

cumulate :: [All] -> All

C Any

Methods

idt :: Any

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

cumulate :: [Any] -> Any

C T

Methods

idt :: T

(<*>) :: T -> T -> T

cumulate :: [T] -> T

C a => C (Dual a)

Methods

idt :: Dual a

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

cumulate :: [Dual a] -> Dual a

C (Endo a)

Methods

idt :: Endo a

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

cumulate :: [Endo a] -> Endo a

C a => C (Sum a)

Methods

idt :: Sum a

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

cumulate :: [Sum a] -> Sum a

C a => C (Product a)

Methods

idt :: Product a

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

cumulate :: [Product a] -> Product a

C (First a)

Methods

idt :: First a

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

cumulate :: [First a] -> First a

C (Last a)

Methods

idt :: Last a

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

cumulate :: [Last a] -> Last a

Ord a => C (Max a)

Methods

idt :: Max a

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

cumulate :: [Max a] -> Max a

Ord a => C (Min a)

Methods

idt :: Min a

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

cumulate :: [Min a] -> Min a

C a => C (LCM a)

Methods

idt :: LCM a

(<*>) :: LCM a -> LCM a -> LCM a

cumulate :: [LCM a] -> LCM a

C a => C (GCD a)

Methods

idt :: GCD a

(<*>) :: GCD a -> GCD a -> GCD a

cumulate :: [GCD a] -> GCD a

C a => C (T a)

Methods

idt :: T a

(<*>) :: T a -> T a -> T a

cumulate :: [T a] -> T a

Ix i => C (T i)

Methods

idt :: T i

(<*>) :: T i -> T i -> T i

cumulate :: [T i] -> T i