base-4.10.1.0: Basic libraries

Copyright | (c) Andy Gill 2001 (c) Oregon Graduate Institute of Science and Technology 2001
License | BSD-style (see the file libraries/base/LICENSE)
Maintainer | libraries@haskell.org
Stability | experimental
Portability | portable
Safe Haskell | Trustworthy
Language | Haskell2010

Data.Monoid

Contents

- `Monoid` typeclass
- `Bool` wrappers
- `Num` wrappers
- `Maybe` wrappers
- `Alternative` wrapper

Description

A class for monoids (types with an associative binary operation that has an identity) with various general-purpose instances.

Synopsis

- class Monoid a where
- (<>) :: Monoid m => m -> m -> m
- 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 First a = First {
  - getFirst :: Maybe a
  }
- newtype Last a = Last {
  - getLast :: Maybe a
  }
- newtype Alt f a = Alt {
  - getAlt :: f a
  }

# `Monoid` typeclass

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 Any # | Since: 2.1
Methods mempty :: Any # mappend :: Any -> Any -> Any # mconcat :: [Any] -> Any #
Monoid All # | Since: 2.1
Methods mempty :: All # mappend :: All -> All -> All # mconcat :: [All] -> All #
Monoid Lifetime # | `mappend` takes the longer of two lifetimes. Since: 4.8.0.0
Methods mempty :: Lifetime # mappend :: Lifetime -> Lifetime -> Lifetime # mconcat :: [Lifetime] -> Lifetime #
Monoid Event # | Since: 4.3.1.0
Methods mempty :: Event # mappend :: Event -> Event -> Event # mconcat :: [Event] -> Event #
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 (Last a) # | Since: 2.1
Methods mempty :: Last a # mappend :: Last a -> Last a -> Last a # mconcat :: [Last a] -> Last a #
Monoid (First a) # | Since: 2.1
Methods mempty :: First a # mappend :: First a -> First a -> First a # mconcat :: [First a] -> First 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 => Monoid (Sum a) # | Since: 2.1
Methods mempty :: Sum a # mappend :: Sum a -> Sum a -> Sum a # mconcat :: [Sum a] -> Sum a #
Monoid (Endo a) # | Since: 2.1
Methods mempty :: Endo a # mappend :: Endo a -> Endo a -> Endo a # mconcat :: [Endo a] -> Endo 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 a => Monoid (Identity a) # |
Methods mempty :: Identity a # mappend :: Identity a -> Identity a -> Identity a # mconcat :: [Identity a] -> Identity a #
Semigroup a => Monoid (Option a) # | Since: 4.9.0.0
Methods mempty :: Option a # mappend :: Option a -> Option a -> Option a # mconcat :: [Option a] -> Option a #
Monoid m => Monoid (WrappedMonoid m) # | Since: 4.9.0.0
Methods mempty :: WrappedMonoid m # mappend :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # mconcat :: [WrappedMonoid m] -> WrappedMonoid m #
(Ord a, Bounded a) => Monoid (Max a) # | Since: 4.9.0.0
Methods mempty :: Max a # mappend :: Max a -> Max a -> Max a # mconcat :: [Max a] -> Max a #
(Ord a, Bounded a) => Monoid (Min a) # | Since: 4.9.0.0
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 #
(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) #
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 (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 #
(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) #

(<>) :: Monoid m => m -> m -> m infixr 6 #

An infix synonym for `mappend`.

Since: 4.5.0.0

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) #
MonadZip Dual # | Since: 4.8.0.0
Methods mzip :: Dual a -> Dual b -> Dual (a, b) # mzipWith :: (a -> b -> c) -> Dual a -> Dual b -> Dual c # munzip :: Dual (a, b) -> (Dual a, Dual b) #
Bounded a => Bounded (Dual a) # |
Methods minBound :: Dual a # maxBound :: Dual a #
Eq a => Eq (Dual a) # |
Methods (==) :: Dual a -> Dual a -> Bool Source # (/=) :: Dual a -> Dual a -> Bool Source #
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 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) # 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 #
Semigroup a => Semigroup (Dual a) # | Since: 4.9.0.0
Methods (<>) :: Dual a -> Dual a -> Dual a # sconcat :: NonEmpty (Dual a) -> Dual a # stimes :: Integral b => b -> Dual a -> 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 #
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 #
Semigroup (Endo a) # | Since: 4.9.0.0
Methods (<>) :: Endo a -> Endo a -> Endo a # sconcat :: NonEmpty (Endo a) -> Endo a # stimes :: Integral b => b -> Endo a -> Endo a #
Monoid (Endo a) # | Since: 2.1
Methods mempty :: Endo a # mappend :: Endo a -> Endo a -> Endo a # mconcat :: [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))))

# `Bool` wrappers

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 Source # (/=) :: All -> All -> Bool Source #
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 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 # 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 #
Semigroup All # | Since: 4.9.0.0
Methods (<>) :: All -> All -> All # sconcat :: NonEmpty All -> All # stimes :: Integral b => b -> All -> All #
Monoid All # | Since: 2.1
Methods mempty :: All # mappend :: All -> All -> All # mconcat :: [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 Source # (/=) :: Any -> Any -> Bool Source #
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 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 # 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 #
Semigroup Any # | Since: 4.9.0.0
Methods (<>) :: Any -> Any -> Any # sconcat :: NonEmpty Any -> Any # stimes :: Integral b => b -> Any -> Any #
Monoid Any # | Since: 2.1
Methods mempty :: Any # mappend :: Any -> Any -> Any # mconcat :: [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)))

# `Num` wrappers

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) #
MonadZip Sum # | Since: 4.8.0.0
Methods mzip :: Sum a -> Sum b -> Sum (a, b) # mzipWith :: (a -> b -> c) -> Sum a -> Sum b -> Sum c # munzip :: Sum (a, b) -> (Sum a, Sum b) #
Bounded a => Bounded (Sum a) # |
Methods minBound :: Sum a # maxBound :: Sum a #
Eq a => Eq (Sum a) # |
Methods (==) :: Sum a -> Sum a -> Bool Source # (/=) :: Sum a -> Sum a -> Bool Source #
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 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) # 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 => Semigroup (Sum a) # | Since: 4.9.0.0
Methods (<>) :: Sum a -> Sum a -> Sum a # sconcat :: NonEmpty (Sum a) -> Sum a # stimes :: Integral b => b -> Sum a -> 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 #
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) #
MonadZip Product # | Since: 4.8.0.0
Methods mzip :: Product a -> Product b -> Product (a, b) # mzipWith :: (a -> b -> c) -> Product a -> Product b -> Product c # munzip :: Product (a, b) -> (Product a, Product b) #
Bounded a => Bounded (Product a) # |
Methods minBound :: Product a # maxBound :: Product a #
Eq a => Eq (Product a) # |
Methods (==) :: Product a -> Product a -> Bool Source # (/=) :: Product a -> Product a -> Bool Source #
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 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) # 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 => Semigroup (Product a) # | Since: 4.9.0.0
Methods (<>) :: Product a -> Product a -> Product a # sconcat :: NonEmpty (Product a) -> Product a # stimes :: Integral b => b -> Product a -> 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 #
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))

# `Maybe` wrappers

To implement `find` or `findLast` on any `Foldable`:

    findLast :: Foldable t => (a -> Bool) -> t a -> Maybe a
    findLast pred = getLast . foldMap (x -> if pred x
                                               then Last (Just x)
                                               else Last Nothing)

Much of Data.Map's interface can be implemented with Data.Map.alter. Some of the rest can be implemented with a new `alterA` function and either `First` or `Last`:

    alterA :: (Applicative f, Ord k) =>
              (Maybe a -> f (Maybe a)) -> k -> Map k a -> f (Map k a)

    instance Monoid a => Applicative ((,) a)  -- from Control.Applicative

    insertLookupWithKey :: Ord k => (k -> v -> v -> v) -> k -> v
                        -> Map k v -> (Maybe v, Map k v)
    insertLookupWithKey combine key value =
      Arrow.first getFirst . alterA doChange key
      where
      doChange Nothing = (First Nothing, Just value)
      doChange (Just oldValue) =
        (First (Just oldValue),
         Just (combine key value oldValue))

newtype First a #

Maybe monoid returning the leftmost non-Nothing value.

``First` a` is isomorphic to ``Alt` `Maybe` a`, but precedes it historically.

Constructors

First |

Fields

- getFirst :: Maybe a

Instances

Monad First # |
Methods (>>=) :: First a -> (a -> First b) -> First b # (>>) :: First a -> First b -> First b # return :: a -> First a # fail :: String -> First a #
Functor First # |
Methods fmap :: (a -> b) -> First a -> First b # (<$) :: a -> First b -> First a #
MonadFix First # | Since: 4.8.0.0
Methods mfix :: (a -> First a) -> First a #
Applicative First # |
Methods pure :: a -> First a # (<*>) :: First (a -> b) -> First a -> First b # liftA2 :: (a -> b -> c) -> First a -> First b -> First c # (*>) :: First a -> First b -> First b # (<*) :: First a -> First b -> First a #
Foldable First # | Since: 4.8.0.0

Methods

fold :: Monoid m => First m -> m #

foldMap :: Monoid m => (a -> m) -> First a -> m #

foldr :: (a -> b -> b) -> b -> First a -> b #

foldr' :: (a -> b -> b) -> b -> First a -> b #

foldl :: (b -> a -> b) -> b -> First a -> b #

foldl' :: (b -> a -> b) -> b -> First a -> b #

foldr1 :: (a -> a -> a) -> First a -> a #

foldl1 :: (a -> a -> a) -> First a -> a #

toList :: First a -> [a] #

null :: First a -> Bool #

length :: First a -> Int #

elem :: Eq a => a -> First a -> Bool #

maximum :: Ord a => First a -> a #

minimum :: Ord a => First a -> a #

sum :: Num a => First a -> a #

product :: Num a => First a -> a #

Traversable First # | Since: 4.8.0.0
Methods traverse :: Applicative f => (a -> f b) -> First a -> f (First b) # sequenceA :: Applicative f => First (f a) -> f (First a) # mapM :: Monad m => (a -> m b) -> First a -> m (First b) # sequence :: Monad m => First (m a) -> m (First a) #
MonadZip First # | Since: 4.8.0.0
Methods mzip :: First a -> First b -> First (a, b) # mzipWith :: (a -> b -> c) -> First a -> First b -> First c # munzip :: First (a, b) -> (First a, First b) #
Eq a => Eq (First a) # |
Methods (==) :: First a -> First a -> Bool Source # (/=) :: First a -> First a -> Bool Source #
Data a => Data (First a) # | Since: 4.8.0.0

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 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) # 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 #
Generic (First a) # |
Associated Types type Rep (First a) :: * -> * # Methods from :: First a -> Rep (First a) x # to :: Rep (First a) x -> First a #
Semigroup (First a) # | Since: 4.9.0.0
Methods (<>) :: First a -> First a -> First a # sconcat :: NonEmpty (First a) -> First a # stimes :: Integral b => b -> First a -> First a #
Monoid (First a) # | Since: 2.1
Methods mempty :: First a # mappend :: First a -> First a -> First a # mconcat :: [First a] -> First a #
Generic1 * First # |
Associated Types type Rep1 First (f :: First -> *) :: k -> * # Methods from1 :: f a -> Rep1 First f a # to1 :: Rep1 First f a -> f a #
type Rep (First a) # |
type Rep (First a) = D1 * (MetaData "First" "Data.Monoid" "base" True) (C1 * (MetaCons "First" PrefixI True) (S1 * (MetaSel (Just Symbol "getFirst") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe a))))
type Rep1 * First # |
type Rep1 * First = D1 * (MetaData "First" "Data.Monoid" "base" True) (C1 * (MetaCons "First" PrefixI True) (S1 * (MetaSel (Just Symbol "getFirst") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 * Maybe)))

newtype Last a #

Maybe monoid returning the rightmost non-Nothing value.

``Last` a` is isomorphic to ``Dual` (`First` a)`, and thus to ``Dual` (`Alt` `Maybe` a)`

Constructors

Last |

Fields

- getLast :: Maybe a

Instances

Monad Last # |
Methods (>>=) :: Last a -> (a -> Last b) -> Last b # (>>) :: Last a -> Last b -> Last b # return :: a -> Last a # fail :: String -> Last a #
Functor Last # |
Methods fmap :: (a -> b) -> Last a -> Last b # (<$) :: a -> Last b -> Last a #
MonadFix Last # | Since: 4.8.0.0
Methods mfix :: (a -> Last a) -> Last a #
Applicative Last # |
Methods pure :: a -> Last a # (<*>) :: Last (a -> b) -> Last a -> Last b # liftA2 :: (a -> b -> c) -> Last a -> Last b -> Last c # (*>) :: Last a -> Last b -> Last b # (<*) :: Last a -> Last b -> Last a #
Foldable Last # | Since: 4.8.0.0

Methods

fold :: Monoid m => Last m -> m #

foldMap :: Monoid m => (a -> m) -> Last a -> m #

foldr :: (a -> b -> b) -> b -> Last a -> b #

foldr' :: (a -> b -> b) -> b -> Last a -> b #

foldl :: (b -> a -> b) -> b -> Last a -> b #

foldl' :: (b -> a -> b) -> b -> Last a -> b #

foldr1 :: (a -> a -> a) -> Last a -> a #

foldl1 :: (a -> a -> a) -> Last a -> a #

toList :: Last a -> [a] #

null :: Last a -> Bool #

length :: Last a -> Int #

elem :: Eq a => a -> Last a -> Bool #

maximum :: Ord a => Last a -> a #

minimum :: Ord a => Last a -> a #

sum :: Num a => Last a -> a #

product :: Num a => Last a -> a #

Traversable Last # | Since: 4.8.0.0
Methods traverse :: Applicative f => (a -> f b) -> Last a -> f (Last b) # sequenceA :: Applicative f => Last (f a) -> f (Last a) # mapM :: Monad m => (a -> m b) -> Last a -> m (Last b) # sequence :: Monad m => Last (m a) -> m (Last a) #
MonadZip Last # | Since: 4.8.0.0
Methods mzip :: Last a -> Last b -> Last (a, b) # mzipWith :: (a -> b -> c) -> Last a -> Last b -> Last c # munzip :: Last (a, b) -> (Last a, Last b) #
Eq a => Eq (Last a) # |
Methods (==) :: Last a -> Last a -> Bool Source # (/=) :: Last a -> Last a -> Bool Source #
Data a => Data (Last a) # | Since: 4.8.0.0

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 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) # 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 #
Generic (Last a) # |
Associated Types type Rep (Last a) :: * -> * # Methods from :: Last a -> Rep (Last a) x # to :: Rep (Last a) x -> Last a #
Semigroup (Last a) # | Since: 4.9.0.0
Methods (<>) :: Last a -> Last a -> Last a # sconcat :: NonEmpty (Last a) -> Last a # stimes :: Integral b => b -> Last a -> Last a #
Monoid (Last a) # | Since: 2.1
Methods mempty :: Last a # mappend :: Last a -> Last a -> Last a # mconcat :: [Last a] -> Last a #
Generic1 * Last # |
Associated Types type Rep1 Last (f :: Last -> *) :: k -> * # Methods from1 :: f a -> Rep1 Last f a # to1 :: Rep1 Last f a -> f a #
type Rep (Last a) # |
type Rep (Last a) = D1 * (MetaData "Last" "Data.Monoid" "base" True) (C1 * (MetaCons "Last" PrefixI True) (S1 * (MetaSel (Just Symbol "getLast") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe a))))
type Rep1 * Last # |
type Rep1 * Last = D1 * (MetaData "Last" "Data.Monoid" "base" True) (C1 * (MetaCons "Last" PrefixI True) (S1 * (MetaSel (Just Symbol "getLast") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 * Maybe)))

# `Alternative` wrapper

newtype Alt f a #

Monoid under `<|>`.

Since: 4.8.0.0

Constructors

Alt |

Fields

- getAlt :: f a

Instances

Generic1 k (Alt k f) # |
Associated Types type Rep1 (Alt k f) (f :: Alt k f -> *) :: k -> * # Methods from1 :: f a -> Rep1 (Alt k f) f a # to1 :: Rep1 (Alt k f) f a -> f a #
Monad f => Monad (Alt * f) # |
Methods (>>=) :: Alt * f a -> (a -> Alt * f b) -> Alt * f b # (>>) :: Alt * f a -> Alt * f b -> Alt * f b # return :: a -> Alt * f a # fail :: String -> Alt * f a #
Functor f => Functor (Alt * f) # |
Methods fmap :: (a -> b) -> Alt * f a -> Alt * f b # (<$) :: a -> Alt * f b -> Alt * f a #
MonadFix f => MonadFix (Alt * f) # | Since: 4.8.0.0
Methods mfix :: (a -> Alt * f a) -> Alt * f a #
Applicative f => Applicative (Alt * f) # |
Methods pure :: a -> Alt * f a # (<*>) :: Alt * f (a -> b) -> Alt * f a -> Alt * f b # liftA2 :: (a -> b -> c) -> Alt * f a -> Alt * f b -> Alt * f c # (*>) :: Alt * f a -> Alt * f b -> Alt * f b # (<*) :: Alt * f a -> Alt * f b -> Alt * f a #
MonadPlus f => MonadPlus (Alt * f) # |
Methods mzero :: Alt * f a # mplus :: Alt * f a -> Alt * f a -> Alt * f a #
Alternative f => Alternative (Alt * f) # |
Methods empty :: Alt * f a # (<|>) :: Alt * f a -> Alt * f a -> Alt * f a # some :: Alt * f a -> Alt * f [a] # many :: Alt * f a -> Alt * f [a] #
MonadZip f => MonadZip (Alt * f) # | Since: 4.8.0.0
Methods mzip :: Alt * f a -> Alt * f b -> Alt * f (a, b) # mzipWith :: (a -> b -> c) -> Alt * f a -> Alt * f b -> Alt * f c # munzip :: Alt * f (a, b) -> (Alt * f a, Alt * f b) #
Enum (f a) => Enum (Alt k f a) # |
Methods succ :: Alt k f a -> Alt k f a # pred :: Alt k f a -> Alt k f a # toEnum :: Int -> Alt k f a # fromEnum :: Alt k f a -> Int # enumFrom :: Alt k f a -> [Alt k f a] # enumFromThen :: Alt k f a -> Alt k f a -> [Alt k f a] # enumFromTo :: Alt k f a -> Alt k f a -> [Alt k f a] # enumFromThenTo :: Alt k f a -> Alt k f a -> Alt k f a -> [Alt k f a] #
Eq (f a) => Eq (Alt k f a) # |
Methods (==) :: Alt k f a -> Alt k f a -> Bool Source # (/=) :: Alt k f a -> Alt k f a -> Bool Source #
(Data (f a), Data a, Typeable (* -> *) f) => Data (Alt * f a) # | Since: 4.8.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Alt * f a -> c (Alt * f a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Alt * f a) #

toConstr :: Alt * f a -> Constr #

dataTypeOf :: Alt * f a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Alt * f a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt * f a)) #

gmapT :: (forall b. Data b => b -> b) -> Alt * f a -> Alt * f a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt * f a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt * f a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Alt * f a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Alt * f a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Alt * f a -> m (Alt * f a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt * f a -> m (Alt * f a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt * f a -> m (Alt * f a) #

Num (f a) => Num (Alt k f a) # |
Methods (+) :: Alt k f a -> Alt k f a -> Alt k f a # (-) :: Alt k f a -> Alt k f a -> Alt k f a # (*) :: Alt k f a -> Alt k f a -> Alt k f a # negate :: Alt k f a -> Alt k f a # abs :: Alt k f a -> Alt k f a # signum :: Alt k f a -> Alt k f a # fromInteger :: Integer -> Alt k f a #
Ord (f a) => Ord (Alt k f a) # |
Methods compare :: Alt k f a -> Alt k f a -> Ordering Source # (<) :: Alt k f a -> Alt k f a -> Bool Source # (<=) :: Alt k f a -> Alt k f a -> Bool Source # (>) :: Alt k f a -> Alt k f a -> Bool Source # (>=) :: Alt k f a -> Alt k f a -> Bool Source # max :: Alt k f a -> Alt k f a -> Alt k f a Source # min :: Alt k f a -> Alt k f a -> Alt k f a Source #
Read (f a) => Read (Alt k f a) # |
Methods readsPrec :: Int -> ReadS (Alt k f a) # readList :: ReadS [Alt k f a] # readPrec :: ReadPrec (Alt k f a) # readListPrec :: ReadPrec [Alt k f a] #
Show (f a) => Show (Alt k f a) # |
Methods showsPrec :: Int -> Alt k f a -> ShowS # show :: Alt k f a -> String # showList :: [Alt k f a] -> ShowS #
Generic (Alt k f a) # |
Associated Types type Rep (Alt k f a) :: * -> * # Methods from :: Alt k f a -> Rep (Alt k f a) x # to :: Rep (Alt k f a) x -> Alt k f a #
Alternative f => Semigroup (Alt * f a) # | Since: 4.9.0.0
Methods (<>) :: Alt * f a -> Alt * f a -> Alt * f a # sconcat :: NonEmpty (Alt * f a) -> Alt * f a # stimes :: Integral b => b -> Alt * f a -> Alt * f a #
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 #
type Rep1 k (Alt k f) # |
type Rep1 k (Alt k f) = D1 k (MetaData "Alt" "Data.Monoid" "base" True) (C1 k (MetaCons "Alt" PrefixI True) (S1 k (MetaSel (Just Symbol "getAlt") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 k f)))
type Rep (Alt k f a) # |
type Rep (Alt k f a) = D1 * (MetaData "Alt" "Data.Monoid" "base" True) (C1 * (MetaCons "Alt" PrefixI True) (S1 * (MetaSel (Just Symbol "getAlt") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (f a))))