Data.Semigroup

semigroups-0.9.2: Haskell 98 semigroups

Copyright | (C) 2011 Edward Kmett
License | BSD-style (see the file LICENSE)
Maintainer | Edward Kmett <ekmett@gmail.com>
Stability | provisional
Portability | portable
Safe Haskell | Safe
Language | Haskell98

Data.Semigroup

Contents

- Semigroups
- Re-exported monoids from Data.Monoid
- A better monoid for Maybe
- Difference lists of a semigroup

Description

In mathematics, a semigroup is an algebraic structure consisting of a set together with an associative binary operation. A semigroup generalizes a monoid in that there might not exist an identity element. It also (originally) generalized a group (a monoid with all inverses) to a type where every element did not have to have an inverse, thus the name semigroup.

The use of `(<>)` in this module conflicts with an operator with the same name that is being exported by Data.Monoid. However, this package re-exports (most of) the contents of Data.Monoid, so to use semigroups and monoids in the same package just

    import Data.Semigroup

Synopsis

- class Semigroup a where
- 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
  }
- timesN :: (Whole n, Monoid a) => n -> a -> a
- class Monoid a where
- newtype Dual a :: * -> * = Dual {
  - getDual :: a
  }
- newtype Endo a :: * -> * = Endo {
  - appEndo :: a -> a
  }
- newtype All :: * = All {
  - getAll :: Bool
  }
- newtype Any :: * = Any {
  - getAny :: Bool
  }
- newtype Sum a :: * -> * = Sum {
  - getSum :: a
  }
- newtype Product a :: * -> * = Product {
  - getProduct :: a
  }
- newtype Option a = Option {
  - getOption :: Maybe a
  }
- option :: b -> (a -> b) -> Option a -> b
- diff :: Semigroup m => m -> Endo m
- cycle1 :: Semigroup m => m -> m

# Documentation

class Semigroup a where #

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

(<>) :: Monoid a => 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.

times1p :: Whole n => n -> a -> a #

Repeat a value (n + 1) times.

    times1p n a = a <> a <> ... <> a  -- using <> n times

The default definition uses peasant multiplication, exploiting associativity to only require O(log n) uses of `<>`.

See also `times`.

Instances

Semigroup Ordering # |
Methods (<>) :: Ordering -> Ordering -> Ordering # sconcat :: NonEmpty Ordering -> Ordering # times1p :: Whole n => n -> Ordering -> Ordering #
Semigroup () # |
Methods (<>) :: () -> () -> () # sconcat :: NonEmpty () -> () # times1p :: Whole n => n -> () -> () #
Semigroup All # |
Methods (<>) :: All -> All -> All # sconcat :: NonEmpty All -> All # times1p :: Whole n => n -> All -> All #
Semigroup Any # |
Methods (<>) :: Any -> Any -> Any # sconcat :: NonEmpty Any -> Any # times1p :: Whole n => n -> Any -> Any #
Semigroup IntSet # |
Methods (<>) :: IntSet -> IntSet -> IntSet # sconcat :: NonEmpty IntSet -> IntSet # times1p :: Whole n => n -> IntSet -> IntSet #
Semigroup [a] # |
Methods (<>) :: [a] -> [a] -> [a] # sconcat :: NonEmpty [a] -> [a] # times1p :: Whole n => n -> [a] -> [a] #
Semigroup a => Semigroup (Maybe a) # |
Methods (<>) :: Maybe a -> Maybe a -> Maybe a # sconcat :: NonEmpty (Maybe a) -> Maybe a # times1p :: Whole n => n -> Maybe a -> Maybe a #
Semigroup a => Semigroup (Dual a) # |
Methods (<>) :: Dual a -> Dual a -> Dual a # sconcat :: NonEmpty (Dual a) -> Dual a # times1p :: Whole n => n -> Dual a -> Dual a #
Semigroup (Endo a) # |
Methods (<>) :: Endo a -> Endo a -> Endo a # sconcat :: NonEmpty (Endo a) -> Endo a # times1p :: Whole n => n -> Endo a -> Endo a #
Num a => Semigroup (Sum a) # |
Methods (<>) :: Sum a -> Sum a -> Sum a # sconcat :: NonEmpty (Sum a) -> Sum a # times1p :: Whole n => n -> Sum a -> Sum a #
Num a => Semigroup (Product a) # |
Methods (<>) :: Product a -> Product a -> Product a # sconcat :: NonEmpty (Product a) -> Product a # times1p :: Whole n => n -> Product a -> Product a #
Semigroup (First a) # |
Methods (<>) :: First a -> First a -> First a # sconcat :: NonEmpty (First a) -> First a # times1p :: Whole n => n -> First a -> First a #
Semigroup (Last a) # |
Methods (<>) :: Last a -> Last a -> Last a # sconcat :: NonEmpty (Last a) -> Last a # times1p :: Whole n => n -> Last a -> Last a #
Semigroup (IntMap v) # |
Methods (<>) :: IntMap v -> IntMap v -> IntMap v # sconcat :: NonEmpty (IntMap v) -> IntMap v # times1p :: Whole n => n -> IntMap v -> IntMap v #
Semigroup (Seq a) # |
Methods (<>) :: Seq a -> Seq a -> Seq a # sconcat :: NonEmpty (Seq a) -> Seq a # times1p :: Whole n => n -> Seq a -> Seq a #
Ord a => Semigroup (Set a) # |
Methods (<>) :: Set a -> Set a -> Set a # sconcat :: NonEmpty (Set a) -> Set a # times1p :: Whole n => n -> Set a -> Set a #
Semigroup (NonEmpty a) # |
Methods (<>) :: NonEmpty a -> NonEmpty a -> NonEmpty a # sconcat :: NonEmpty (NonEmpty a) -> NonEmpty a # times1p :: Whole n => n -> NonEmpty a -> NonEmpty a #
Semigroup a => Semigroup (Option a) # |
Methods (<>) :: Option a -> Option a -> Option a # sconcat :: NonEmpty (Option a) -> Option a # times1p :: Whole n => n -> Option a -> Option a #
Monoid m => Semigroup (WrappedMonoid m) # |
Methods (<>) :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # sconcat :: NonEmpty (WrappedMonoid m) -> WrappedMonoid m # times1p :: Whole n => n -> WrappedMonoid m -> WrappedMonoid m #
Semigroup (Last a) # |
Methods (<>) :: Last a -> Last a -> Last a # sconcat :: NonEmpty (Last a) -> Last a # times1p :: Whole n => n -> Last a -> Last a #
Semigroup (First a) # |
Methods (<>) :: First a -> First a -> First a # sconcat :: NonEmpty (First a) -> First a # times1p :: Whole n => n -> First a -> First a #
Ord a => Semigroup (Max a) # |
Methods (<>) :: Max a -> Max a -> Max a # sconcat :: NonEmpty (Max a) -> Max a # times1p :: Whole n => n -> Max a -> Max a #
Ord a => Semigroup (Min a) # |
Methods (<>) :: Min a -> Min a -> Min a # sconcat :: NonEmpty (Min a) -> Min a # times1p :: Whole n => n -> Min a -> Min a #
Semigroup b => Semigroup (a -> b) # |
Methods (<>) :: (a -> b) -> (a -> b) -> a -> b # sconcat :: NonEmpty (a -> b) -> a -> b # times1p :: Whole n => n -> (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 # times1p :: Whole n => n -> 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) # times1p :: Whole n => n -> (a, b) -> (a, b) #
Ord k => Semigroup (Map k v) # |
Methods (<>) :: Map k v -> Map k v -> Map k v # sconcat :: NonEmpty (Map k v) -> Map k v # times1p :: Whole n => n -> Map k v -> Map k v #
(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) # times1p :: Whole n => n -> (a, b, c) -> (a, b, c) #
(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) # times1p :: Whole n => n -> (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) # times1p :: Whole n => n -> (a, b, c, d, e) -> (a, b, c, d, e) #

# Semigroups

newtype Min a #

Constructors

Min |
Fields getMin :: a

Instances

Bounded a => Bounded (Min a) # |
Methods minBound :: Min a # maxBound :: Min a #
Eq a => Eq (Min a) # |
Methods (==) :: Min a -> Min a -> Bool # (/=) :: Min a -> Min a -> Bool #
Data a => Data (Min a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Min a -> c (Min a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Min a) # toConstr :: Min a -> Constr # dataTypeOf :: Min a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Min a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Min a)) # gmapT :: (forall b. Data b => b -> b) -> Min a -> Min a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r # gmapQ :: (forall d. Data d => d -> u) -> Min a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Min a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Min a -> m (Min a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Min a -> m (Min a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Min a -> m (Min a) #
Ord a => Ord (Min a) # |
Methods compare :: Min a -> Min a -> Ordering # (<) :: Min a -> Min a -> Bool # (<=) :: Min a -> Min a -> Bool # (>) :: Min a -> Min a -> Bool # (>=) :: Min a -> Min a -> Bool # max :: Min a -> Min a -> Min a # min :: Min a -> Min a -> Min a #
Read a => Read (Min a) # |
Methods readsPrec :: Int -> ReadS (Min a) # readList :: ReadS [Min a] # readPrec :: ReadPrec (Min a) # readListPrec :: ReadPrec [Min a] #
Show a => Show (Min a) # |
Methods showsPrec :: Int -> Min a -> ShowS # show :: Min a -> String # showList :: [Min a] -> ShowS #
(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 => Semigroup (Min a) # |
Methods (<>) :: Min a -> Min a -> Min a # sconcat :: NonEmpty (Min a) -> Min a # times1p :: Whole n => n -> Min a -> Min a #

newtype Max a #

Constructors

Max |
Fields getMax :: a

Instances

Bounded a => Bounded (Max a) # |
Methods minBound :: Max a # maxBound :: Max a #
Eq a => Eq (Max a) # |
Methods (==) :: Max a -> Max a -> Bool # (/=) :: Max a -> Max a -> Bool #
Data a => Data (Max a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Max a -> c (Max a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Max a) # toConstr :: Max a -> Constr # dataTypeOf :: Max a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Max a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Max a)) # gmapT :: (forall b. Data b => b -> b) -> Max a -> Max a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r # gmapQ :: (forall d. Data d => d -> u) -> Max a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Max a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Max a -> m (Max a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Max a -> m (Max a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Max a -> m (Max a) #
Ord a => Ord (Max a) # |
Methods compare :: Max a -> Max a -> Ordering # (<) :: Max a -> Max a -> Bool # (<=) :: Max a -> Max a -> Bool # (>) :: Max a -> Max a -> Bool # (>=) :: Max a -> Max a -> Bool # max :: Max a -> Max a -> Max a # min :: Max a -> Max a -> Max a #
Read a => Read (Max a) # |
Methods readsPrec :: Int -> ReadS (Max a) # readList :: ReadS [Max a] # readPrec :: ReadPrec (Max a) # readListPrec :: ReadPrec [Max a] #
Show a => Show (Max a) # |
Methods showsPrec :: Int -> Max a -> ShowS # show :: Max a -> String # showList :: [Max a] -> ShowS #
(Ord a, Bounded a) => Monoid (Max a) # |
Methods mempty :: Max a # mappend :: Max a -> Max a -> Max a # mconcat :: [Max a] -> Max a #
Ord a => Semigroup (Max a) # |
Methods (<>) :: Max a -> Max a -> Max a # sconcat :: NonEmpty (Max a) -> Max a # times1p :: Whole n => n -> Max a -> Max a #

newtype First a #

Use ``Option` (`First` a)` -- to get the behavior of `First`

Constructors

First |
Fields getFirst :: a

Instances

Bounded a => Bounded (First a) # |
Methods minBound :: First a # maxBound :: First a #
Eq a => Eq (First a) # |
Methods (==) :: First a -> First a -> Bool # (/=) :: First a -> First a -> Bool #
Data a => Data (First a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> First a -> c (First a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (First a) # toConstr :: First a -> Constr # dataTypeOf :: First a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (First a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (First a)) # gmapT :: (forall b. Data b => b -> b) -> First a -> First a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r # gmapQ :: (forall d. Data d => d -> u) -> First a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> First a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> First a -> m (First a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) #
Ord a => Ord (First a) # |
Methods compare :: First a -> First a -> Ordering # (<) :: First a -> First a -> Bool # (<=) :: First a -> First a -> Bool # (>) :: First a -> First a -> Bool # (>=) :: First a -> First a -> Bool # max :: First a -> First a -> First a # min :: First a -> First a -> First a #
Read a => Read (First a) # |
Methods readsPrec :: Int -> ReadS (First a) # readList :: ReadS [First a] # readPrec :: ReadPrec (First a) # readListPrec :: ReadPrec [First a] #
Show a => Show (First a) # |
Methods showsPrec :: Int -> First a -> ShowS # show :: First a -> String # showList :: [First a] -> ShowS #
Semigroup (First a) # |
Methods (<>) :: First a -> First a -> First a # sconcat :: NonEmpty (First a) -> First a # times1p :: Whole n => n -> First a -> First a #

newtype Last a #

Use ``Option` (`Last` a)` -- to get the behavior of `Last`

Constructors

Last |
Fields getLast :: a

Instances

Bounded a => Bounded (Last a) # |
Methods minBound :: Last a # maxBound :: Last a #
Eq a => Eq (Last a) # |
Methods (==) :: Last a -> Last a -> Bool # (/=) :: Last a -> Last a -> Bool #
Data a => Data (Last a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Last a -> c (Last a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Last a) # toConstr :: Last a -> Constr # dataTypeOf :: Last a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Last a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Last a)) # gmapT :: (forall b. Data b => b -> b) -> Last a -> Last a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r # gmapQ :: (forall d. Data d => d -> u) -> Last a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Last a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) #
Ord a => Ord (Last a) # |
Methods compare :: Last a -> Last a -> Ordering # (<) :: Last a -> Last a -> Bool # (<=) :: Last a -> Last a -> Bool # (>) :: Last a -> Last a -> Bool # (>=) :: Last a -> Last a -> Bool # max :: Last a -> Last a -> Last a # min :: Last a -> Last a -> Last a #
Read a => Read (Last a) # |
Methods readsPrec :: Int -> ReadS (Last a) # readList :: ReadS [Last a] # readPrec :: ReadPrec (Last a) # readListPrec :: ReadPrec [Last a] #
Show a => Show (Last a) # |
Methods showsPrec :: Int -> Last a -> ShowS # show :: Last a -> String # showList :: [Last a] -> ShowS #
Semigroup (Last a) # |
Methods (<>) :: Last a -> Last a -> Last a # sconcat :: NonEmpty (Last a) -> Last a # times1p :: Whole n => n -> Last a -> Last a #

newtype WrappedMonoid m #

Provide a Semigroup for an arbitrary Monoid.

Constructors

WrapMonoid |
Fields unwrapMonoid :: m

Instances

Bounded m => Bounded (WrappedMonoid m) # |
Methods minBound :: WrappedMonoid m # maxBound :: WrappedMonoid m #
Eq m => Eq (WrappedMonoid m) # |
Methods (==) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (/=) :: WrappedMonoid m -> WrappedMonoid m -> Bool #
Data m => Data (WrappedMonoid m) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WrappedMonoid m -> c (WrappedMonoid m) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WrappedMonoid m) # toConstr :: WrappedMonoid m -> Constr # dataTypeOf :: WrappedMonoid m -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (WrappedMonoid m)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WrappedMonoid m)) # gmapT :: (forall b. Data b => b -> b) -> WrappedMonoid m -> WrappedMonoid m # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonoid m -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonoid m -> r # gmapQ :: (forall d. Data d => d -> u) -> WrappedMonoid m -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> WrappedMonoid m -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WrappedMonoid m -> m (WrappedMonoid m) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WrappedMonoid m -> m (WrappedMonoid m) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WrappedMonoid m -> m (WrappedMonoid m) #
Ord m => Ord (WrappedMonoid m) # |
Methods compare :: WrappedMonoid m -> WrappedMonoid m -> Ordering # (<) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (<=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (>) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (>=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # max :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # min :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m #
Read m => Read (WrappedMonoid m) # |
Methods readsPrec :: Int -> ReadS (WrappedMonoid m) # readList :: ReadS [WrappedMonoid m] # readPrec :: ReadPrec (WrappedMonoid m) # readListPrec :: ReadPrec [WrappedMonoid m] #
Show m => Show (WrappedMonoid m) # |
Methods showsPrec :: Int -> WrappedMonoid m -> ShowS # show :: WrappedMonoid m -> String # showList :: [WrappedMonoid m] -> ShowS #
Monoid m => Monoid (WrappedMonoid m) # |
Methods mempty :: WrappedMonoid m # mappend :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # mconcat :: [WrappedMonoid m] -> WrappedMonoid m #
Monoid m => Semigroup (WrappedMonoid m) # |
Methods (<>) :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # sconcat :: NonEmpty (WrappedMonoid m) -> WrappedMonoid m # times1p :: Whole n => n -> WrappedMonoid m -> WrappedMonoid m #

timesN :: (Whole n, Monoid a) => n -> a -> a #

Repeat a value `n` times.

    times n a = a <> a <> ... <> a  -- using <> (n-1) times

Implemented using `times1p`.

# Re-exported monoids from Data.Monoid

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 `newtype`s and make those instances of `Monoid`, e.g. `Sum` and `Product`.

Minimal complete definition

mempty, mappend

Methods

mempty :: a #

Identity of `mappend`

mappend :: a -> a -> a #

An associative operation

mconcat :: [a] -> a #

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.

Instances

Monoid Ordering | Since: 2.1
Methods mempty :: Ordering # mappend :: Ordering -> Ordering -> Ordering # mconcat :: [Ordering] -> Ordering #
Monoid () | Since: 2.1
Methods mempty :: () # mappend :: () -> () -> () # mconcat :: [()] -> () #
Monoid All | Since: 2.1
Methods mempty :: All # mappend :: All -> All -> All # mconcat :: [All] -> All #
Monoid Any | Since: 2.1
Methods mempty :: Any # mappend :: Any -> Any -> Any # mconcat :: [Any] -> Any #
Monoid IntSet |
Methods mempty :: IntSet # mappend :: IntSet -> IntSet -> IntSet # mconcat :: [IntSet] -> IntSet #
Monoid [a] | Since: 2.1
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 used to be no "Semigroup" typeclass providing just `mappend`, we use `Monoid` instead. Since: 2.1
Methods mempty :: Maybe a # mappend :: Maybe a -> Maybe a -> Maybe a # mconcat :: [Maybe a] -> Maybe a #
Monoid a => Monoid (IO a) | Since: 4.9.0.0
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 #
Monoid a => Monoid (Dual a) | Since: 2.1
Methods mempty :: Dual a # mappend :: Dual a -> Dual a -> Dual a # mconcat :: [Dual a] -> Dual a #
Monoid (Endo a) | Since: 2.1
Methods mempty :: Endo a # mappend :: Endo a -> Endo a -> Endo a # mconcat :: [Endo a] -> Endo a #
Num a => Monoid (Sum a) | Since: 2.1
Methods mempty :: Sum a # mappend :: Sum a -> Sum a -> Sum a # mconcat :: [Sum a] -> Sum a #
Num a => Monoid (Product a) | Since: 2.1
Methods mempty :: Product a # mappend :: Product a -> Product a -> Product a # mconcat :: [Product a] -> Product a #
Monoid (First a) | Since: 2.1
Methods mempty :: First a # mappend :: First a -> First a -> First a # mconcat :: [First a] -> First a #
Monoid (Last a) | Since: 2.1
Methods mempty :: Last a # mappend :: Last a -> Last a -> Last a # mconcat :: [Last a] -> Last a #
Monoid (IntMap a) |
Methods mempty :: IntMap a # mappend :: IntMap a -> IntMap a -> IntMap a # mconcat :: [IntMap a] -> IntMap a #
Monoid (Seq a) |
Methods mempty :: Seq a # mappend :: Seq a -> Seq a -> Seq a # mconcat :: [Seq a] -> Seq a #
Ord a => Monoid (Set a) |
Methods mempty :: Set a # mappend :: Set a -> Set a -> Set a # mconcat :: [Set a] -> Set a #
Semigroup a => Monoid (Option a) # |
Methods mempty :: Option a # mappend :: Option a -> Option a -> Option a # mconcat :: [Option a] -> Option a #
Monoid m => Monoid (WrappedMonoid m) # |
Methods mempty :: WrappedMonoid m # mappend :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # mconcat :: [WrappedMonoid m] -> WrappedMonoid m #
(Ord a, Bounded a) => Monoid (Max a) # |
Methods mempty :: Max a # mappend :: Max a -> Max a -> Max a # mconcat :: [Max a] -> Max a #
(Ord a, Bounded a) => Monoid (Min a) # |
Methods mempty :: Min a # mappend :: Min a -> Min a -> Min a # mconcat :: [Min a] -> Min a #
Monoid b => Monoid (a -> b) | Since: 2.1
Methods mempty :: a -> b # mappend :: (a -> b) -> (a -> b) -> a -> b # mconcat :: [a -> b] -> a -> b #
(Monoid a, Monoid b) => Monoid (a, b) | Since: 2.1
Methods mempty :: (a, b) # mappend :: (a, b) -> (a, b) -> (a, b) # mconcat :: [(a, b)] -> (a, b) #
Monoid (Proxy k s) | Since: 4.7.0.0
Methods mempty :: Proxy k s # mappend :: Proxy k s -> Proxy k s -> Proxy k s # mconcat :: [Proxy k s] -> Proxy k s #
Ord k => Monoid (Map k v) |
Methods mempty :: Map k v # mappend :: Map k v -> Map k v -> Map k v # mconcat :: [Map k v] -> Map k v #
(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c) | Since: 2.1
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) | Since: 4.8.0.0
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) | Since: 2.1
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) | Since: 2.1
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) #

newtype Dual a :: * -> * #

The dual of a `Monoid`, obtained by swapping the arguments of `mappend`.

Constructors

Dual |
Fields getDual :: a

Instances

Monad Dual | Since: 4.8.0.0
Methods (>>=) :: Dual a -> (a -> Dual b) -> Dual b # (>>) :: Dual a -> Dual b -> Dual b # return :: a -> Dual a # fail :: String -> Dual a #
Functor Dual | Since: 4.8.0.0
Methods fmap :: (a -> b) -> Dual a -> Dual b # (<$) :: a -> Dual b -> Dual a #
MonadFix Dual | Since: 4.8.0.0
Methods mfix :: (a -> Dual a) -> Dual a #
Applicative Dual | Since: 4.8.0.0
Methods pure :: a -> Dual a # (<*>) :: Dual (a -> b) -> Dual a -> Dual b # liftA2 :: (a -> b -> c) -> Dual a -> Dual b -> Dual c # (*>) :: Dual a -> Dual b -> Dual b # (<*) :: Dual a -> Dual b -> Dual a #
Foldable Dual | Since: 4.8.0.0
Methods fold :: Monoid m => Dual m -> m # foldMap :: Monoid m => (a -> m) -> Dual a -> m # foldr :: (a -> b -> b) -> b -> Dual a -> b # foldr' :: (a -> b -> b) -> b -> Dual a -> b # foldl :: (b -> a -> b) -> b -> Dual a -> b # foldl' :: (b -> a -> b) -> b -> Dual a -> b # foldr1 :: (a -> a -> a) -> Dual a -> a # foldl1 :: (a -> a -> a) -> Dual a -> a # toList :: Dual a -> [a] # null :: Dual a -> Bool # length :: Dual a -> Int # elem :: Eq a => a -> Dual a -> Bool # maximum :: Ord a => Dual a -> a # minimum :: Ord a => Dual a -> a # sum :: Num a => Dual a -> a # product :: Num a => Dual a -> a #
Traversable Dual | Since: 4.8.0.0
Methods traverse :: Applicative f => (a -> f b) -> Dual a -> f (Dual b) # sequenceA :: Applicative f => Dual (f a) -> f (Dual a) # mapM :: Monad m => (a -> m b) -> Dual a -> m (Dual b) # sequence :: Monad m => Dual (m a) -> m (Dual a) #
Bounded a => Bounded (Dual a) |
Methods minBound :: Dual a # maxBound :: Dual a #
Eq a => Eq (Dual a) |
Methods (==) :: Dual a -> Dual a -> Bool # (/=) :: Dual a -> Dual a -> Bool #
Data a => Data (Dual a) | Since: 4.8.0.0
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Dual a -> c (Dual a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Dual a) # toConstr :: Dual a -> Constr # dataTypeOf :: Dual a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Dual a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Dual a)) # gmapT :: (forall b. Data b => b -> b) -> Dual a -> Dual a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dual a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dual a -> r # gmapQ :: (forall d. Data d => d -> u) -> Dual a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Dual a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dual a -> m (Dual a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dual a -> m (Dual a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dual a -> m (Dual a) #
Ord a => Ord (Dual a) |
Methods compare :: Dual a -> Dual a -> Ordering # (<) :: Dual a -> Dual a -> Bool # (<=) :: Dual a -> Dual a -> Bool # (>) :: Dual a -> Dual a -> Bool # (>=) :: Dual a -> Dual a -> Bool # max :: Dual a -> Dual a -> Dual a # min :: Dual a -> Dual a -> Dual a #
Read a => Read (Dual a) |
Methods readsPrec :: Int -> ReadS (Dual a) # readList :: ReadS [Dual a] # readPrec :: ReadPrec (Dual a) # readListPrec :: ReadPrec [Dual a] #
Show a => Show (Dual a) |
Methods showsPrec :: Int -> Dual a -> ShowS # show :: Dual a -> String # showList :: [Dual a] -> ShowS #
Generic (Dual a) |
Associated Types type Rep (Dual a) :: * -> * # Methods from :: Dual a -> Rep (Dual a) x # to :: Rep (Dual a) x -> Dual a #
Monoid a => Monoid (Dual a) | Since: 2.1
Methods mempty :: Dual a # mappend :: Dual a -> Dual a -> Dual a # mconcat :: [Dual a] -> Dual a #
Semigroup a => Semigroup (Dual a) # |
Methods (<>) :: Dual a -> Dual a -> Dual a # sconcat :: NonEmpty (Dual a) -> Dual a # times1p :: Whole n => n -> Dual a -> Dual a #
Generic1 * Dual |
Associated Types type Rep1 Dual (f :: Dual -> *) :: k -> * # Methods from1 :: f a -> Rep1 Dual f a # to1 :: Rep1 Dual f a -> f a #
type Rep (Dual a) |
type Rep (Dual a) = D1 * (MetaData "Dual" "Data.Monoid" "base" True) (C1 * (MetaCons "Dual" PrefixI True) (S1 * (MetaSel (Just Symbol "getDual") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)))
type Rep1 * Dual |
type Rep1 * Dual = D1 * (MetaData "Dual" "Data.Monoid" "base" True) (C1 * (MetaCons "Dual" PrefixI True) (S1 * (MetaSel (Just Symbol "getDual") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype Endo a :: * -> * #

The monoid of endomorphisms under composition.

Constructors

Endo |
Fields appEndo :: a -> a

Instances

Generic (Endo a) |
Associated Types type Rep (Endo a) :: * -> * # Methods from :: Endo a -> Rep (Endo a) x # to :: Rep (Endo a) x -> Endo a #
Monoid (Endo a) | Since: 2.1
Methods mempty :: Endo a # mappend :: Endo a -> Endo a -> Endo a # mconcat :: [Endo a] -> Endo a #
Semigroup (Endo a) # |
Methods (<>) :: Endo a -> Endo a -> Endo a # sconcat :: NonEmpty (Endo a) -> Endo a # times1p :: Whole n => n -> Endo a -> Endo a #
type Rep (Endo a) |
type Rep (Endo a) = D1 * (MetaData "Endo" "Data.Monoid" "base" True) (C1 * (MetaCons "Endo" PrefixI True) (S1 * (MetaSel (Just Symbol "appEndo") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (a -> a))))

newtype All :: * #

Boolean monoid under conjunction (`&&`).

Constructors

All |
Fields getAll :: Bool

Instances

Bounded All |
Methods minBound :: All # maxBound :: All #
Eq All |
Methods (==) :: All -> All -> Bool # (/=) :: All -> All -> Bool #
Data All | Since: 4.8.0.0
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> All -> c All # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c All # toConstr :: All -> Constr # dataTypeOf :: All -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c All) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c All) # gmapT :: (forall b. Data b => b -> b) -> All -> All # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> All -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> All -> r # gmapQ :: (forall d. Data d => d -> u) -> All -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> All -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> All -> m All # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> All -> m All # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> All -> m All #
Ord All |
Methods compare :: All -> All -> Ordering # (<) :: All -> All -> Bool # (<=) :: All -> All -> Bool # (>) :: All -> All -> Bool # (>=) :: All -> All -> Bool # max :: All -> All -> All # min :: All -> All -> All #
Read All |
Methods readsPrec :: Int -> ReadS All # readList :: ReadS [All] # readPrec :: ReadPrec All # readListPrec :: ReadPrec [All] #
Show All |
Methods showsPrec :: Int -> All -> ShowS # show :: All -> String # showList :: [All] -> ShowS #
Generic All |
Associated Types type Rep All :: * -> * # Methods from :: All -> Rep All x # to :: Rep All x -> All #
Monoid All | Since: 2.1
Methods mempty :: All # mappend :: All -> All -> All # mconcat :: [All] -> All #
Semigroup All # |
Methods (<>) :: All -> All -> All # sconcat :: NonEmpty All -> All # times1p :: Whole n => n -> All -> All #
type Rep All |
type Rep All = D1 * (MetaData "All" "Data.Monoid" "base" True) (C1 * (MetaCons "All" PrefixI True) (S1 * (MetaSel (Just Symbol "getAll") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Bool)))

newtype Any :: * #

Boolean monoid under disjunction (`||`).

Constructors

Any |
Fields getAny :: Bool

Instances

Bounded Any |
Methods minBound :: Any # maxBound :: Any #
Eq Any |
Methods (==) :: Any -> Any -> Bool # (/=) :: Any -> Any -> Bool #
Data Any | Since: 4.8.0.0
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Any -> c Any # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Any # toConstr :: Any -> Constr # dataTypeOf :: Any -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Any) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Any) # gmapT :: (forall b. Data b => b -> b) -> Any -> Any # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Any -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Any -> r # gmapQ :: (forall d. Data d => d -> u) -> Any -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Any -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Any -> m Any # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Any -> m Any # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Any -> m Any #
Ord Any |
Methods compare :: Any -> Any -> Ordering # (<) :: Any -> Any -> Bool # (<=) :: Any -> Any -> Bool # (>) :: Any -> Any -> Bool # (>=) :: Any -> Any -> Bool # max :: Any -> Any -> Any # min :: Any -> Any -> Any #
Read Any |
Methods readsPrec :: Int -> ReadS Any # readList :: ReadS [Any] # readPrec :: ReadPrec Any # readListPrec :: ReadPrec [Any] #
Show Any |
Methods showsPrec :: Int -> Any -> ShowS # show :: Any -> String # showList :: [Any] -> ShowS #
Generic Any |
Associated Types type Rep Any :: * -> * # Methods from :: Any -> Rep Any x # to :: Rep Any x -> Any #
Monoid Any | Since: 2.1
Methods mempty :: Any # mappend :: Any -> Any -> Any # mconcat :: [Any] -> Any #
Semigroup Any # |
Methods (<>) :: Any -> Any -> Any # sconcat :: NonEmpty Any -> Any # times1p :: Whole n => n -> Any -> Any #
type Rep Any |
type Rep Any = D1 * (MetaData "Any" "Data.Monoid" "base" True) (C1 * (MetaCons "Any" PrefixI True) (S1 * (MetaSel (Just Symbol "getAny") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Bool)))

newtype Sum a :: * -> * #

Monoid under addition.

Constructors

Sum |
Fields getSum :: a

Instances

Monad Sum | Since: 4.8.0.0
Methods (>>=) :: Sum a -> (a -> Sum b) -> Sum b # (>>) :: Sum a -> Sum b -> Sum b # return :: a -> Sum a # fail :: String -> Sum a #
Functor Sum | Since: 4.8.0.0
Methods fmap :: (a -> b) -> Sum a -> Sum b # (<$) :: a -> Sum b -> Sum a #
MonadFix Sum | Since: 4.8.0.0
Methods mfix :: (a -> Sum a) -> Sum a #
Applicative Sum | Since: 4.8.0.0
Methods pure :: a -> Sum a # (<*>) :: Sum (a -> b) -> Sum a -> Sum b # liftA2 :: (a -> b -> c) -> Sum a -> Sum b -> Sum c # (*>) :: Sum a -> Sum b -> Sum b # (<*) :: Sum a -> Sum b -> Sum a #
Foldable Sum | Since: 4.8.0.0
Methods fold :: Monoid m => Sum m -> m # foldMap :: Monoid m => (a -> m) -> Sum a -> m # foldr :: (a -> b -> b) -> b -> Sum a -> b # foldr' :: (a -> b -> b) -> b -> Sum a -> b # foldl :: (b -> a -> b) -> b -> Sum a -> b # foldl' :: (b -> a -> b) -> b -> Sum a -> b # foldr1 :: (a -> a -> a) -> Sum a -> a # foldl1 :: (a -> a -> a) -> Sum a -> a # toList :: Sum a -> [a] # null :: Sum a -> Bool # length :: Sum a -> Int # elem :: Eq a => a -> Sum a -> Bool # maximum :: Ord a => Sum a -> a # minimum :: Ord a => Sum a -> a # sum :: Num a => Sum a -> a # product :: Num a => Sum a -> a #
Traversable Sum | Since: 4.8.0.0
Methods traverse :: Applicative f => (a -> f b) -> Sum a -> f (Sum b) # sequenceA :: Applicative f => Sum (f a) -> f (Sum a) # mapM :: Monad m => (a -> m b) -> Sum a -> m (Sum b) # sequence :: Monad m => Sum (m a) -> m (Sum a) #
Bounded a => Bounded (Sum a) |
Methods minBound :: Sum a # maxBound :: Sum a #
Eq a => Eq (Sum a) |
Methods (==) :: Sum a -> Sum a -> Bool # (/=) :: Sum a -> Sum a -> Bool #
Data a => Data (Sum a) | Since: 4.8.0.0
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Sum a -> c (Sum a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Sum a) # toConstr :: Sum a -> Constr # dataTypeOf :: Sum a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Sum a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sum a)) # gmapT :: (forall b. Data b => b -> b) -> Sum a -> Sum a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sum a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sum a -> r # gmapQ :: (forall d. Data d => d -> u) -> Sum a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Sum a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Sum a -> m (Sum a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum a -> m (Sum a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum a -> m (Sum a) #
Num a => Num (Sum a) |
Methods (+) :: Sum a -> Sum a -> Sum a # (-) :: Sum a -> Sum a -> Sum a # (*) :: Sum a -> Sum a -> Sum a # negate :: Sum a -> Sum a # abs :: Sum a -> Sum a # signum :: Sum a -> Sum a # fromInteger :: Integer -> Sum a #
Ord a => Ord (Sum a) |
Methods compare :: Sum a -> Sum a -> Ordering # (<) :: Sum a -> Sum a -> Bool # (<=) :: Sum a -> Sum a -> Bool # (>) :: Sum a -> Sum a -> Bool # (>=) :: Sum a -> Sum a -> Bool # max :: Sum a -> Sum a -> Sum a # min :: Sum a -> Sum a -> Sum a #
Read a => Read (Sum a) |
Methods readsPrec :: Int -> ReadS (Sum a) # readList :: ReadS [Sum a] # readPrec :: ReadPrec (Sum a) # readListPrec :: ReadPrec [Sum a] #
Show a => Show (Sum a) |
Methods showsPrec :: Int -> Sum a -> ShowS # show :: Sum a -> String # showList :: [Sum a] -> ShowS #
Generic (Sum a) |
Associated Types type Rep (Sum a) :: * -> * # Methods from :: Sum a -> Rep (Sum a) x # to :: Rep (Sum a) x -> Sum a #
Num a => Monoid (Sum a) | Since: 2.1
Methods mempty :: Sum a # mappend :: Sum a -> Sum a -> Sum a # mconcat :: [Sum a] -> Sum a #
Num a => Semigroup (Sum a) # |
Methods (<>) :: Sum a -> Sum a -> Sum a # sconcat :: NonEmpty (Sum a) -> Sum a # times1p :: Whole n => n -> Sum a -> Sum a #
Generic1 * Sum |
Associated Types type Rep1 Sum (f :: Sum -> *) :: k -> * # Methods from1 :: f a -> Rep1 Sum f a # to1 :: Rep1 Sum f a -> f a #
type Rep (Sum a) |
type Rep (Sum a) = D1 * (MetaData "Sum" "Data.Monoid" "base" True) (C1 * (MetaCons "Sum" PrefixI True) (S1 * (MetaSel (Just Symbol "getSum") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)))
type Rep1 * Sum |
type Rep1 * Sum = D1 * (MetaData "Sum" "Data.Monoid" "base" True) (C1 * (MetaCons "Sum" PrefixI True) (S1 * (MetaSel (Just Symbol "getSum") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype Product a :: * -> * #

Monoid under multiplication.

Constructors

Product |
Fields getProduct :: a

Instances

Monad Product | Since: 4.8.0.0
Methods (>>=) :: Product a -> (a -> Product b) -> Product b # (>>) :: Product a -> Product b -> Product b # return :: a -> Product a # fail :: String -> Product a #
Functor Product | Since: 4.8.0.0
Methods fmap :: (a -> b) -> Product a -> Product b # (<$) :: a -> Product b -> Product a #
MonadFix Product | Since: 4.8.0.0
Methods mfix :: (a -> Product a) -> Product a #
Applicative Product | Since: 4.8.0.0
Methods pure :: a -> Product a # (<*>) :: Product (a -> b) -> Product a -> Product b # liftA2 :: (a -> b -> c) -> Product a -> Product b -> Product c # (*>) :: Product a -> Product b -> Product b # (<*) :: Product a -> Product b -> Product a #
Foldable Product | Since: 4.8.0.0
Methods fold :: Monoid m => Product m -> m # foldMap :: Monoid m => (a -> m) -> Product a -> m # foldr :: (a -> b -> b) -> b -> Product a -> b # foldr' :: (a -> b -> b) -> b -> Product a -> b # foldl :: (b -> a -> b) -> b -> Product a -> b # foldl' :: (b -> a -> b) -> b -> Product a -> b # foldr1 :: (a -> a -> a) -> Product a -> a # foldl1 :: (a -> a -> a) -> Product a -> a # toList :: Product a -> [a] # null :: Product a -> Bool # length :: Product a -> Int # elem :: Eq a => a -> Product a -> Bool # maximum :: Ord a => Product a -> a # minimum :: Ord a => Product a -> a # sum :: Num a => Product a -> a # product :: Num a => Product a -> a #
Traversable Product | Since: 4.8.0.0
Methods traverse :: Applicative f => (a -> f b) -> Product a -> f (Product b) # sequenceA :: Applicative f => Product (f a) -> f (Product a) # mapM :: Monad m => (a -> m b) -> Product a -> m (Product b) # sequence :: Monad m => Product (m a) -> m (Product a) #
Bounded a => Bounded (Product a) |
Methods minBound :: Product a # maxBound :: Product a #
Eq a => Eq (Product a) |
Methods (==) :: Product a -> Product a -> Bool # (/=) :: Product a -> Product a -> Bool #
Data a => Data (Product a) | Since: 4.8.0.0
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Product a -> c (Product a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Product a) # toConstr :: Product a -> Constr # dataTypeOf :: Product a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Product a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Product a)) # gmapT :: (forall b. Data b => b -> b) -> Product a -> Product a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Product a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Product a -> r # gmapQ :: (forall d. Data d => d -> u) -> Product a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Product a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Product a -> m (Product a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Product a -> m (Product a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Product a -> m (Product a) #
Num a => Num (Product a) |
Methods (+) :: Product a -> Product a -> Product a # (-) :: Product a -> Product a -> Product a # (*) :: Product a -> Product a -> Product a # negate :: Product a -> Product a # abs :: Product a -> Product a # signum :: Product a -> Product a # fromInteger :: Integer -> Product a #
Ord a => Ord (Product a) |
Methods compare :: Product a -> Product a -> Ordering # (<) :: Product a -> Product a -> Bool # (<=) :: Product a -> Product a -> Bool # (>) :: Product a -> Product a -> Bool # (>=) :: Product a -> Product a -> Bool # max :: Product a -> Product a -> Product a # min :: Product a -> Product a -> Product a #
Read a => Read (Product a) |
Methods readsPrec :: Int -> ReadS (Product a) # readList :: ReadS [Product a] # readPrec :: ReadPrec (Product a) # readListPrec :: ReadPrec [Product a] #
Show a => Show (Product a) |
Methods showsPrec :: Int -> Product a -> ShowS # show :: Product a -> String # showList :: [Product a] -> ShowS #
Generic (Product a) |
Associated Types type Rep (Product a) :: * -> * # Methods from :: Product a -> Rep (Product a) x # to :: Rep (Product a) x -> Product a #
Num a => Monoid (Product a) | Since: 2.1
Methods mempty :: Product a # mappend :: Product a -> Product a -> Product a # mconcat :: [Product a] -> Product a #
Num a => Semigroup (Product a) # |
Methods (<>) :: Product a -> Product a -> Product a # sconcat :: NonEmpty (Product a) -> Product a # times1p :: Whole n => n -> Product a -> Product a #
Generic1 * Product |
Associated Types type Rep1 Product (f :: Product -> *) :: k -> * # Methods from1 :: f a -> Rep1 Product f a # to1 :: Rep1 Product f a -> f a #
type Rep (Product a) |
type Rep (Product a) = D1 * (MetaData "Product" "Data.Monoid" "base" True) (C1 * (MetaCons "Product" PrefixI True) (S1 * (MetaSel (Just Symbol "getProduct") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)))
type Rep1 * Product |
type Rep1 * Product = D1 * (MetaData "Product" "Data.Monoid" "base" True) (C1 * (MetaCons "Product" PrefixI True) (S1 * (MetaSel (Just Symbol "getProduct") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

# A better monoid for Maybe

newtype Option 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` intance of `Maybe`

Constructors

Option |
Fields getOption :: Maybe a

Instances

Monad Option # |
Methods (>>=) :: Option a -> (a -> Option b) -> Option b # (>>) :: Option a -> Option b -> Option b # return :: a -> Option a # fail :: String -> Option a #
Functor Option # |
Methods fmap :: (a -> b) -> Option a -> Option b # (<$) :: a -> Option b -> Option a #
MonadFix Option # |
Methods mfix :: (a -> Option a) -> Option a #
Applicative Option # |
Methods pure :: a -> Option a # (<*>) :: Option (a -> b) -> Option a -> Option b # liftA2 :: (a -> b -> c) -> Option a -> Option b -> Option c # (*>) :: Option a -> Option b -> Option b # (<*) :: Option a -> Option b -> Option a #
Foldable Option # |
Methods fold :: Monoid m => Option m -> m # foldMap :: Monoid m => (a -> m) -> Option a -> m # foldr :: (a -> b -> b) -> b -> Option a -> b # foldr' :: (a -> b -> b) -> b -> Option a -> b # foldl :: (b -> a -> b) -> b -> Option a -> b # foldl' :: (b -> a -> b) -> b -> Option a -> b # foldr1 :: (a -> a -> a) -> Option a -> a # foldl1 :: (a -> a -> a) -> Option a -> a # toList :: Option a -> [a] # null :: Option a -> Bool # length :: Option a -> Int # elem :: Eq a => a -> Option a -> Bool # maximum :: Ord a => Option a -> a # minimum :: Ord a => Option a -> a # sum :: Num a => Option a -> a # product :: Num a => Option a -> a #
Traversable Option # |
Methods traverse :: Applicative f => (a -> f b) -> Option a -> f (Option b) # sequenceA :: Applicative f => Option (f a) -> f (Option a) # mapM :: Monad m => (a -> m b) -> Option a -> m (Option b) # sequence :: Monad m => Option (m a) -> m (Option a) #
Alternative Option # |
Methods empty :: Option a # (<|>) :: Option a -> Option a -> Option a # some :: Option a -> Option [a] # many :: Option a -> Option [a] #
MonadPlus Option # |
Methods mzero :: Option a # mplus :: Option a -> Option a -> Option a #
Eq a => Eq (Option a) # |
Methods (==) :: Option a -> Option a -> Bool # (/=) :: Option a -> Option a -> Bool #
Data a => Data (Option a) # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Option a -> c (Option a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Option a) # toConstr :: Option a -> Constr # dataTypeOf :: Option a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Option a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Option a)) # gmapT :: (forall b. Data b => b -> b) -> Option a -> Option a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Option a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Option a -> r # gmapQ :: (forall d. Data d => d -> u) -> Option a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Option a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Option a -> m (Option a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Option a -> m (Option a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Option a -> m (Option a) #
Ord a => Ord (Option a) # |
Methods compare :: Option a -> Option a -> Ordering # (<) :: Option a -> Option a -> Bool # (<=) :: Option a -> Option a -> Bool # (>) :: Option a -> Option a -> Bool # (>=) :: Option a -> Option a -> Bool # max :: Option a -> Option a -> Option a # min :: Option a -> Option a -> Option a #
Read a => Read (Option a) # |
Methods readsPrec :: Int -> ReadS (Option a) # readList :: ReadS [Option a] # readPrec :: ReadPrec (Option a) # readListPrec :: ReadPrec [Option a] #
Show a => Show (Option a) # |
Methods showsPrec :: Int -> Option a -> ShowS # show :: Option a -> String # showList :: [Option a] -> ShowS #
Semigroup a => Monoid (Option a) # |
Methods mempty :: Option a # mappend :: Option a -> Option a -> Option a # mconcat :: [Option a] -> Option a #
Semigroup a => Semigroup (Option a) # |
Methods (<>) :: Option a -> Option a -> Option a # sconcat :: NonEmpty (Option a) -> Option a # times1p :: Whole n => n -> Option a -> Option a #

option :: b -> (a -> b) -> Option a -> b #

# Difference lists of a semigroup

diff :: Semigroup m => m -> Endo m #

This lets you use a difference list of a Semigroup as a Monoid.

cycle1 :: Semigroup m => m -> m #

A generalization of `cycle` to an arbitrary `Semigroup`. May fail to terminate for some values in some semigroups.