base-4.9.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 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 * f a) # |
Methods mempty :: Alt * f a Source # mappend :: Alt * f a -> Alt * f a -> Alt * f a Source # mconcat :: [Alt * f a] -> Alt * 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 #

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

An infix synonym for `mappend`.

Since: 4.5.0.0

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 :: * -> *) :: * -> * 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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Dual a)) Source # dataCast2 :: Typeable (* -> * -> *) 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 # |
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) # |
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) # |
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 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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c All) Source # dataCast2 :: Typeable (* -> * -> *) 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 # |
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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Any) Source # dataCast2 :: Typeable (* -> * -> *) 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 # |
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 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 :: * -> *) :: * -> * 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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Sum a)) Source # dataCast2 :: Typeable (* -> * -> *) 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 # |
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) # |
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 :: * -> *) :: * -> * 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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Product a)) Source # dataCast2 :: Typeable (* -> * -> *) 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 # |
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) # |
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)))

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

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 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 :: * -> *) :: * -> * Source # Methods from1 :: First a -> Rep1 First a Source # to1 :: Rep1 First a -> First a Source #
MonadZip First # |
Methods mzip :: First a -> First b -> First (a, b) Source # mzipWith :: (a -> b -> c) -> First a -> First b -> First c Source # munzip :: First (a, b) -> (First a, First b) 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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (First a)) Source # dataCast2 :: Typeable (* -> * -> *) 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 #
Monoid (First a) # |
Methods mempty :: First a Source # mappend :: First a -> First a -> First a Source # mconcat :: [First a] -> First a Source #
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)))
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))))

newtype Last a Source #

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 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 :: * -> *) :: * -> * Source # Methods from1 :: Last a -> Rep1 Last a Source # to1 :: Rep1 Last a -> Last a Source #
MonadZip Last # |
Methods mzip :: Last a -> Last b -> Last (a, b) Source # mzipWith :: (a -> b -> c) -> Last a -> Last b -> Last c Source # munzip :: Last (a, b) -> (Last a, Last b) 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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Last a)) Source # dataCast2 :: Typeable (* -> * -> *) 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 #
Monoid (Last a) # |
Methods mempty :: Last a Source # mappend :: Last a -> Last a -> Last a Source # mconcat :: [Last a] -> Last a Source #
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)))
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))))

# `Alternative` wrapper

newtype Alt f a Source #

Monoid under `<|>`.

Since: 4.8.0.0

Constructors

Alt |
Fields getAlt :: f a

Instances

Monad f => Monad (Alt * f) # |
Methods (>>=) :: Alt * f a -> (a -> Alt * f b) -> Alt * f b Source # (>>) :: Alt * f a -> Alt * f b -> Alt * f b Source # return :: a -> Alt * f a Source # fail :: String -> Alt * f a Source #
Functor f => Functor (Alt * f) # |
Methods fmap :: (a -> b) -> Alt * f a -> Alt * f b Source # (<$) :: a -> Alt * f b -> Alt * f a Source #
MonadFix f => MonadFix (Alt * f) # |
Methods mfix :: (a -> Alt * f a) -> Alt * f a Source #
Applicative f => Applicative (Alt * f) # |
Methods pure :: a -> Alt * f a Source # (<*>) :: Alt * f (a -> b) -> Alt * f a -> Alt * f b Source # (*>) :: Alt * f a -> Alt * f b -> Alt * f b Source # (<*) :: Alt * f a -> Alt * f b -> Alt * f a Source #
Generic1 (Alt * f) # |
Associated Types type Rep1 (Alt * f :: * -> *) :: * -> * Source # Methods from1 :: Alt * f a -> Rep1 (Alt * f) a Source # to1 :: Rep1 (Alt * f) a -> Alt * f a Source #
MonadPlus f => MonadPlus (Alt * f) # |
Methods mzero :: Alt * f a Source # mplus :: Alt * f a -> Alt * f a -> Alt * f a Source #
Alternative f => Alternative (Alt * f) # |
Methods empty :: Alt * f a Source # (<|>) :: Alt * f a -> Alt * f a -> Alt * f a Source # some :: Alt * f a -> Alt * f [a] Source # many :: Alt * f a -> Alt * f [a] Source #
MonadZip f => MonadZip (Alt * f) # |
Methods mzip :: Alt * f a -> Alt * f b -> Alt * f (a, b) Source # mzipWith :: (a -> b -> c) -> Alt * f a -> Alt * f b -> Alt * f c Source # munzip :: Alt * f (a, b) -> (Alt * f a, Alt * f b) Source #
Enum (f a) => Enum (Alt k f a) # |
Methods succ :: Alt k f a -> Alt k f a Source # pred :: Alt k f a -> Alt k f a Source # toEnum :: Int -> Alt k f a Source # fromEnum :: Alt k f a -> Int Source # enumFrom :: Alt k f a -> [Alt k f a] Source # enumFromThen :: Alt k f a -> Alt k f a -> [Alt k f a] Source # enumFromTo :: Alt k f a -> Alt k f a -> [Alt k f a] Source # enumFromThenTo :: Alt k f a -> Alt k f a -> Alt k f a -> [Alt k f a] Source #
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) # |
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) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Alt * f a) Source # toConstr :: Alt * f a -> Constr Source # dataTypeOf :: Alt * f a -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Alt * f a)) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt * f a)) Source # gmapT :: (forall b. Data b => b -> b) -> Alt * f a -> Alt * f a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt * f a -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt * f a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Alt * f a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Alt * f a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Alt * f a -> m (Alt * f a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt * f a -> m (Alt * f a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt * f a -> m (Alt * f a) Source #
Num (f a) => Num (Alt k f a) # |
Methods (+) :: Alt k f a -> Alt k f a -> Alt k f a Source # (-) :: Alt k f a -> Alt k f a -> Alt k f a Source # (*) :: Alt k f a -> Alt k f a -> Alt k f a Source # negate :: Alt k f a -> Alt k f a Source # abs :: Alt k f a -> Alt k f a Source # signum :: Alt k f a -> Alt k f a Source # fromInteger :: Integer -> Alt k f a Source #
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) Source # readList :: ReadS [Alt k f a] Source # readPrec :: ReadPrec (Alt k f a) Source # readListPrec :: ReadPrec [Alt k f a] Source #
Show (f a) => Show (Alt k f a) # |
Methods showsPrec :: Int -> Alt k f a -> ShowS Source # show :: Alt k f a -> String Source # showList :: [Alt k f a] -> ShowS Source #
Generic (Alt k f a) # |
Associated Types type Rep (Alt k f a) :: * -> * Source # Methods from :: Alt k f a -> Rep (Alt k f a) x Source # to :: Rep (Alt k f a) x -> Alt k f a Source #
Alternative f => Semigroup (Alt * f a) # |
Methods (<>) :: Alt * f a -> Alt * f a -> Alt * f a Source # sconcat :: NonEmpty (Alt * f a) -> Alt * f a Source # stimes :: Integral b => b -> Alt * f a -> Alt * f a Source #
Alternative f => Monoid (Alt * f a) # |
Methods mempty :: Alt * f a Source # mappend :: Alt * f a -> Alt * f a -> Alt * f a Source # mconcat :: [Alt * f a] -> Alt * f a Source #
type Rep1 (Alt * f) # |
type Rep1 (Alt * f) = D1 (MetaData "Alt" "Data.Monoid" "base" True) (C1 (MetaCons "Alt" PrefixI True) (S1 (MetaSel (Just Symbol "getAlt") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 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))))