Copyright | (c) Artem Chirkin |
---|---|
License | BSD3 |
Maintainer | chirkin@arch.ethz.ch |
Safe Haskell | None |
Language | Haskell2010 |
Re-export most of Data.Semigroup with a few changes and new definitions.
The main initiative behind this module is to provide more strict
alternatives to widely used semigroups.
For example, Option
has lazy (<>)
implementation,
which causes memory leaks in large foldMaps.
- 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
- foldMap' :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
- newtype Min a :: * -> * = Min {
- getMin :: a
- newtype Max a :: * -> * = Max {
- getMax :: a
- newtype First a :: * -> * = First {
- getFirst :: a
- newtype Last a :: * -> * = Last {
- getLast :: a
- newtype WrappedMonoid m :: * -> * = WrapMonoid {
- unwrapMonoid :: m
- class Monoid a where
- newtype Dual a :: * -> * = Dual {
- getDual :: a
- newtype Endo a :: * -> * = Endo {
- appEndo :: a -> a
- newtype All :: * = All {}
- newtype Any :: * = Any {}
- newtype Sum a :: * -> * = Sum {
- getSum :: a
- newtype Product a :: * -> * = Product {
- getProduct :: a
- newtype Option a = Option {}
- option :: b -> (a -> b) -> Option a -> b
- fromOption :: a -> Option a -> a
- toOption :: a -> Option a
- diff :: Semigroup m => m -> Endo m
- cycle1 :: Semigroup m => m -> m
- data Arg a b :: * -> * -> * = Arg a b
- type ArgMin a b = Min (Arg a b)
- type ArgMax a b = Max (Arg a b)
- data MinMax a = MinMax a a
- minMax :: a -> MinMax a
- mmDiff :: Num a => MinMax a -> a
- mmAvg :: Fractional a => MinMax a -> a
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.
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 #
foldMap' :: (Foldable t, Monoid m) => (a -> m) -> t a -> m Source #
Map each element of the structure to a monoid, and combine the results.
This function differs from Data.Foldable.foldMap
in that uses foldl'
instead of foldr
inside.
This makes this function suitable for Monoids with strict mappend
operation.
For example,
foldMap' Sum $ take 1000000000 ([1..] :: [Int])
runs in constant memory, whereas normal foldMap
would cause a memory leak there.
Semigroups
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) | |
newtype WrappedMonoid m :: * -> * #
Provide a Semigroup for an arbitrary Monoid.
WrapMonoid | |
|
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) | |
Re-exported monoids from Data.Monoid
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
.
Identity of mappend
An associative operation
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.
Monoid Ordering | |
Monoid () | |
Monoid All | |
Monoid Any | |
Monoid T0 # | |
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) | |
(Ord a, Bounded a) => Monoid (MinMax a) # | |
Semigroup a => Monoid (Option a) # | |
Monoid a => Monoid (T1 a) # | |
Monoid b => Monoid (a -> b) | |
(Monoid a, Monoid b) => Monoid (a, b) | |
Monoid (Proxy k s) | |
(Monoid a, Monoid b) => Monoid (T2 a b) # | |
(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 (T3 a b c) # | |
(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d) | |
(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (T4 a b c d) # | |
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e) | |
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (T5 a b c d e) # | |
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e, Monoid f) => Monoid (T6 a b c d e f) # | |
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e, Monoid f, Monoid g) => Monoid (T7 a b c d e f g) # | |
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e, Monoid f, Monoid g, Monoid h) => Monoid (T8 a b c d e f g h) # | |
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e, Monoid f, Monoid g, Monoid h, Monoid i) => Monoid (T9 a b c d e f g h i) # | |
Monad Dual | |
Functor Dual | |
MonadFix Dual | |
Applicative Dual | |
Foldable Dual | |
Traversable Dual | |
Generic1 Dual | |
Bounded a => Bounded (Dual a) | |
Eq a => Eq (Dual a) | |
Data a => Data (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 | |
MonadFix Sum | |
Applicative Sum | |
Foldable Sum | |
Traversable Sum | |
Generic1 Sum | |
Bounded a => Bounded (Sum a) | |
Eq a => Eq (Sum a) | |
Data a => Data (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.
Product | |
|
Monad Product | |
Functor Product | |
MonadFix Product | |
Applicative Product | |
Foldable Product | |
Traversable Product | |
Generic1 Product | |
Bounded a => Bounded (Product a) | |
Eq a => Eq (Product a) | |
Data a => Data (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) | |
A better monoid for Maybe
Option
is effectively Maybe
with a better instance of
Monoid
, built off of an underlying Semigroup
instead of an
underlying Monoid
.
This version of Option
data type is more strict than the one from
Data.Semigroup.
Monad Option Source # | |
Functor Option Source # | |
MonadFix Option Source # | |
Applicative Option Source # | |
Foldable Option Source # | |
Traversable Option Source # | |
Generic1 Option Source # | |
Alternative Option Source # | |
Eq a => Eq (Option a) Source # | |
Data a => Data (Option a) Source # | |
Ord a => Ord (Option a) Source # | |
Read a => Read (Option a) Source # | |
Show a => Show (Option a) Source # | |
Generic (Option a) Source # | |
Semigroup a => Semigroup (Option a) Source # | |
Semigroup a => Monoid (Option a) Source # | |
type Rep1 Option Source # | |
type Rep (Option a) Source # | |
fromOption :: a -> Option a -> a Source #
Get value from Option
with default value.
Eagerly evaluates the value before returning!
toOption :: a -> Option a Source #
Wrap a value into Option
container.
Eagerly evaluates the value before wrapping!
Difference lists of a semigroup
ArgMin, ArgMax
Arg
isn't itself a Semigroup
in its own right, but it can be
placed inside Min
and Max
to compute an arg min or arg max.
Arg a b |
Evaluate minimum and maximum at the same time. Arithmetics and semigroup operations are eager, functorial operations are lazy.
This data type is especially useful for calculating bounds
of foldable containers with numeric data using foldMap minMax
.
MinMax a a |
Monad MinMax Source # | |
Functor MinMax Source # | |
MonadFix MinMax Source # | |
Applicative MinMax Source # | |
Generic1 MinMax Source # | |
Bounded a => Bounded (MinMax a) Source # | |
Eq a => Eq (MinMax a) Source # | |
Data a => Data (MinMax a) Source # | |
(Num a, Ord a) => Num (MinMax a) Source # | |
Ord a => Ord (MinMax a) Source # | MinMax checks whether bounds overlap.
|
Read a => Read (MinMax a) Source # | |
Show a => Show (MinMax a) Source # | |
Generic (MinMax a) Source # | |
Ord a => Semigroup (MinMax a) Source # | |
(Ord a, Bounded a) => Monoid (MinMax a) Source # | |
type Rep1 MinMax Source # | |
type Rep (MinMax a) Source # | |
mmAvg :: Fractional a => MinMax a -> a Source #