Safe Haskell	Safe

Eta.Classes.Monoid

Description

The Monoid type class defines that a type can have an append operation which can be used to append two things of the same type

The List, and String types are examples of instances of Monoid.

Mnemonic: Appendable

Synopsis

Documentation

class Monoid a where #

Minimal complete definition

mempty, mappend

Methods

mempty :: a #

mappend :: a -> a -> a #

mconcat :: [a] -> a #

Instances

Monoid Ordering
Methods mempty :: Ordering # mappend :: Ordering -> Ordering -> Ordering # mconcat :: [Ordering] -> Ordering #
Monoid ()
Methods mempty :: () # mappend :: () -> () -> () # mconcat :: [()] -> () #
Monoid Any
Methods mempty :: Any # mappend :: Any -> Any -> Any # mconcat :: [Any] -> Any #
Monoid All
Methods mempty :: All # mappend :: All -> All -> All # mconcat :: [All] -> All #
Monoid [a]
Methods mempty :: [a] # mappend :: [a] -> [a] -> [a] # mconcat :: [[a]] -> [a] #
Monoid a => Monoid (Maybe a)
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 #
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 (Last a)
Methods mempty :: Last a # mappend :: Last a -> Last a -> Last a # mconcat :: [Last a] -> Last a #
Monoid (First a)
Methods mempty :: First a # mappend :: First a -> First a -> First a # mconcat :: [First a] -> First a #
Monoid (Endo a)
Methods mempty :: Endo a # mappend :: Endo a -> Endo a -> Endo a # mconcat :: [Endo a] -> Endo a #
Monoid a => Monoid (Dual a)
Methods mempty :: Dual a # mappend :: Dual a -> Dual a -> Dual a # mconcat :: [Dual a] -> Dual a #
Ord a => Monoid (Min a)
Methods mempty :: Min a # mappend :: Min a -> Min a -> Min a # mconcat :: [Min a] -> Min a #
Ord a => Monoid (Max a)
Methods mempty :: Max a # mappend :: Max a -> Max a -> Max a # mconcat :: [Max a] -> Max 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) #
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) #

append :: Monoid a => a -> a -> a #

Appends two values.

>>> append "Hello " "world!"
"Hello world!"

neutral :: Monoid a => a #

A Monoid also requires that the type has a neutral element that does not affect concatenation.

$ >>> import Prelude (String, Int)

>>> neutral :: String
""

>>> neutral :: [Int]
[]

concat :: Monoid a => [a] -> a #

You can reduce a list of elements that implement the Monoid type class by using concat

>>> import Prelude ()
>>> concat ["Hello ", "world", "!"]
"Hello world!"

(<+>) :: Monoid a => a -> a -> a #

Operator for the append operation

>>> "Hello " <+> "world!"
"Hello world!"