Data.Semigroup

base-4.9.0.0: Basic libraries

Copyright | (C) 2011-2015 Edward Kmett
License | BSD-style (see the file LICENSE)
Maintainer | libraries@haskell.org
Stability | provisional
Portability | portable
Safe Haskell | Trustworthy
Language | Haskell2010

Data.Semigroup

Contents

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

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

Since: 4.9.0.0

Synopsis

- 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
- 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 {
  - 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
- data Arg a b = Arg a b
- type ArgMin a b = Min (Arg a b)
- type ArgMax a b = Max (Arg a b)

# Documentation

class Semigroup a where Source

The class of semigroups (types with an associative binary operation).

Since: 4.9.0.0

Methods

(<>) :: a -> a -> a infixr 6 Source

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 Source

An associative operation.

    (a <> b) <> c = a <> (b <> c)

If `a` is also a `Monoid` we further require

    (<>) = mappend

sconcat :: NonEmpty a -> a Source

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 Source

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.

Instances

Semigroup Ordering |
Methods (<>) :: Ordering -> Ordering -> Ordering Source sconcat :: NonEmpty Ordering -> Ordering Source stimes :: Integral b => b -> Ordering -> Ordering Source
Semigroup () |
Methods (<>) :: () -> () -> () Source sconcat :: NonEmpty () -> () Source stimes :: Integral b => b -> () -> () Source
Semigroup Any |
Methods (<>) :: Any -> Any -> Any Source sconcat :: NonEmpty Any -> Any Source stimes :: Integral b => b -> Any -> Any Source
Semigroup All |
Methods (<>) :: All -> All -> All Source sconcat :: NonEmpty All -> All Source stimes :: Integral b => b -> All -> All Source
Semigroup Void |
Methods (<>) :: Void -> Void -> Void Source sconcat :: NonEmpty Void -> Void Source stimes :: Integral b => b -> Void -> Void Source
Semigroup [a] |
Methods (<>) :: [a] -> [a] -> [a] Source sconcat :: NonEmpty [a] -> [a] Source stimes :: Integral b => b -> [a] -> [a] Source
Semigroup a => Semigroup (Maybe a) |
Methods (<>) :: Maybe a -> Maybe a -> Maybe a Source sconcat :: NonEmpty (Maybe a) -> Maybe a Source stimes :: Integral b => b -> Maybe a -> Maybe a Source
Semigroup (Last a) |
Methods (<>) :: Last a -> Last a -> Last a Source sconcat :: NonEmpty (Last a) -> Last a Source stimes :: Integral b => b -> Last a -> Last a Source
Semigroup (First a) |
Methods (<>) :: First a -> First a -> First a Source sconcat :: NonEmpty (First a) -> First a Source stimes :: Integral b => b -> First a -> First a Source
Num a => Semigroup (Product a) |
Methods (<>) :: Product a -> Product a -> Product a Source sconcat :: NonEmpty (Product a) -> Product a Source stimes :: Integral b => b -> Product a -> Product a Source
Num a => Semigroup (Sum a) |
Methods (<>) :: Sum a -> Sum a -> Sum a Source sconcat :: NonEmpty (Sum a) -> Sum a Source stimes :: Integral b => b -> Sum a -> Sum a Source
Semigroup (Endo a) |
Methods (<>) :: Endo a -> Endo a -> Endo a Source sconcat :: NonEmpty (Endo a) -> Endo a Source stimes :: Integral b => b -> Endo a -> Endo a Source
Semigroup a => Semigroup (Dual a) |
Methods (<>) :: Dual a -> Dual a -> Dual a Source sconcat :: NonEmpty (Dual a) -> Dual a Source stimes :: Integral b => b -> Dual a -> Dual a Source
Semigroup (NonEmpty a) |
Methods (<>) :: NonEmpty a -> NonEmpty a -> NonEmpty a Source sconcat :: NonEmpty (NonEmpty a) -> NonEmpty a Source stimes :: Integral b => b -> NonEmpty a -> NonEmpty a Source
Semigroup a => Semigroup (Option a) |
Methods (<>) :: Option a -> Option a -> Option a Source sconcat :: NonEmpty (Option a) -> Option a Source stimes :: Integral b => b -> Option a -> Option a Source
Monoid m => Semigroup (WrappedMonoid m) |
Methods (<>) :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m Source sconcat :: NonEmpty (WrappedMonoid m) -> WrappedMonoid m Source stimes :: Integral b => b -> WrappedMonoid m -> WrappedMonoid m Source
Semigroup (Last a) |
Methods (<>) :: Last a -> Last a -> Last a Source sconcat :: NonEmpty (Last a) -> Last a Source stimes :: Integral b => b -> Last a -> Last a Source
Semigroup (First a) |
Methods (<>) :: First a -> First a -> First a Source sconcat :: NonEmpty (First a) -> First a Source stimes :: Integral b => b -> First a -> First a Source
Ord a => Semigroup (Max a) |
Methods (<>) :: Max a -> Max a -> Max a Source sconcat :: NonEmpty (Max a) -> Max a Source stimes :: Integral b => b -> Max a -> Max a Source
Ord a => Semigroup (Min a) |
Methods (<>) :: Min a -> Min a -> Min a Source sconcat :: NonEmpty (Min a) -> Min a Source stimes :: Integral b => b -> Min a -> Min a Source
Semigroup a => Semigroup (Identity a) |
Methods (<>) :: Identity a -> Identity a -> Identity a Source sconcat :: NonEmpty (Identity a) -> Identity a Source stimes :: Integral b => b -> Identity a -> Identity a Source
Semigroup b => Semigroup (a -> b) |
Methods (<>) :: (a -> b) -> (a -> b) -> a -> b Source sconcat :: NonEmpty (a -> b) -> a -> b Source stimes :: Integral b => b -> (a -> b) -> a -> b Source
Semigroup (Either a b) |
Methods (<>) :: Either a b -> Either a b -> Either a b Source sconcat :: NonEmpty (Either a b) -> Either a b Source stimes :: Integral b => b -> Either a b -> Either a b Source
(Semigroup a, Semigroup b) => Semigroup (a, b) |
Methods (<>) :: (a, b) -> (a, b) -> (a, b) Source sconcat :: NonEmpty (a, b) -> (a, b) Source stimes :: Integral b => b -> (a, b) -> (a, b) Source
Semigroup (Proxy k s) |
Methods (<>) :: Proxy k s -> Proxy k s -> Proxy k s Source sconcat :: NonEmpty (Proxy k s) -> Proxy k s Source stimes :: Integral b => b -> Proxy k s -> Proxy k s Source
(Semigroup a, Semigroup b, Semigroup c) => Semigroup (a, b, c) |
Methods (<>) :: (a, b, c) -> (a, b, c) -> (a, b, c) Source sconcat :: NonEmpty (a, b, c) -> (a, b, c) Source stimes :: Integral b => b -> (a, b, c) -> (a, b, c) Source
Alternative f => Semigroup (Alt (TYPE Lifted) f a) |
Methods (<>) :: Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f a Source sconcat :: NonEmpty (Alt (TYPE Lifted) f a) -> Alt (TYPE Lifted) f a Source stimes :: Integral b => b -> Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f a Source
Semigroup a => Semigroup (Const k a b) |
Methods (<>) :: Const k a b -> Const k a b -> Const k a b Source sconcat :: NonEmpty (Const k a b) -> Const k a b Source stimes :: Integral b => b -> Const k a b -> Const k a b Source
(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) Source sconcat :: NonEmpty (a, b, c, d) -> (a, b, c, d) Source stimes :: Integral b => b -> (a, b, c, d) -> (a, b, c, d) Source
(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) Source sconcat :: NonEmpty (a, b, c, d, e) -> (a, b, c, d, e) Source stimes :: Integral b => b -> (a, b, c, d, e) -> (a, b, c, d, e) Source

stimesMonoid :: (Integral b, Monoid a) => b -> a -> a Source

This is a valid definition of `stimes` for a `Monoid`.

Unlike the default definition of `stimes`, it is defined for 0 and so it should be preferred where possible.

stimesIdempotent :: Integral b => b -> a -> a Source

This is a valid definition of `stimes` for an idempotent `Semigroup`.

When `x <> x = x`, this definition should be preferred, because it works in O(1) rather than O(log n).

stimesIdempotentMonoid :: (Integral b, Monoid a) => b -> a -> a Source

This is a valid definition of `stimes` for an idempotent `Monoid`.

When `mappend x x = x`, this definition should be preferred, because it works in O(1) rather than O(log n)

mtimesDefault :: (Integral b, Monoid a) => b -> a -> a Source

Repeat a value `n` times.

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

Implemented using `stimes` and `mempty`.

This is a suitable definition for an `mtimes` member of `Monoid`.

# Semigroups

newtype Min a Source

Constructors

Min |
Fields getMin :: a

Instances

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

newtype Max a Source

Constructors

Max |
Fields getMax :: a

Instances

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

newtype First a Source

Use ``Option` (`First` a)` to get the behavior of `First` from Data.Monoid.

Constructors

First |
Fields getFirst :: a

Instances

Monad First |
Methods (>>=) :: First a -> (a -> First b) -> First b Source (>>) :: First a -> First b -> First b Source return :: a -> First a Source fail :: String -> First a Source
Functor First |
Methods fmap :: (a -> b) -> First a -> First b Source (<$) :: a -> First b -> First a Source
MonadFix First |
Methods mfix :: (a -> First a) -> First a Source
Applicative First |
Methods pure :: a -> First a Source (<*>) :: First (a -> b) -> First a -> First b Source (*>) :: First a -> First b -> First b Source (<*) :: First a -> First b -> First a Source
Foldable First |
Methods fold :: Monoid m => First m -> m Source foldMap :: Monoid m => (a -> m) -> First a -> m Source foldr :: (a -> b -> b) -> b -> First a -> b Source foldr' :: (a -> b -> b) -> b -> First a -> b Source foldl :: (b -> a -> b) -> b -> First a -> b Source foldl' :: (b -> a -> b) -> b -> First a -> b Source foldr1 :: (a -> a -> a) -> First a -> a Source foldl1 :: (a -> a -> a) -> First a -> a Source toList :: First a -> [a] Source null :: First a -> Bool Source length :: First a -> Int Source elem :: Eq a => a -> First a -> Bool Source maximum :: Ord a => First a -> a Source minimum :: Ord a => First a -> a Source sum :: Num a => First a -> a Source product :: Num a => First a -> a Source
Traversable First |
Methods traverse :: Applicative f => (a -> f b) -> First a -> f (First b) Source sequenceA :: Applicative f => First (f a) -> f (First a) Source mapM :: Monad m => (a -> m b) -> First a -> m (First b) Source sequence :: Monad m => First (m a) -> m (First a) Source
Generic1 First |
Associated Types type Rep1 (First :: * -> TYPE Lifted) :: * -> * Source Methods from1 :: First a -> Rep1 First a Source to1 :: Rep1 First a -> First a Source
Bounded a => Bounded (First a) |
Methods minBound :: First a Source maxBound :: First a Source
Enum a => Enum (First a) |
Methods succ :: First a -> First a Source pred :: First a -> First a Source toEnum :: Int -> First a Source fromEnum :: First a -> Int Source enumFrom :: First a -> [First a] Source enumFromThen :: First a -> First a -> [First a] Source enumFromTo :: First a -> First a -> [First a] Source enumFromThenTo :: First a -> First a -> First a -> [First a] Source
Eq a => Eq (First a) |
Methods (==) :: First a -> First a -> Bool Source (/=) :: First a -> First a -> Bool Source
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) Source gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (First a) Source toConstr :: First a -> Constr Source dataTypeOf :: First a -> DataType Source dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (First a)) Source dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (First a)) Source gmapT :: (forall b. Data b => b -> b) -> First a -> First a Source gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r Source gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r Source gmapQ :: (forall d. Data d => d -> u) -> First a -> [u] Source gmapQi :: Int -> (forall d. Data d => d -> u) -> First a -> u Source gmapM :: Monad m => (forall d. Data d => d -> m d) -> First a -> m (First a) Source gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) Source gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) Source
Ord a => Ord (First a) |
Methods compare :: First a -> First a -> Ordering Source (<) :: First a -> First a -> Bool Source (<=) :: First a -> First a -> Bool Source (>) :: First a -> First a -> Bool Source (>=) :: First a -> First a -> Bool Source max :: First a -> First a -> First a Source min :: First a -> First a -> First a Source
Read a => Read (First a) |
Methods readsPrec :: Int -> ReadS (First a) Source readList :: ReadS [First a] Source readPrec :: ReadPrec (First a) Source readListPrec :: ReadPrec [First a] Source
Show a => Show (First a) |
Methods showsPrec :: Int -> First a -> ShowS Source show :: First a -> String Source showList :: [First a] -> ShowS Source
Generic (First a) |
Associated Types type Rep (First a) :: * -> * Source Methods from :: First a -> Rep (First a) x Source to :: Rep (First a) x -> First a Source
Semigroup (First a) |
Methods (<>) :: First a -> First a -> First a Source sconcat :: NonEmpty (First a) -> First a Source stimes :: Integral b => b -> First a -> First a Source
type Rep1 First = D1 (MetaData "First" "Data.Semigroup" "base" True) (C1 (MetaCons "First" PrefixI True) (S1 (MetaSel (Just Symbol "getFirst") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1)) |
type Rep (First a) = D1 (MetaData "First" "Data.Semigroup" "base" True) (C1 (MetaCons "First" PrefixI True) (S1 (MetaSel (Just Symbol "getFirst") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a))) |

newtype Last a Source

Use ``Option` (`Last` a)` to get the behavior of `Last` from Data.Monoid

Constructors

Last |
Fields getLast :: a

Instances

Monad Last |
Methods (>>=) :: Last a -> (a -> Last b) -> Last b Source (>>) :: Last a -> Last b -> Last b Source return :: a -> Last a Source fail :: String -> Last a Source
Functor Last |
Methods fmap :: (a -> b) -> Last a -> Last b Source (<$) :: a -> Last b -> Last a Source
MonadFix Last |
Methods mfix :: (a -> Last a) -> Last a Source
Applicative Last |
Methods pure :: a -> Last a Source (<*>) :: Last (a -> b) -> Last a -> Last b Source (*>) :: Last a -> Last b -> Last b Source (<*) :: Last a -> Last b -> Last a Source
Foldable Last |
Methods fold :: Monoid m => Last m -> m Source foldMap :: Monoid m => (a -> m) -> Last a -> m Source foldr :: (a -> b -> b) -> b -> Last a -> b Source foldr' :: (a -> b -> b) -> b -> Last a -> b Source foldl :: (b -> a -> b) -> b -> Last a -> b Source foldl' :: (b -> a -> b) -> b -> Last a -> b Source foldr1 :: (a -> a -> a) -> Last a -> a Source foldl1 :: (a -> a -> a) -> Last a -> a Source toList :: Last a -> [a] Source null :: Last a -> Bool Source length :: Last a -> Int Source elem :: Eq a => a -> Last a -> Bool Source maximum :: Ord a => Last a -> a Source minimum :: Ord a => Last a -> a Source sum :: Num a => Last a -> a Source product :: Num a => Last a -> a Source
Traversable Last |
Methods traverse :: Applicative f => (a -> f b) -> Last a -> f (Last b) Source sequenceA :: Applicative f => Last (f a) -> f (Last a) Source mapM :: Monad m => (a -> m b) -> Last a -> m (Last b) Source sequence :: Monad m => Last (m a) -> m (Last a) Source
Generic1 Last |
Associated Types type Rep1 (Last :: * -> TYPE Lifted) :: * -> * Source Methods from1 :: Last a -> Rep1 Last a Source to1 :: Rep1 Last a -> Last a Source
Bounded a => Bounded (Last a) |
Methods minBound :: Last a Source maxBound :: Last a Source
Enum a => Enum (Last a) |
Methods succ :: Last a -> Last a Source pred :: Last a -> Last a Source toEnum :: Int -> Last a Source fromEnum :: Last a -> Int Source enumFrom :: Last a -> [Last a] Source enumFromThen :: Last a -> Last a -> [Last a] Source enumFromTo :: Last a -> Last a -> [Last a] Source enumFromThenTo :: Last a -> Last a -> Last a -> [Last a] Source
Eq a => Eq (Last a) |
Methods (==) :: Last a -> Last a -> Bool Source (/=) :: Last a -> Last a -> Bool Source
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) Source gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Last a) Source toConstr :: Last a -> Constr Source dataTypeOf :: Last a -> DataType Source dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (Last a)) Source dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Last a)) Source gmapT :: (forall b. Data b => b -> b) -> Last a -> Last a Source gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r Source gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r Source gmapQ :: (forall d. Data d => d -> u) -> Last a -> [u] Source gmapQi :: Int -> (forall d. Data d => d -> u) -> Last a -> u Source gmapM :: Monad m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) Source gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) Source gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) Source
Ord a => Ord (Last a) |
Methods compare :: Last a -> Last a -> Ordering Source (<) :: Last a -> Last a -> Bool Source (<=) :: Last a -> Last a -> Bool Source (>) :: Last a -> Last a -> Bool Source (>=) :: Last a -> Last a -> Bool Source max :: Last a -> Last a -> Last a Source min :: Last a -> Last a -> Last a Source
Read a => Read (Last a) |
Methods readsPrec :: Int -> ReadS (Last a) Source readList :: ReadS [Last a] Source readPrec :: ReadPrec (Last a) Source readListPrec :: ReadPrec [Last a] Source
Show a => Show (Last a) |
Methods showsPrec :: Int -> Last a -> ShowS Source show :: Last a -> String Source showList :: [Last a] -> ShowS Source
Generic (Last a) |
Associated Types type Rep (Last a) :: * -> * Source Methods from :: Last a -> Rep (Last a) x Source to :: Rep (Last a) x -> Last a Source
Semigroup (Last a) |
Methods (<>) :: Last a -> Last a -> Last a Source sconcat :: NonEmpty (Last a) -> Last a Source stimes :: Integral b => b -> Last a -> Last a Source
type Rep1 Last = D1 (MetaData "Last" "Data.Semigroup" "base" True) (C1 (MetaCons "Last" PrefixI True) (S1 (MetaSel (Just Symbol "getLast") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1)) |
type Rep (Last a) = D1 (MetaData "Last" "Data.Semigroup" "base" True) (C1 (MetaCons "Last" PrefixI True) (S1 (MetaSel (Just Symbol "getLast") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a))) |

newtype WrappedMonoid m Source

Provide a Semigroup for an arbitrary Monoid.

Constructors

WrapMonoid |
Fields unwrapMonoid :: m

Instances

Generic1 WrappedMonoid |
Associated Types type Rep1 (WrappedMonoid :: * -> TYPE Lifted) :: * -> * Source Methods from1 :: WrappedMonoid a -> Rep1 WrappedMonoid a Source to1 :: Rep1 WrappedMonoid a -> WrappedMonoid a Source
Bounded a => Bounded (WrappedMonoid a) |
Methods minBound :: WrappedMonoid a Source maxBound :: WrappedMonoid a Source
Enum a => Enum (WrappedMonoid a) |
Methods succ :: WrappedMonoid a -> WrappedMonoid a Source pred :: WrappedMonoid a -> WrappedMonoid a Source toEnum :: Int -> WrappedMonoid a Source fromEnum :: WrappedMonoid a -> Int Source enumFrom :: WrappedMonoid a -> [WrappedMonoid a] Source enumFromThen :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] Source enumFromTo :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] Source enumFromThenTo :: WrappedMonoid a -> WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] Source
Eq m => Eq (WrappedMonoid m) |
Methods (==) :: WrappedMonoid m -> WrappedMonoid m -> Bool Source (/=) :: WrappedMonoid m -> WrappedMonoid m -> Bool Source
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) Source gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WrappedMonoid m) Source toConstr :: WrappedMonoid m -> Constr Source dataTypeOf :: WrappedMonoid m -> DataType Source dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (WrappedMonoid m)) Source dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WrappedMonoid m)) Source gmapT :: (forall b. Data b => b -> b) -> WrappedMonoid m -> WrappedMonoid m Source gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonoid m -> r Source gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonoid m -> r Source gmapQ :: (forall d. Data d => d -> u) -> WrappedMonoid m -> [u] Source gmapQi :: Int -> (forall d. Data d => d -> u) -> WrappedMonoid m -> u Source gmapM :: Monad m => (forall d. Data d => d -> m d) -> WrappedMonoid m -> m (WrappedMonoid m) Source gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WrappedMonoid m -> m (WrappedMonoid m) Source gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WrappedMonoid m -> m (WrappedMonoid m) Source
Ord m => Ord (WrappedMonoid m) |
Methods compare :: WrappedMonoid m -> WrappedMonoid m -> Ordering Source (<) :: WrappedMonoid m -> WrappedMonoid m -> Bool Source (<=) :: WrappedMonoid m -> WrappedMonoid m -> Bool Source (>) :: WrappedMonoid m -> WrappedMonoid m -> Bool Source (>=) :: WrappedMonoid m -> WrappedMonoid m -> Bool Source max :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m Source min :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m Source
Read m => Read (WrappedMonoid m) |
Methods readsPrec :: Int -> ReadS (WrappedMonoid m) Source readList :: ReadS [WrappedMonoid m] Source readPrec :: ReadPrec (WrappedMonoid m) Source readListPrec :: ReadPrec [WrappedMonoid m] Source
Show m => Show (WrappedMonoid m) |
Methods showsPrec :: Int -> WrappedMonoid m -> ShowS Source show :: WrappedMonoid m -> String Source showList :: [WrappedMonoid m] -> ShowS Source
Generic (WrappedMonoid m) |
Associated Types type Rep (WrappedMonoid m) :: * -> * Source Methods from :: WrappedMonoid m -> Rep (WrappedMonoid m) x Source to :: Rep (WrappedMonoid m) x -> WrappedMonoid m Source
Monoid m => Semigroup (WrappedMonoid m) |
Methods (<>) :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m Source sconcat :: NonEmpty (WrappedMonoid m) -> WrappedMonoid m Source stimes :: Integral b => b -> WrappedMonoid m -> WrappedMonoid m Source
Monoid m => Monoid (WrappedMonoid m) |
Methods mempty :: WrappedMonoid m Source mappend :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m Source mconcat :: [WrappedMonoid m] -> WrappedMonoid m Source
type Rep1 WrappedMonoid = D1 (MetaData "WrappedMonoid" "Data.Semigroup" "base" True) (C1 (MetaCons "WrapMonoid" PrefixI True) (S1 (MetaSel (Just Symbol "unwrapMonoid") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1)) |
type Rep (WrappedMonoid m) = D1 (MetaData "WrappedMonoid" "Data.Semigroup" "base" True) (C1 (MetaCons "WrapMonoid" PrefixI True) (S1 (MetaSel (Just Symbol "unwrapMonoid") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 m))) |

# Re-exported monoids from Data.Monoid

class Monoid a where Source

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 Source

Identity of `mappend`

mappend :: a -> a -> a Source

An associative operation

mconcat :: [a] -> a Source

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 |
Methods mempty :: Ordering Source mappend :: Ordering -> Ordering -> Ordering Source mconcat :: [Ordering] -> Ordering Source
Monoid () |
Methods mempty :: () Source mappend :: () -> () -> () Source mconcat :: [()] -> () Source
Monoid Any |
Methods mempty :: Any Source mappend :: Any -> Any -> Any Source mconcat :: [Any] -> Any Source
Monoid All |
Methods mempty :: All Source mappend :: All -> All -> All Source mconcat :: [All] -> All Source
Monoid Lifetime | `mappend` == `elSupremum`
Methods mempty :: Lifetime Source mappend :: Lifetime -> Lifetime -> Lifetime Source mconcat :: [Lifetime] -> Lifetime Source
Monoid Event |
Methods mempty :: Event Source mappend :: Event -> Event -> Event Source mconcat :: [Event] -> Event Source
Monoid [a] |
Methods mempty :: [a] Source mappend :: [a] -> [a] -> [a] Source mconcat :: [[a]] -> [a] Source
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 is no "Semigroup" typeclass providing just `mappend`, we use `Monoid` instead.
Methods mempty :: Maybe a Source mappend :: Maybe a -> Maybe a -> Maybe a Source mconcat :: [Maybe a] -> Maybe a Source
Monoid a => Monoid (IO a) |
Methods mempty :: IO a Source mappend :: IO a -> IO a -> IO a Source mconcat :: [IO a] -> IO a Source
Monoid (Last a) |
Methods mempty :: Last a Source mappend :: Last a -> Last a -> Last a Source mconcat :: [Last a] -> Last a Source
Monoid (First a) |
Methods mempty :: First a Source mappend :: First a -> First a -> First a Source mconcat :: [First a] -> First a Source
Num a => Monoid (Product a) |
Methods mempty :: Product a Source mappend :: Product a -> Product a -> Product a Source mconcat :: [Product a] -> Product a Source
Num a => Monoid (Sum a) |
Methods mempty :: Sum a Source mappend :: Sum a -> Sum a -> Sum a Source mconcat :: [Sum a] -> Sum a Source
Monoid (Endo a) |
Methods mempty :: Endo a Source mappend :: Endo a -> Endo a -> Endo a Source mconcat :: [Endo a] -> Endo a Source
Monoid a => Monoid (Dual a) |
Methods mempty :: Dual a Source mappend :: Dual a -> Dual a -> Dual a Source mconcat :: [Dual a] -> Dual a Source
Semigroup a => Monoid (Option a) |
Methods mempty :: Option a Source mappend :: Option a -> Option a -> Option a Source mconcat :: [Option a] -> Option a Source
Monoid m => Monoid (WrappedMonoid m) |
Methods mempty :: WrappedMonoid m Source mappend :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m Source mconcat :: [WrappedMonoid m] -> WrappedMonoid m Source
(Ord a, Bounded a) => Monoid (Max a) |
Methods mempty :: Max a Source mappend :: Max a -> Max a -> Max a Source mconcat :: [Max a] -> Max a Source
(Ord a, Bounded a) => Monoid (Min a) |
Methods mempty :: Min a Source mappend :: Min a -> Min a -> Min a Source mconcat :: [Min a] -> Min a Source
Monoid a => Monoid (Identity a) |
Methods mempty :: Identity a Source mappend :: Identity a -> Identity a -> Identity a Source mconcat :: [Identity a] -> Identity a Source
Monoid b => Monoid (a -> b) |
Methods mempty :: a -> b Source mappend :: (a -> b) -> (a -> b) -> a -> b Source mconcat :: [a -> b] -> a -> b Source
(Monoid a, Monoid b) => Monoid (a, b) |
Methods mempty :: (a, b) Source mappend :: (a, b) -> (a, b) -> (a, b) Source mconcat :: [(a, b)] -> (a, b) Source
Monoid (Proxy k s) |
Methods mempty :: Proxy k s Source mappend :: Proxy k s -> Proxy k s -> Proxy k s Source mconcat :: [Proxy k s] -> Proxy k s Source
(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c) |
Methods mempty :: (a, b, c) Source mappend :: (a, b, c) -> (a, b, c) -> (a, b, c) Source mconcat :: [(a, b, c)] -> (a, b, c) Source
Alternative f => Monoid (Alt (TYPE Lifted) f a) |
Methods mempty :: Alt (TYPE Lifted) f a Source mappend :: Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f a Source mconcat :: [Alt (TYPE Lifted) f a] -> Alt (TYPE Lifted) f a Source
Monoid a => Monoid (Const k a b) |
Methods mempty :: Const k a b Source mappend :: Const k a b -> Const k a b -> Const k a b Source mconcat :: [Const k a b] -> Const k a b Source
(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d) |
Methods mempty :: (a, b, c, d) Source mappend :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) Source mconcat :: [(a, b, c, d)] -> (a, b, c, d) Source
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e) |
Methods mempty :: (a, b, c, d, e) Source mappend :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) Source mconcat :: [(a, b, c, d, e)] -> (a, b, c, d, e) Source

newtype Dual a Source

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

Constructors

Dual |
Fields getDual :: a

Instances

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

newtype Endo a Source

The monoid of endomorphisms under composition.

Constructors

Endo |
Fields appEndo :: a -> a

Instances

Generic (Endo a) |
Associated Types type Rep (Endo a) :: * -> * Source Methods from :: Endo a -> Rep (Endo a) x Source to :: Rep (Endo a) x -> Endo a Source
Semigroup (Endo a) |
Methods (<>) :: Endo a -> Endo a -> Endo a Source sconcat :: NonEmpty (Endo a) -> Endo a Source stimes :: Integral b => b -> Endo a -> Endo a Source
Monoid (Endo a) |
Methods mempty :: Endo a Source mappend :: Endo a -> Endo a -> Endo a Source mconcat :: [Endo a] -> Endo a Source
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 Source

Boolean monoid under conjunction (`&&`).

Constructors

All |
Fields getAll :: Bool

Instances

Bounded All |
Methods minBound :: All Source maxBound :: All Source
Eq All |
Methods (==) :: All -> All -> Bool Source (/=) :: All -> All -> Bool Source
Data All |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> All -> c All Source gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c All Source toConstr :: All -> Constr Source dataTypeOf :: All -> DataType Source dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c All) Source dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c All) Source gmapT :: (forall b. Data b => b -> b) -> All -> All Source gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> All -> r Source gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> All -> r Source gmapQ :: (forall d. Data d => d -> u) -> All -> [u] Source gmapQi :: Int -> (forall d. Data d => d -> u) -> All -> u Source gmapM :: Monad m => (forall d. Data d => d -> m d) -> All -> m All Source gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> All -> m All Source gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> All -> m All Source
Ord All |
Methods compare :: All -> All -> Ordering Source (<) :: All -> All -> Bool Source (<=) :: All -> All -> Bool Source (>) :: All -> All -> Bool Source (>=) :: All -> All -> Bool Source max :: All -> All -> All Source min :: All -> All -> All Source
Read All |
Methods readsPrec :: Int -> ReadS All Source readList :: ReadS [All] Source readPrec :: ReadPrec All Source readListPrec :: ReadPrec [All] Source
Show All |
Methods showsPrec :: Int -> All -> ShowS Source show :: All -> String Source showList :: [All] -> ShowS Source
Generic All |
Associated Types type Rep All :: * -> * Source Methods from :: All -> Rep All x Source to :: Rep All x -> All Source
Semigroup All |
Methods (<>) :: All -> All -> All Source sconcat :: NonEmpty All -> All Source stimes :: Integral b => b -> All -> All Source
Monoid All |
Methods mempty :: All Source mappend :: All -> All -> All Source mconcat :: [All] -> All Source
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 Source

Boolean monoid under disjunction (`||`).

Constructors

Any |
Fields getAny :: Bool

Instances

Bounded Any |
Methods minBound :: Any Source maxBound :: Any Source
Eq Any |
Methods (==) :: Any -> Any -> Bool Source (/=) :: Any -> Any -> Bool Source
Data Any |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Any -> c Any Source gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Any Source toConstr :: Any -> Constr Source dataTypeOf :: Any -> DataType Source dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c Any) Source dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Any) Source gmapT :: (forall b. Data b => b -> b) -> Any -> Any Source gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Any -> r Source gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Any -> r Source gmapQ :: (forall d. Data d => d -> u) -> Any -> [u] Source gmapQi :: Int -> (forall d. Data d => d -> u) -> Any -> u Source gmapM :: Monad m => (forall d. Data d => d -> m d) -> Any -> m Any Source gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Any -> m Any Source gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Any -> m Any Source
Ord Any |
Methods compare :: Any -> Any -> Ordering Source (<) :: Any -> Any -> Bool Source (<=) :: Any -> Any -> Bool Source (>) :: Any -> Any -> Bool Source (>=) :: Any -> Any -> Bool Source max :: Any -> Any -> Any Source min :: Any -> Any -> Any Source
Read Any |
Methods readsPrec :: Int -> ReadS Any Source readList :: ReadS [Any] Source readPrec :: ReadPrec Any Source readListPrec :: ReadPrec [Any] Source
Show Any |
Methods showsPrec :: Int -> Any -> ShowS Source show :: Any -> String Source showList :: [Any] -> ShowS Source
Generic Any |
Associated Types type Rep Any :: * -> * Source Methods from :: Any -> Rep Any x Source to :: Rep Any x -> Any Source
Semigroup Any |
Methods (<>) :: Any -> Any -> Any Source sconcat :: NonEmpty Any -> Any Source stimes :: Integral b => b -> Any -> Any Source
Monoid Any |
Methods mempty :: Any Source mappend :: Any -> Any -> Any Source mconcat :: [Any] -> Any Source
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 Source

Monoid under addition.

Constructors

Sum |
Fields getSum :: a

Instances

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

newtype Product a Source

Monoid under multiplication.

Constructors

Product |
Fields getProduct :: a

Instances

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

# A better monoid for Maybe

newtype Option a Source

`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`

Constructors

Option |
Fields getOption :: Maybe a

Instances

Monad Option |
Methods (>>=) :: Option a -> (a -> Option b) -> Option b Source (>>) :: Option a -> Option b -> Option b Source return :: a -> Option a Source fail :: String -> Option a Source
Functor Option |
Methods fmap :: (a -> b) -> Option a -> Option b Source (<$) :: a -> Option b -> Option a Source
MonadFix Option |
Methods mfix :: (a -> Option a) -> Option a Source
Applicative Option |
Methods pure :: a -> Option a Source (<*>) :: Option (a -> b) -> Option a -> Option b Source (*>) :: Option a -> Option b -> Option b Source (<*) :: Option a -> Option b -> Option a Source
Foldable Option |
Methods fold :: Monoid m => Option m -> m Source foldMap :: Monoid m => (a -> m) -> Option a -> m Source foldr :: (a -> b -> b) -> b -> Option a -> b Source foldr' :: (a -> b -> b) -> b -> Option a -> b Source foldl :: (b -> a -> b) -> b -> Option a -> b Source foldl' :: (b -> a -> b) -> b -> Option a -> b Source foldr1 :: (a -> a -> a) -> Option a -> a Source foldl1 :: (a -> a -> a) -> Option a -> a Source toList :: Option a -> [a] Source null :: Option a -> Bool Source length :: Option a -> Int Source elem :: Eq a => a -> Option a -> Bool Source maximum :: Ord a => Option a -> a Source minimum :: Ord a => Option a -> a Source sum :: Num a => Option a -> a Source product :: Num a => Option a -> a Source
Traversable Option |
Methods traverse :: Applicative f => (a -> f b) -> Option a -> f (Option b) Source sequenceA :: Applicative f => Option (f a) -> f (Option a) Source mapM :: Monad m => (a -> m b) -> Option a -> m (Option b) Source sequence :: Monad m => Option (m a) -> m (Option a) Source
Generic1 Option |
Associated Types type Rep1 (Option :: * -> TYPE Lifted) :: * -> * Source Methods from1 :: Option a -> Rep1 Option a Source to1 :: Rep1 Option a -> Option a Source
MonadPlus Option |
Methods mzero :: Option a Source mplus :: Option a -> Option a -> Option a Source
Alternative Option |
Methods empty :: Option a Source (<|>) :: Option a -> Option a -> Option a Source some :: Option a -> Option [a] Source many :: Option a -> Option [a] Source
Eq a => Eq (Option a) |
Methods (==) :: Option a -> Option a -> Bool Source (/=) :: Option a -> Option a -> Bool Source
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) Source gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Option a) Source toConstr :: Option a -> Constr Source dataTypeOf :: Option a -> DataType Source dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (Option a)) Source dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Option a)) Source gmapT :: (forall b. Data b => b -> b) -> Option a -> Option a Source gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Option a -> r Source gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Option a -> r Source gmapQ :: (forall d. Data d => d -> u) -> Option a -> [u] Source gmapQi :: Int -> (forall d. Data d => d -> u) -> Option a -> u Source gmapM :: Monad m => (forall d. Data d => d -> m d) -> Option a -> m (Option a) Source gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Option a -> m (Option a) Source gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Option a -> m (Option a) Source
Ord a => Ord (Option a) |
Methods compare :: Option a -> Option a -> Ordering Source (<) :: Option a -> Option a -> Bool Source (<=) :: Option a -> Option a -> Bool Source (>) :: Option a -> Option a -> Bool Source (>=) :: Option a -> Option a -> Bool Source max :: Option a -> Option a -> Option a Source min :: Option a -> Option a -> Option a Source
Read a => Read (Option a) |
Methods readsPrec :: Int -> ReadS (Option a) Source readList :: ReadS [Option a] Source readPrec :: ReadPrec (Option a) Source readListPrec :: ReadPrec [Option a] Source
Show a => Show (Option a) |
Methods showsPrec :: Int -> Option a -> ShowS Source show :: Option a -> String Source showList :: [Option a] -> ShowS Source
Generic (Option a) |
Associated Types type Rep (Option a) :: * -> * Source Methods from :: Option a -> Rep (Option a) x Source to :: Rep (Option a) x -> Option a Source
Semigroup a => Semigroup (Option a) |
Methods (<>) :: Option a -> Option a -> Option a Source sconcat :: NonEmpty (Option a) -> Option a Source stimes :: Integral b => b -> Option a -> Option a Source
Semigroup a => Monoid (Option a) |
Methods mempty :: Option a Source mappend :: Option a -> Option a -> Option a Source mconcat :: [Option a] -> Option a Source
type Rep1 Option = D1 (MetaData "Option" "Data.Semigroup" "base" True) (C1 (MetaCons "Option" PrefixI True) (S1 (MetaSel (Just Symbol "getOption") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 Maybe))) |
type Rep (Option a) = D1 (MetaData "Option" "Data.Semigroup" "base" True) (C1 (MetaCons "Option" PrefixI True) (S1 (MetaSel (Just Symbol "getOption") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe a)))) |

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

Fold an `Option` case-wise, just like `maybe`.

# Difference lists of a semigroup

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

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

cycle1 :: Semigroup m => m -> m Source

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

# ArgMin, ArgMax

data Arg a b Source

`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.

Constructors

Arg a b |

Instances

Bifunctor Arg |
Methods bimap :: (a -> b) -> (c -> d) -> Arg a c -> Arg b d Source first :: (a -> b) -> Arg a c -> Arg b c Source second :: (b -> c) -> Arg a b -> Arg a c Source
Functor (Arg a) |
Methods fmap :: (a -> b) -> Arg a a -> Arg a b Source (<$) :: a -> Arg a b -> Arg a a Source
Foldable (Arg a) |
Methods fold :: Monoid m => Arg a m -> m Source foldMap :: Monoid m => (a -> m) -> Arg a a -> m Source foldr :: (a -> b -> b) -> b -> Arg a a -> b Source foldr' :: (a -> b -> b) -> b -> Arg a a -> b Source foldl :: (b -> a -> b) -> b -> Arg a a -> b Source foldl' :: (b -> a -> b) -> b -> Arg a a -> b Source foldr1 :: (a -> a -> a) -> Arg a a -> a Source foldl1 :: (a -> a -> a) -> Arg a a -> a Source toList :: Arg a a -> [a] Source null :: Arg a a -> Bool Source length :: Arg a a -> Int Source elem :: Eq a => a -> Arg a a -> Bool Source maximum :: Ord a => Arg a a -> a Source minimum :: Ord a => Arg a a -> a Source sum :: Num a => Arg a a -> a Source product :: Num a => Arg a a -> a Source
Traversable (Arg a) |
Methods traverse :: Applicative f => (a -> f b) -> Arg a a -> f (Arg a b) Source sequenceA :: Applicative f => Arg a (f a) -> f (Arg a a) Source mapM :: Monad m => (a -> m b) -> Arg a a -> m (Arg a b) Source sequence :: Monad m => Arg a (m a) -> m (Arg a a) Source
Generic1 (Arg a) |
Associated Types type Rep1 (Arg a :: * -> TYPE Lifted) :: * -> * Source Methods from1 :: Arg a a -> Rep1 (Arg a) a Source to1 :: Rep1 (Arg a) a -> Arg a a Source
Eq a => Eq (Arg a b) |
Methods (==) :: Arg a b -> Arg a b -> Bool Source (/=) :: Arg a b -> Arg a b -> Bool Source
(Data a, Data b) => Data (Arg a b) |
Methods gfoldl :: (forall d c. Data d => c (d -> c) -> d -> c c) -> (forall g. g -> c g) -> Arg a b -> c (Arg a b) Source gunfold :: (forall c r. Data c => c (c -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Arg a b) Source toConstr :: Arg a b -> Constr Source dataTypeOf :: Arg a b -> DataType Source dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (Arg a b)) Source dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Arg a b)) Source gmapT :: (forall c. Data c => c -> c) -> Arg a b -> Arg a b Source gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Arg a b -> r Source gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Arg a b -> r Source gmapQ :: (forall d. Data d => d -> u) -> Arg a b -> [u] Source gmapQi :: Int -> (forall d. Data d => d -> u) -> Arg a b -> u Source gmapM :: Monad m => (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b) Source gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b) Source gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b) Source
Ord a => Ord (Arg a b) |
Methods compare :: Arg a b -> Arg a b -> Ordering Source (<) :: Arg a b -> Arg a b -> Bool Source (<=) :: Arg a b -> Arg a b -> Bool Source (>) :: Arg a b -> Arg a b -> Bool Source (>=) :: Arg a b -> Arg a b -> Bool Source max :: Arg a b -> Arg a b -> Arg a b Source min :: Arg a b -> Arg a b -> Arg a b Source
(Read a, Read b) => Read (Arg a b) |
Methods readsPrec :: Int -> ReadS (Arg a b) Source readList :: ReadS [Arg a b] Source readPrec :: ReadPrec (Arg a b) Source readListPrec :: ReadPrec [Arg a b] Source
(Show a, Show b) => Show (Arg a b) |
Methods showsPrec :: Int -> Arg a b -> ShowS Source show :: Arg a b -> String Source showList :: [Arg a b] -> ShowS Source
Generic (Arg a b) |
Associated Types type Rep (Arg a b) :: * -> * Source Methods from :: Arg a b -> Rep (Arg a b) x Source to :: Rep (Arg a b) x -> Arg a b Source
type Rep1 (Arg a) = D1 (MetaData "Arg" "Data.Semigroup" "base" False) (C1 (MetaCons "Arg" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))) |
type Rep (Arg a b) = D1 (MetaData "Arg" "Data.Semigroup" "base" False) (C1 (MetaCons "Arg" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 b)))) |

type ArgMin a b = Min (Arg a b) Source

type ArgMax a b = Max (Arg a b) Source