-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Lots of Monoids
--   
--   Lots of Monoids
@package monoids
@version 0.1.2

module Data.Monoid.Reducer
class (Monoid m) => Reducer c m
unit :: (Reducer c m) => c -> m
snoc :: (Reducer c m) => m -> c -> m
cons :: (Reducer c m) => c -> m -> m
foldMapReduce :: (Foldable f, Reducer e m) => (a -> e) -> f a -> m
foldReduce :: (Foldable f, Reducer e m) => f e -> m
instance (Ord k) => Reducer (k, v) (Map k v)
instance Reducer (Int, v) (IntMap v)
instance (Ord a) => Reducer a (Set a)
instance Reducer Int IntSet
instance Reducer a (Seq a)
instance (Measured v a) => Reducer a (FingerTree v a)
instance (Measured v a) => Monoid (FingerTree v a)
instance Reducer a (Last a)
instance Reducer (Maybe a) (Last a)
instance Reducer a (First a)
instance Reducer (Maybe a) (First a)
instance (Num a) => Reducer a (Product a)
instance (Num a) => Reducer a (Sum a)
instance (Monoid a) => Reducer a (Dual a)
instance Reducer (a -> a) (Endo a)
instance Reducer Bool All
instance Reducer Bool Any
instance Reducer c ()
instance Reducer c [c]
instance (Reducer c m, Reducer c n, Reducer c o, Reducer c p) => Reducer c (m, n, o, p)
instance (Reducer c m, Reducer c n, Reducer c o) => Reducer c (m, n, o)
instance (Reducer c m, Reducer c n) => Reducer c (m, n)

module Data.Monoid.Reducer.Char
class (Reducer Char m) => CharReducer m
fromChar :: (CharReducer m) => Char -> m
invalidChar :: (CharReducer m) => [Word8] -> m
instance CharReducer [Char]
instance (CharReducer m, CharReducer m', CharReducer m'', CharReducer m''') => CharReducer (m, m', m'', m''')
instance (CharReducer m, CharReducer m', CharReducer m'') => CharReducer (m, m', m'')
instance (CharReducer m, CharReducer m') => CharReducer (m, m')

module Data.Monoid.Reducer.With
newtype WithReducer c m
WithReducer :: (m, c) -> WithReducer c m
runWithReducer :: WithReducer c m -> (m, c)
withoutReducer :: c WithReducer m -> c
instance (Reducer c m) => Measured m (WithReducer c m)
instance (Reducer c m) => Reducer (WithReducer c m) m

module Data.Monoid.Unit
newtype Unit c
Unit :: () -> Unit c
getUnit :: Unit c -> ()
instance Pointed Unit
instance Functor Unit
instance CharReducer (Unit Char)
instance Reducer c (Unit c)
instance Monoid (Unit c)

module Data.Monoid.Ord

-- | The <a>Monoid</a> <tt>(<a>max</a>,<a>minBound</a>)</tt>
newtype Max a
Max :: a -> Max a
getMax :: Max a -> a

-- | The <a>Monoid</a> given by <tt>(<a>min</a>,<a>maxBound</a>)</tt>
newtype Min a
Min :: a -> Min a
getMin :: Min a -> a

-- | The <a>Monoid</a> <tt>(<a>max</a>,<a>Nothing</a>)</tt> over
--   <tt><a>Maybe</a> a</tt> where <a>Nothing</a> is the bottom element
newtype MaxPriority a
MaxPriority :: Maybe a -> MaxPriority a
getMaxPriority :: MaxPriority a -> Maybe a

-- | The <a>Monoid</a> <tt>(<a>min</a>,<a>Nothing</a>)</tt> over
--   <tt><a>Maybe</a> a</tt> where <a>Nothing</a> is the top element
newtype MinPriority a
MinPriority :: Maybe a -> MinPriority a
getMinPriority :: MinPriority a -> Maybe a
instance (Eq a) => Eq (MinPriority a)
instance (Show a) => Show (MinPriority a)
instance (Read a) => Read (MinPriority a)
instance (Eq a) => Eq (MaxPriority a)
instance (Ord a) => Ord (MaxPriority a)
instance (Show a) => Show (MaxPriority a)
instance (Read a) => Read (MaxPriority a)
instance (Eq a) => Eq (Min a)
instance (Ord a) => Ord (Min a)
instance (Show a) => Show (Min a)
instance (Read a) => Read (Min a)
instance (Bounded a) => Bounded (Min a)
instance (Eq a) => Eq (Max a)
instance (Ord a) => Ord (Max a)
instance (Show a) => Show (Max a)
instance (Read a) => Read (Max a)
instance (Bounded a) => Bounded (Max a)
instance Pointed MinPriority
instance Functor MinPriority
instance (Ord a) => Reducer (Maybe a) (MinPriority a)
instance (Ord a) => Monoid (MinPriority a)
instance (Ord a) => Ord (MinPriority a)
instance Pointed MaxPriority
instance Functor MaxPriority
instance (Ord a) => Reducer (Maybe a) (MaxPriority a)
instance (Ord a) => Monoid (MaxPriority a)
instance Copointed Min
instance Pointed Min
instance Functor Min
instance (Ord a, Bounded a) => Reducer a (Min a)
instance (Ord a, Bounded a) => Monoid (Min a)
instance Copointed Max
instance Pointed Max
instance Functor Max
instance (Ord a, Bounded a) => Reducer a (Max a)
instance (Ord a, Bounded a) => Monoid (Max a)

module Data.Monoid.Monad.Writer.Strict
instance (Monad m, Monoid w, Monoid n) => Reducer (m n) (WriterT w m n)
instance (Monad m, Monoid w, Monoid n) => Reducer n (WriterT w m n)
instance (Monoid w, Monoid m) => Reducer m (Writer w m)
instance (Monad m, Monoid w, Monoid n) => Monoid (WriterT w m n)
instance (Monoid w, Monoid m) => Monoid (Writer w m)

module Data.Monoid.Monad.Writer.Lazy
instance (Monad m, Monoid w, Monoid n) => Reducer (m n) (WriterT w m n)
instance (Monad m, Monoid w, Monoid n) => Reducer n (WriterT w m n)
instance (Monoid w, Monoid m) => Reducer m (Writer w m)
instance (Monad m, Monoid w, Monoid n) => Monoid (WriterT w m n)
instance (Monoid w, Monoid m) => Monoid (Writer w m)

module Data.Monoid.Monad.ST.Strict
instance (Monoid m) => Reducer m (ST s m)
instance (Monoid m) => Monoid (ST s m)

module Data.Monoid.Monad.STM
instance (Monoid m) => Reducer m (STM m)
instance (Monoid m) => Monoid (STM m)

module Data.Monoid.Monad.ST.Lazy
instance (Monoid m) => Reducer m (ST s m)
instance (Monoid m) => Monoid (ST s m)

module Data.Monoid.Monad.State.Strict
instance (Monad m, Monoid n) => Reducer (m n) (StateT s m n)
instance (Monad m, Monoid n) => Reducer n (StateT s m n)
instance (Monoid m) => Reducer m (State s m)
instance (Monad m, Monoid n) => Monoid (StateT s m n)
instance (Monoid m) => Monoid (State s m)

module Data.Monoid.Monad.State.Lazy
instance (Monad m, Monoid n) => Reducer (m n) (StateT s m n)
instance (Monad m, Monoid n) => Reducer n (StateT s m n)
instance (Monoid m) => Reducer m (State s m)
instance (Monad m, Monoid n) => Monoid (StateT s m n)
instance (Monoid m) => Monoid (State s m)

module Data.Monoid.Monad.RWS.Strict
instance (Monad m, Monoid w, Monoid n) => Reducer (m n) (RWST r w s m n)
instance (Monad m, Monoid w, Monoid n) => Reducer n (RWST r w s m n)
instance (Monoid w, Monoid m) => Reducer m (RWS r w s m)
instance (Monad m, Monoid w, Monoid n) => Monoid (RWST r w s m n)
instance (Monoid w, Monoid m) => Monoid (RWS r w s m)

module Data.Monoid.Monad.RWS.Lazy
instance (Monad m, Monoid w, Monoid n) => Reducer (m n) (RWST r w s m n)
instance (Monad m, Monoid w, Monoid n) => Reducer n (RWST r w s m n)
instance (Monoid w, Monoid m) => Reducer m (RWS r w s m)
instance (Monad m, Monoid w, Monoid n) => Monoid (RWST r w s m n)
instance (Monoid w, Monoid m) => Monoid (RWS r w s m)

module Data.Monoid.Monad.Reader
instance (Monad m, Monoid n) => Reducer (m n) (ReaderT e m n)
instance (Monad m, Monoid n) => Reducer n (ReaderT e m n)
instance (Monad m, Monoid n) => Monoid (ReaderT e m n)
instance (Monoid m) => Reducer m (Reader e m)
instance (Monoid m) => Monoid (Reader e m)

module Data.Monoid.Monad.IO
instance (Monoid m) => Reducer (STM m) (IO m)
instance (Monoid m) => Reducer (ST RealWorld m) (IO m)
instance (Monoid m) => Reducer m (IO m)
instance (Monoid m) => Monoid (IO m)

module Data.Monoid.Monad.Identity
instance (Monoid m) => Reducer m (Identity m)
instance (Monoid m) => Monoid (Identity m)

module Data.Monoid.Monad.Either
instance (Monad m, Monoid n) => Reducer (m n) (EitherT e m n)
instance (Monad m, Monoid n) => Reducer n (EitherT e m n)
instance (Monad m, Monoid n) => Monoid (EitherT e m n)
instance (Monoid m) => Reducer m (Either e m)
instance (Monoid m) => Monoid (Either e m)

module Data.Monoid.Monad.Cont
instance (Monad m, Monoid n) => Reducer (m n) (ContT r m n)
instance (Monad m, Monoid n) => Reducer n (ContT r m n)
instance (Monoid m) => Reducer m (Cont r m)
instance (Monad m, Monoid n) => Monoid (ContT r m n)
instance (Monoid m) => Monoid (Cont r m)

module Data.Monoid.Monad
newtype Action m
Action :: m () -> Action m
getAction :: Action m -> m ()
newtype MonadSum m a
MonadSum :: m a -> MonadSum m a
getMonadSum :: MonadSum m a -> m a
newtype ActionWith m n
ActionWith :: m n -> ActionWith m n
getActionWith :: ActionWith m n -> m n
instance (Eq (m a)) => Eq (MonadSum m a)
instance (Ord (m a)) => Ord (MonadSum m a)
instance (Show (m a)) => Show (MonadSum m a)
instance (Read (m a)) => Read (MonadSum m a)
instance (Functor m) => Functor (MonadSum m)
instance (Monad m) => Monad (MonadSum m)
instance (MonadPlus m) => MonadPlus (MonadSum m)
instance (Monad m, Monoid n) => Reducer (m n) (ActionWith m n)
instance (Monad m, Monoid n) => Monoid (ActionWith m n)
instance (MonadPlus m) => Reducer (m a) (MonadSum m a)
instance (MonadPlus m) => Monoid (MonadSum m a)
instance (Monad m) => Reducer (m a) (Action m)
instance (Monad m) => Monoid (Action m)

module Data.Monoid.Map
data UnionWith k m
instance (Ord k, Monoid m) => Reducer (Map k m) (UnionWith k m)
instance (Ord k, Monoid m) => Monoid (UnionWith k m)

module Data.Monoid.Lexical.UTF8.Decoder
data UTF8 m
runUTF8 :: (CharReducer m) => UTF8 m -> m
instance Pointed UTF8
instance Functor UTF8
instance (CharReducer m) => Reducer Word8 (UTF8 m)
instance (CharReducer m) => Monoid (UTF8 m)

module Data.Monoid.Lexical.SourcePosition
data SourcePosition file
type SourceLine = Int
type SourceColumn = Int
sourceLine :: SourcePosition f -> Maybe SourceLine
sourceColumn :: SourcePosition f -> Maybe SourceColumn
startOfFile :: f -> SourcePosition f
showSourcePosition :: SourcePosition String -> String
instance (Read file) => Read (SourcePosition file)
instance (Show file) => Show (SourcePosition file)
instance (Eq file) => Eq (SourcePosition file)
instance CharReducer (SourcePosition file)
instance Reducer Char (SourcePosition file)
instance Monoid (SourcePosition file)
instance FunctorPlus SourcePosition
instance FunctorZero SourcePosition
instance Pointed SourcePosition
instance Functor SourcePosition

module Data.Monoid.IntMap
data UnionWith m
instance (Monoid m) => Reducer (IntMap m) (UnionWith m)
instance (Monoid m) => Monoid (UnionWith m)

module Data.Monoid.Generator
class Generator c where { type family Elem c :: *; { mapFrom f = mappend . mapReduce f mapTo f m = mappend m . mapReduce f mapReduce f = mapTo f mempty } }
mapReduce :: (Generator c, Reducer e m) => (Elem c -> e) -> c -> m
mapTo :: (Generator c, Reducer e m) => (Elem c -> e) -> m -> c -> m
mapFrom :: (Generator c, Reducer e m) => (Elem c -> e) -> c -> m -> m
reduce :: (Generator c, Reducer (Elem c) m) => c -> m
newtype Keys c
Keys :: c -> Keys c
getKeys :: Keys c -> c
newtype Values c
Values :: c -> Values c
getValues :: Values c -> c
newtype Char8 c
Char8 :: c -> Char8 c
getChar8 :: Char8 c -> c
instance Generator (Values (Map k v))
instance Generator (Values (IntMap v))
instance Generator (Keys (Map k v))
instance Generator (Keys (IntMap v))
instance Generator (Map k v)
instance Generator (IntMap v)
instance Generator (Set a)
instance Generator IntSet
instance Generator (Seq c)
instance (Measured v e) => Generator (FingerTree v e)
instance Generator [c]
instance Generator Text
instance Generator (Char8 ByteString)
instance Generator (Char8 ByteString)
instance Generator ByteString
instance Generator ByteString

module Data.Monoid.Lexical.Words
data Words m
runWords :: Words m -> [m]
data Lines m
runLines :: Lines m -> [m]
data Unspaced m
data Unlined m
wordsFrom :: (Generator c, (Elem c) ~ Char, Reducer Char m, Reducer Char n, Reducer Char o) => m -> c -> [(m, n, o)]
linesFrom :: (Generator c, (Elem c) ~ Char, Reducer Char m, Reducer Char n, Reducer Char o) => m -> c -> [(m, n, o)]
instance (Eq m) => Eq (Unlined m)
instance (Ord m) => Ord (Unlined m)
instance (Show m) => Show (Unlined m)
instance (Read m) => Read (Unlined m)
instance (Monoid m) => Monoid (Unlined m)
instance (Eq m) => Eq (Unspaced m)
instance (Ord m) => Ord (Unspaced m)
instance (Show m) => Show (Unspaced m)
instance (Read m) => Read (Unspaced m)
instance (Monoid m) => Monoid (Unspaced m)
instance (Show m) => Show (Lines m)
instance (Read m) => Read (Lines m)
instance (Monoid m) => Monoid (Lines m)
instance Functor Lines
instance (Show m) => Show (Words m)
instance (Read m) => Read (Words m)
instance Copointed Unlined
instance Pointed Unlined
instance Functor Unlined
instance (CharReducer m) => CharReducer (Unlined m)
instance (Reducer Char m) => Reducer Char (Unlined m)
instance Copointed Unspaced
instance Pointed Unspaced
instance Functor Unspaced
instance (CharReducer m) => CharReducer (Unspaced m)
instance (Reducer Char m) => Reducer Char (Unspaced m)
instance (Reducer Char m) => Reducer Char (Lines m)
instance Functor Words
instance (Reducer Char m) => Reducer Char (Words m)
instance (Monoid m) => Monoid (Words m)

module Data.Monoid.Reducer.Sugar
fromInteger :: (Reducer Integer m) => Integer -> m
fromString :: (Reducer Char m) => String -> m

module Data.Monoid.FromString
data FromString m
FromString :: m -> FromString m
getFromString :: FromString m -> m
instance Functor FromString
instance Copointed FromString
instance Pointed FromString
instance (Reducer Char m) => IsString (FromString m)
instance (Reducer Char m) => Reducer Char (FromString m)
instance (Monoid m) => Monoid (FromString m)

module Data.Monoid.Categorical

-- | The <a>Monoid</a> of endomorphisms over some object in an arbitrary
--   <a>Category</a>
data Endo k a
Endo :: k a a -> Endo k a
getEndo :: Endo k a -> k a a

-- | A <a>Monoid</a> is just a <a>Category</a> with one object.
data Mon m n o
Mon :: m -> Mon m a a
runMon :: Mon m m m -> m
instance (Monoid m) => Category (Mon m)
instance (Category k) => Monoid (Endo k a)

module Data.Monoid.Applicative
newtype Traversal f
Traversal :: f () -> Traversal f
getTraversal :: Traversal f -> f ()
newtype Alternate f a
Alternate :: f a -> Alternate f a
getAlternate :: Alternate f a -> f a
newtype TraversalWith f n
TraversalWith :: f n -> TraversalWith f n
getTraversalWith :: TraversalWith f n -> f n
instance (Eq (f a)) => Eq (Alternate f a)
instance (Ord (f a)) => Ord (Alternate f a)
instance (Show (f a)) => Show (Alternate f a)
instance (Read (f a)) => Read (Alternate f a)
instance (Functor f) => Functor (Alternate f)
instance (Applicative f) => Applicative (Alternate f)
instance (Alternative f) => Alternative (Alternate f)
instance (Pointed f) => Pointed (TraversalWith f)
instance (Functor f) => Functor (TraversalWith f)
instance (Applicative f, Monoid n) => Reducer (f n) (TraversalWith f n)
instance (Applicative f, Monoid n) => Monoid (TraversalWith f n)
instance (Pointed f) => Pointed (Alternate f)
instance (Alternative f) => Reducer (f a) (Alternate f a)
instance (Alternative f) => Monoid (Alternate f a)
instance (Applicative f) => Reducer (f a) (Traversal f)
instance (Applicative f) => Monoid (Traversal f)

module Data.Monoid.Generator.Combinators
traverse_ :: (Generator c, Applicative f) => (Elem c -> f b) -> c -> f ()
for_ :: (Generator c, Applicative f) => c -> (Elem c -> f b) -> f ()
mapM_ :: (Generator c, Monad m) => (Elem c -> m b) -> c -> m ()
forM_ :: (Generator c, Monad m) => c -> (Elem c -> m b) -> m ()
foldMap' :: (Monoid m, Generator c) => (Elem c -> m) -> c -> m
concatMap :: (Generator c) => (Elem c -> [b]) -> c -> [b]
and :: (Generator c, (Elem c) ~ Bool) => c -> Bool
or :: (Generator c, (Elem c) ~ Bool) => c -> Bool
any :: (Generator c) => (Elem c -> Bool) -> c -> Bool
all :: (Generator c) => (Elem c -> Bool) -> c -> Bool
sum :: (Generator c, Num (Elem c)) => c -> Elem c
product :: (Generator c, Num (Elem c)) => c -> Elem c
elem :: (Generator c, Eq (Elem c)) => Elem c -> c -> Bool
notElem :: (Generator c, Eq (Elem c)) => Elem c -> c -> Bool
filter :: (Generator c, Reducer (Elem c) m) => (Elem c -> Bool) -> c -> m
find :: (Generator c) => (Elem c -> Bool) -> c -> Maybe (Elem c)

module Data.Monoid.Additive
plus :: (Monoid m) => m -> m -> m
zero :: (Monoid m) => m

module Data.Monoid.Additive.Sugar
(+) :: (Monoid m) => m -> m -> m

module Data.Monoid.Multiplicative
class MultiplicativeMonoid m
one :: (MultiplicativeMonoid m) => m
times :: (MultiplicativeMonoid m) => m -> m -> m
instance (MultiplicativeMonoid m) => MultiplicativeMonoid (FromString m)
instance (MultiplicativeMonoid m) => MultiplicativeMonoid (Identity m)
instance (Monoid m) => MultiplicativeMonoid (Seq m)
instance (Measured v m, Monoid m) => MultiplicativeMonoid (FingerTree v m)
instance (Monoid m) => MultiplicativeMonoid [m]

module Data.Monoid.Multiplicative.Sugar
(*) :: (MultiplicativeMonoid r) => r -> r -> r

module Data.Monoid.Multiplicative.Transformer
data Log m
Log :: m -> Log m
getLog :: Log m -> m
data Exp m
Exp :: m -> Exp m
getExp :: Exp m -> m
instance (Monoid m) => MultiplicativeMonoid (Exp m)
instance (MultiplicativeMonoid m) => Monoid (Log m)

module Data.Ring.Semi.Near
class (MultiplicativeMonoid m, Monoid m) => Seminearring m
instance (Seminearring m) => Seminearring (FromString m)
instance (Seminearring m) => Seminearring (Identity m)
instance (Measured v m, Monoid m) => Seminearring (FingerTree v m)
instance (Monoid m) => Seminearring (Seq m)
instance (Monoid m) => Seminearring [m]

module Data.Ring.Semi
class (Seminearring a) => Semiring a

module Data.Ring.Semi.Ord
newtype Order a
Order :: a -> Order a
getOrder :: Order a -> a
data Priority a
MinBound :: Priority a
Priority :: a -> Priority a
MaxBound :: Priority a
instance (Eq a) => Eq (Priority a)
instance (Read a) => Read (Priority a)
instance (Show a) => Show (Priority a)
instance (Eq a) => Eq (Order a)
instance (Ord a) => Ord (Order a)
instance (Read a) => Read (Order a)
instance (Show a) => Show (Order a)
instance (Bounded a) => Bounded (Order a)
instance (Arbitrary a) => Arbitrary (Order a)
instance Pointed Priority
instance Functor Priority
instance (Ord a) => Reducer (MaxPriority a) (Priority a)
instance (Ord a) => Reducer (MinPriority a) (Priority a)
instance (Ord a) => Reducer a (Priority a)
instance (Ord a) => Semiring (Priority a)
instance (Ord a) => Seminearring (Priority a)
instance (Ord a) => MultiplicativeMonoid (Priority a)
instance (Ord a) => Monoid (Priority a)
instance (Arbitrary a) => Arbitrary (Priority a)
instance (Ord a) => Ord (Priority a)
instance Bounded (Priority a)
instance Copointed Order
instance Pointed Order
instance Functor Order
instance (Bounded a, Ord a) => Reducer a (Order a)
instance (Bounded a, Ord a) => Semiring (Order a)
instance (Bounded a, Ord a) => Seminearring (Order a)
instance (Bounded a, Ord a) => MultiplicativeMonoid (Order a)
instance (Bounded a, Ord a) => Monoid (Order a)

module Data.Ring.Sugar

module Data.Group
class (Monoid a) => Group a
gnegate :: (Group a) => a -> a
minus :: (Group a) => a -> a -> a
instance (Group a) => Group (FromString a)
instance (Group a) => Group (Identity a)
instance (Group a) => Group (Dual a)
instance (Fractional a) => Group (Product a)
instance (Num a) => Group (Sum a)

module Data.Group.Sugar
(-) :: (Group g) => g -> g -> g
negate :: (Group g) => g -> g

module Data.Ring
instance Ring Bool
instance Semiring Bool
instance Seminearring Bool
instance MultiplicativeMonoid Bool
instance Group Bool
instance Monoid Bool

module Data.Ring.FromNum
newtype FromNum a
FromNum :: a -> FromNum a
getFromNum :: FromNum a -> a
instance (Eq a) => Eq (FromNum a)
instance (Show a) => Show (FromNum a)
instance (Num a) => Num (FromNum a)
instance (Num a) => Reducer Integer (FromNum a)
instance (Num a) => Seminearring (FromNum a)
instance (Num a) => MultiplicativeMonoid (FromNum a)
instance (Num a) => Group (FromNum a)
instance (Num a) => Monoid (FromNum a)