Safe Haskell | Safe |
---|---|
Language | Haskell2010 |
- class Semigroup a where
- stimesMonoid :: (Integral b, Monoid a) => b -> a -> a
- stimesIdempotent :: Integral b => b -> a -> a
- stimesIdempotentMonoid :: (Integral b, Monoid a) => b -> a -> a
- mtimesDefault :: (Integral b, Monoid a) => b -> a -> a
- data Min a :: * -> *
- data Max a :: * -> *
- data First a :: * -> *
- data Last a :: * -> *
- data WrappedMonoid m :: * -> *
- class Monoid a where
- data Dual a :: * -> *
- data Endo a :: * -> *
- data All :: *
- data Any :: *
- data Sum a :: * -> *
- data Product a :: * -> *
- data Option a :: * -> *
- option :: b -> (a -> b) -> Option a -> b
- diff :: Semigroup m => m -> Endo m
- cycle1 :: Semigroup m => m -> m
- data WrappedMonoid m :: * -> *
- data Arg a b :: * -> * -> * = Arg a b
- type ArgMin a b = Min (Arg a b)
- type ArgMax a b = Max (Arg a b)
Documentation
The class of semigroups (types with an associative binary operation).
Since: 4.9.0.0
(<>) :: a -> a -> a infixr 6 #
An associative operation.
(a<>
b)<>
c = a<>
(b<>
c)
If a
is also a Monoid
we further require
(<>
) =mappend
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.
Semigroup Ordering | |
Semigroup () | |
Semigroup Void | |
Semigroup All | |
Semigroup Any | |
Semigroup [a] | |
Semigroup a => Semigroup (Maybe a) | |
Ord a => Semigroup (Min a) | |
Ord a => Semigroup (Max a) | |
Semigroup (First a) | |
Semigroup (Last a) | |
Monoid m => Semigroup (WrappedMonoid m) | |
Semigroup a => Semigroup (Option a) | |
Semigroup (NonEmpty a) | |
Semigroup a => Semigroup (Dual a) | |
Semigroup (Endo a) | |
Num a => Semigroup (Sum a) | |
Num a => Semigroup (Product a) | |
Semigroup (First a) | |
Semigroup (Last a) | |
Semigroup b => Semigroup (a -> b) | |
Semigroup (Either a b) | |
(Semigroup a, Semigroup b) => Semigroup (a, b) | |
Semigroup (Proxy k s) | |
(Semigroup a, Semigroup b, Semigroup c) => Semigroup (a, b, c) | |
Semigroup a => Semigroup (Const k a b) | |
Alternative f => Semigroup (Alt * f a) | |
(Semigroup a, Semigroup b, Semigroup c, Semigroup d) => Semigroup (a, b, c, d) | |
(Semigroup a, Semigroup b, Semigroup c, Semigroup d, Semigroup e) => Semigroup (a, b, c, d, e) | |
stimesMonoid :: (Integral b, Monoid a) => b -> a -> a #
stimesIdempotent :: Integral b => b -> a -> a #
stimesIdempotentMonoid :: (Integral b, Monoid a) => b -> a -> a #
mtimesDefault :: (Integral b, Monoid a) => b -> a -> a #
Monad Min | |
Functor Min | |
MonadFix Min | |
Applicative Min | |
Foldable Min | |
Traversable Min | |
Generic1 Min | |
Bounded a => Bounded (Min a) | |
Enum a => Enum (Min a) | |
Eq a => Eq (Min a) | |
Data a => Data (Min a) | |
Num a => Num (Min a) | |
Ord a => Ord (Min a) | |
Read a => Read (Min a) | |
Show a => Show (Min a) | |
Generic (Min a) | |
Ord a => Semigroup (Min a) | |
(Ord a, Bounded a) => Monoid (Min a) | |
type Rep1 Min | |
type Rep (Min a) | |
Monad Max | |
Functor Max | |
MonadFix Max | |
Applicative Max | |
Foldable Max | |
Traversable Max | |
Generic1 Max | |
Bounded a => Bounded (Max a) | |
Enum a => Enum (Max a) | |
Eq a => Eq (Max a) | |
Data a => Data (Max a) | |
Num a => Num (Max a) | |
Ord a => Ord (Max a) | |
Read a => Read (Max a) | |
Show a => Show (Max a) | |
Generic (Max a) | |
Ord a => Semigroup (Max a) | |
(Ord a, Bounded a) => Monoid (Max a) | |
type Rep1 Max | |
type Rep (Max a) | |
Use
to get the behavior of
Option
(First
a)First
from Data.Monoid.
Monad First | |
Functor First | |
MonadFix First | |
Applicative First | |
Foldable First | |
Traversable First | |
Generic1 First | |
Bounded a => Bounded (First a) | |
Enum a => Enum (First a) | |
Eq a => Eq (First a) | |
Data a => Data (First a) | |
Ord a => Ord (First a) | |
Read a => Read (First a) | |
Show a => Show (First a) | |
Generic (First a) | |
Semigroup (First a) | |
type Rep1 First | |
type Rep (First a) | |
Use
to get the behavior of
Option
(Last
a)Last
from Data.Monoid
Monad Last | |
Functor Last | |
MonadFix Last | |
Applicative Last | |
Foldable Last | |
Traversable Last | |
Generic1 Last | |
Bounded a => Bounded (Last a) | |
Enum a => Enum (Last a) | |
Eq a => Eq (Last a) | |
Data a => Data (Last a) | |
Ord a => Ord (Last a) | |
Read a => Read (Last a) | |
Show a => Show (Last a) | |
Generic (Last a) | |
Semigroup (Last a) | |
type Rep1 Last | |
type Rep (Last a) | |
data WrappedMonoid m :: * -> * #
Provide a Semigroup for an arbitrary Monoid.
Generic1 WrappedMonoid | |
Bounded a => Bounded (WrappedMonoid a) | |
Enum a => Enum (WrappedMonoid a) | |
Eq m => Eq (WrappedMonoid m) | |
Data m => Data (WrappedMonoid m) | |
Ord m => Ord (WrappedMonoid m) | |
Read m => Read (WrappedMonoid m) | |
Show m => Show (WrappedMonoid m) | |
Generic (WrappedMonoid m) | |
Monoid m => Semigroup (WrappedMonoid m) | |
Monoid m => Monoid (WrappedMonoid m) | |
type Rep1 WrappedMonoid | |
type Rep (WrappedMonoid m) | |
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 newtype
s and make those instances
of Monoid
, e.g. Sum
and Product
.
Monoid Ordering | |
Monoid () | |
Monoid All | |
Monoid Any | |
Monoid [a] | |
Monoid a => Monoid (Maybe a) | Lift a semigroup into |
Monoid a => Monoid (IO a) | |
Ord a => Monoid (Max a) | |
Ord a => Monoid (Min a) | |
(Ord a, Bounded a) => Monoid (Min a) | |
(Ord a, Bounded a) => Monoid (Max a) | |
Monoid m => Monoid (WrappedMonoid m) | |
Semigroup a => Monoid (Option 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 b => Monoid (a -> b) | |
(Monoid a, Monoid b) => Monoid (a, b) | |
Monoid (Proxy k s) | |
(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c) | |
Monoid a => Monoid (Const k a b) | |
Alternative f => Monoid (Alt * f a) | |
(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) | |
Monad Dual | |
Functor Dual | |
Applicative Dual | |
Foldable Dual | |
Traversable Dual | |
Generic1 Dual | |
Bounded a => Bounded (Dual a) | |
Eq a => Eq (Dual a) | |
Ord a => Ord (Dual a) | |
Read a => Read (Dual a) | |
Show a => Show (Dual a) | |
Generic (Dual a) | |
Semigroup a => Semigroup (Dual a) | |
Monoid a => Monoid (Dual a) | |
type Rep1 Dual | |
type Rep (Dual a) | |
The monoid of endomorphisms under composition.
Boolean monoid under conjunction (&&
).
Boolean monoid under disjunction (||
).
Monoid under addition.
Monad Sum | |
Functor Sum | |
Applicative Sum | |
Foldable Sum | |
Traversable Sum | |
Generic1 Sum | |
Bounded a => Bounded (Sum a) | |
Eq a => Eq (Sum a) | |
Num a => Num (Sum a) | |
Ord a => Ord (Sum a) | |
Read a => Read (Sum a) | |
Show a => Show (Sum a) | |
Generic (Sum a) | |
Num a => Semigroup (Sum a) | |
Num a => Monoid (Sum a) | |
type Rep1 Sum | |
type Rep (Sum a) | |
Monoid under multiplication.
Monad Product | |
Functor Product | |
Applicative Product | |
Foldable Product | |
Traversable Product | |
Generic1 Product | |
Bounded a => Bounded (Product a) | |
Eq a => Eq (Product a) | |
Num a => Num (Product a) | |
Ord a => Ord (Product a) | |
Read a => Read (Product a) | |
Show a => Show (Product a) | |
Generic (Product a) | |
Num a => Semigroup (Product a) | |
Num a => Monoid (Product a) | |
type Rep1 Product | |
type Rep (Product a) | |
Option
is effectively Maybe
with a better instance of
Monoid
, built off of an underlying Semigroup
instead of an
underlying Monoid
.
Ideally, this type would not exist at all and we would just fix the
Monoid
instance of Maybe
Monad Option | |
Functor Option | |
MonadFix Option | |
Applicative Option | |
Foldable Option | |
Traversable Option | |
Generic1 Option | |
Alternative Option | |
MonadPlus Option | |
Eq a => Eq (Option a) | |
Data a => Data (Option a) | |
Ord a => Ord (Option a) | |
Read a => Read (Option a) | |
Show a => Show (Option a) | |
Generic (Option a) | |
Semigroup a => Semigroup (Option a) | |
Semigroup a => Monoid (Option a) | |
type Rep1 Option | |
type Rep (Option a) | |
data WrappedMonoid m :: * -> * #
Provide a Semigroup for an arbitrary Monoid.
Generic1 WrappedMonoid | |
Bounded a => Bounded (WrappedMonoid a) | |
Enum a => Enum (WrappedMonoid a) | |
Eq m => Eq (WrappedMonoid m) | |
Data m => Data (WrappedMonoid m) | |
Ord m => Ord (WrappedMonoid m) | |
Read m => Read (WrappedMonoid m) | |
Show m => Show (WrappedMonoid m) | |
Generic (WrappedMonoid m) | |
Monoid m => Semigroup (WrappedMonoid m) | |
Monoid m => Monoid (WrappedMonoid m) | |
type Rep1 WrappedMonoid | |
type Rep (WrappedMonoid m) | |