-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/
-- | Monoids, specialized containers and a general map/reduce framework
--
-- Monoids, specialized containers and a general map/reduce framework
@package monoids
@version 0.2.0.2
-- | A c-Reducer is a Monoid with a canonical
-- mapping from c to the Monoid. This unit acts in many
-- ways like return for a Monad but is limited to a single
-- type.
module Data.Monoid.Reducer
-- | This type may be best read infix. A c Reducer m is a
-- Monoid m that maps values of type c through
-- unit to values of type m. A
-- c-Reducer may also supply operations which tack-on
-- another c to an existing Monoid m on the left
-- or right. These specialized reductions may be more efficient in some
-- scenarios and are used when appropriate by a Generator. The names
-- cons and snoc work by analogy to the synonymous
-- operations in the list monoid.
--
-- This class deliberately avoids functional-dependencies, so that () can
-- be a c-Reducer for all c, and so many common
-- reducers can work over multiple types, for instance, First and Last
-- may reduce both a and Maybe a. Since a
-- Generator has a fixed element type, the input to the reducer is
-- generally known and extracting from the monoid usually is sufficient
-- to fix the result type. Combinators are available for most scenarios
-- where this is not the case, and the few remaining cases can be handled
-- by using an explicit type annotation.
--
-- Minimal definition: unit or snoc
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
-- | Apply a Reducer to a Foldable container, after mapping
-- the contents into a suitable form for reduction.
foldMapReduce :: (Foldable f, Reducer e m) => (a -> e) -> f a -> m
-- | Apply a Reducer to a Foldable mapping each element
-- through unit
foldReduce :: (Foldable f, Reducer e m) => f e -> m
pureUnit :: (Applicative f, Reducer c n) => c -> f n
returnUnit :: (Monad m, Reducer c n) => c -> m n
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)
-- | A simple Monoid transformer that takes a Monoid m and
-- produces a new m-Reducer named Self m
--
-- This is useful when you have a generator that already contains
-- monoidal values or someone supplies the map to the monoid in the form
-- of a function rather than as a Reducer instance. You can just
-- getSelf . reduce or getSelf . mapReduce
-- f in those scenarios. These behaviors are encapsulated into the
-- fold and foldMap combinators in Data.Monoid.Combinators
-- respectively.
module Data.Monoid.Self
newtype Self m
Self :: m -> Self m
getSelf :: Self m -> m
instance (Monoid m) => Monoid (Self m)
instance Functor Self
instance (Monoid m) => Reducer m (Self m)
module Data.Monoid.Union
-- | A Container suitable for the Union Monoid
class HasUnion f
empty :: (HasUnion f) => f
union :: (HasUnion f) => f -> f -> f
-- | The Monoid (union,empty)
newtype Union f
Union :: f -> Union f
getUnion :: Union f -> f
-- | Polymorphic containers that we can supply an operation to handle
-- unions with
class (Functor f) => HasUnionWith f
unionWith :: (HasUnionWith f) => (a -> a -> a) -> f a -> f a -> f a
emptyWith :: (HasUnionWith f) => f a
-- | The Monoid ('unionWith mappend',empty) for
-- containers full of monoids.
newtype UnionWith f m
UnionWith :: f m -> UnionWith f m
getUnionWith :: UnionWith f m -> f m
instance (Eq (f m)) => Eq (UnionWith f m)
instance (Ord (f m)) => Ord (UnionWith f m)
instance (Show (f m)) => Show (UnionWith f m)
instance (Read (f m)) => Read (UnionWith f m)
instance (Functor f) => Functor (UnionWith f)
instance (Monad f) => Monad (UnionWith f)
instance (Eq f) => Eq (Union f)
instance (Ord f) => Ord (Union f)
instance (Show f) => Show (Union f)
instance (Read f) => Read (Union f)
instance (HasUnionWith f, Monoid m) => Reducer (f m) (UnionWith f m)
instance (HasUnionWith f, Monoid m) => Monoid (UnionWith f m)
instance (Ord k) => HasUnionWith (Map k)
instance HasUnionWith IntMap
instance Functor Union
instance (HasUnion f) => Reducer f (Union f)
instance (HasUnion f) => Monoid (Union f)
instance HasUnion IntSet
instance (Ord a) => HasUnion (Set a)
instance (Eq a) => HasUnion [a]
instance (Ord k) => HasUnion (Map k a)
instance HasUnion (IntMap a)
module Data.Monoid.Ord
-- | The Monoid (max,minBound)
newtype Max a
Max :: a -> Max a
getMax :: Max a -> a
-- | The Monoid given by (min,maxBound)
newtype Min a
Min :: a -> Min a
getMin :: Min a -> a
-- | The Monoid (max,Nothing) over
-- Maybe a where Nothing is the bottom element
newtype MaxPriority a
MaxPriority :: Maybe a -> MaxPriority a
getMaxPriority :: MaxPriority a -> Maybe a
minfinity :: MaxPriority a
-- | The Monoid (min,Nothing) over
-- Maybe a where Nothing is the top element
newtype MinPriority a
MinPriority :: Maybe a -> MinPriority a
getMinPriority :: MinPriority a -> Maybe a
infinity :: MinPriority 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 Functor MinPriority
instance (Ord a) => Reducer (Maybe a) (MinPriority a)
instance (Ord a) => Monoid (MinPriority a)
instance (Ord a) => Ord (MinPriority a)
instance Functor MaxPriority
instance (Ord a) => Reducer (Maybe a) (MaxPriority a)
instance (Ord a) => Monoid (MaxPriority a)
instance Functor Min
instance (Ord a, Bounded a) => Reducer a (Min a)
instance (Ord a, Bounded a) => Monoid (Min a)
instance Functor Max
instance (Ord a, Bounded a) => Reducer a (Max a)
instance (Ord a, Bounded a) => Monoid (Max a)
-- | Utilities for working with Monoids that conflict with names from the
-- Prelude, Data.Foldable, Control.Monad or
-- elsewhere. Intended to be imported qualified.
--
--
-- import Data.Monoid.Combinators as Monoid
--
module Data.Monoid.Combinators
-- | A generalization of Data.List.repeat to an arbitrary Monoid.
-- May fail to terminate for some values in some monoids.
repeat :: (Reducer e m) => e -> m
-- | A generalization of Data.List.replicate to an arbitrary Monoid.
-- Adapted from
-- http://augustss.blogspot.com/2008/07/lost-and-found-if-i-write-108-in.html
replicate :: (Monoid m, Integral n) => m -> n -> m
-- | A generalization of Data.List.cycle to an arbitrary Monoid. May
-- fail to terminate for some values in some monoids.
cycle :: (Monoid m) => m -> m
-- | More easily understood aliases for mappend and mempty,
-- chosen for symmetry with Data.Monoid.Multiplicative
--
--
-- import Data.Monoid.Additive
--
module Data.Monoid.Additive
plus :: (Monoid m) => m -> m -> m
zero :: (Monoid m) => m
-- | A Generator c is a possibly-specialized container,
-- which contains values of type Elem c, and which knows
-- how to efficiently apply a Reducer to extract an answer.
--
-- Since a Generator is not polymorphic in its contents, it is
-- more specialized than Data.Foldable.Foldable, and a
-- Reducer may supply efficient left-to-right and right-to-left
-- reduction strategies that a Generator may avail itself of.
module Data.Generator
-- | minimal definition mapReduce or mapTo
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
-- | a Generator transformer that asks only for the keys of an
-- indexed container
newtype Keys c
Keys :: c -> Keys c
getKeys :: Keys c -> c
-- | a Generator transformer that asks only for the values contained
-- in an indexed container
newtype Values c
Values :: c -> Values c
getValues :: Values c -> c
-- | a Generator transformer that treats Word8 as Char
-- This lets you use a ByteString as a Char source without going
-- through a Monoid transformer like UTF8
newtype Char8 c
Char8 :: c -> Char8 c
getChar8 :: Char8 c -> c
-- | Apply a Reducer directly to the elements of a Generator
reduce :: (Generator c, Reducer (Elem c) m) => c -> m
mapReduceWith :: (Generator c, Reducer e m) => (m -> n) -> (Elem c -> e) -> c -> n
reduceWith :: (Generator c, Reducer (Elem c) m) => (m -> n) -> c -> n
instance Generator (Char8 ByteString)
instance Generator (Char8 ByteString)
instance (Ix i) => Generator (Values (Array i e))
instance Generator (Values (Map k v))
instance Generator (Values (IntMap v))
instance (Ix i) => Generator (Keys (Array i e))
instance Generator (Keys (Map k v))
instance Generator (Keys (IntMap v))
instance (Ix i) => Generator (Array i e)
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 ByteString
instance Generator ByteString
-- | When dealing with a Ring or other structure, you often need a pair of
-- Monoid instances that are closely related. Making a
-- newtype for one is unsatisfying and yields an unnatural
-- programming style.
--
-- A Multiplicative is a Monoid that is intended for use in
-- a scenario that can be extended to have another Monoid slot in
-- for addition. This enables one to use common notation.
--
-- Any Multiplicative can be turned into a Monoid using the
-- Log wrapper.
--
-- Any Monoid can be turned into a Multiplicative using the
-- Exp wrapper.
--
-- Instances are supplied for common Monads of Monoids, in a fashion
-- which can be extended if the Monad is a MonadPlus to yield a
-- RightSemiNearRing
--
-- Instances are also supplied for common Applicatives of Monoids, in a
-- fashion which can be extended if the Applicative is
-- Alternative to yield a RightSemiNearRing
module Data.Monoid.Multiplicative
class Multiplicative m
one :: (Multiplicative m) => m
times :: (Multiplicative m) => m -> m -> m
-- | Convert a Multiplicative into a Monoid. Mnemonic:
-- Log a + Log b = Log (a * b)
data Log m
Log :: m -> Log m
getLog :: Log m -> m
-- | Convert a Monoid into a Multiplicative. Mnemonic:
-- Exp a * Exp b = Exp (a + b)
data Exp m
Exp :: m -> Exp m
getExp :: Exp m -> m
instance (Measured v m, Monoid m) => Multiplicative (FingerTree v m)
instance (Monoid m) => Multiplicative (Seq m)
instance (Integral m) => Multiplicative (Ratio m)
instance Multiplicative Integer
instance Multiplicative Int
instance (Monoid m) => Multiplicative (Const m a)
instance (Monoid n) => Multiplicative (ZipList n)
instance (Monoid n) => Multiplicative (IO n)
instance (Monoid m) => Multiplicative (Maybe m)
instance (Monoid m) => Multiplicative [m]
instance (Multiplicative m) => Multiplicative (Self m)
instance (Monoid m) => Multiplicative (Exp m)
instance (Multiplicative m) => Monoid (Log m)
instance (Multiplicative m) => Multiplicative (Dual m)
-- | Extends Monoid to support Group operations
module Data.Group
-- | Minimal complete definition: gnegate or minus
class (Monoid a) => Group a
gnegate :: (Group a) => a -> a
minus :: (Group a) => a -> a -> a
gsubtract :: (Group a) => a -> a -> a
-- | Minimal definition over or grecip
class (Multiplicative g) => MultiplicativeGroup g
over :: (MultiplicativeGroup g) => g -> g -> g
under :: (MultiplicativeGroup g) => g -> g -> g
grecip :: (MultiplicativeGroup g) => g -> g
instance (MultiplicativeGroup a) => MultiplicativeGroup (Dual a)
instance (MultiplicativeGroup g) => MultiplicativeGroup (Self g)
instance (Group g) => MultiplicativeGroup (Exp g)
instance (MultiplicativeGroup g) => Group (Log g)
instance (Group a) => Group (Self a)
instance (Group a) => Group (Dual a)
instance (Fractional a) => Group (Product a)
instance (Num a) => Group (Sum a)
-- | Utilities for working with Groups that conflict with names from the
-- Prelude.
--
-- Intended to be imported qualified.
--
--
-- import Data.Group.Combinators as Group (replicate)
--
module Data.Group.Combinators
replicate :: (Group m, Integral n) => m -> n -> m
-- | Monoids for working with an Applicative Functor.
module Data.Monoid.Applicative
-- | A Traversal uses an glues together Applicative actions
-- with (*>) in the manner of traverse_ from Data.Foldable. Any
-- values returned by reduced actions are discarded.
newtype Traversal f
Traversal :: f () -> Traversal f
getTraversal :: Traversal f -> f ()
-- | A Alt turns any Alternative instance into a
-- Monoid. It also provides a Multiplicative instance for
-- an Applicative functor wrapped around a Monoid and
-- asserts that any Alternative applied to a Monoid forms a
-- RightSemiNearRing under these operations.
newtype Alt f a
Alt :: f a -> Alt f a
getAlt :: Alt f a -> f a
-- | if m is a Module over r and f is a
-- Applicative then f App m is a Module over
-- r as well
newtype App f m
App :: f m -> App f m
getApp :: App f m -> f m
-- | Efficiently avoid needlessly rebinding when using snoc on an
-- action that already returns () A rewrite rule automatically applies
-- this when possible
snocTraversal :: (Reducer (f ()) (Traversal f)) => Traversal f -> f () -> Traversal f
instance (Eq (f m)) => Eq (App f m)
instance (Ord (f m)) => Ord (App f m)
instance (Show (f m)) => Show (App f m)
instance (Read (f m)) => Read (App f m)
instance (Functor f) => Functor (App f)
instance (Applicative f) => Applicative (App f)
instance (Alternative f) => Alternative (App f)
instance (Eq (f a)) => Eq (Alt f a)
instance (Ord (f a)) => Ord (Alt f a)
instance (Show (f a)) => Show (Alt f a)
instance (Read (f a)) => Read (Alt f a)
instance (Functor f) => Functor (Alt f)
instance (Applicative f) => Applicative (Alt f)
instance (Alternative f) => Alternative (Alt f)
instance (Reducer c m, Applicative f) => Reducer c (App f m)
instance (Group m, Applicative f) => Group (App f m)
instance (Monoid m, Applicative f) => Monoid (App f m)
instance (Alternative f) => Reducer (f a) (Alt f a)
instance (Applicative f, Monoid a) => Multiplicative (Alt f a)
instance (Alternative f) => Monoid (Alt f a)
instance (Applicative f) => Reducer (f a) (Traversal f)
instance (Applicative f) => Monoid (Traversal f)
-- | Monoid instances for working with a Monad
module Data.Monoid.Monad
-- | An Action uses glues together Monad actions with
-- (>>) in the manner of mapM_ from Data.Foldable.
-- Any values returned by reduced actions are discarded.
newtype Action m
Action :: m () -> Action m
getAction :: Action m -> m ()
-- | Efficiently avoid needlessly rebinding when using snoc on an
-- action that already returns () A rewrite rule automatically applies
-- this when possible
snocAction :: (Reducer (m ()) (Action m)) => Action m -> m () -> Action m
-- | A MonadSum turns any MonadPlus instance into a
-- Monoid. It also provides a Multiplicative instance for a
-- Monad wrapped around a Monoid and asserts that any
-- MonadPlus applied to a Monoid forms a RightSemiNearRing
-- under these operations.
newtype MonadSum m a
MonadSum :: m a -> MonadSum m a
getMonadSum :: MonadSum m a -> m a
-- | if m is a Module over r and f is a
-- Monad then f Mon m is a Module as well
newtype Mon f m
Mon :: f m -> Mon f m
getMon :: Mon f m -> f m
instance (Eq (f m)) => Eq (Mon f m)
instance (Ord (f m)) => Ord (Mon f m)
instance (Show (f m)) => Show (Mon f m)
instance (Read (f m)) => Read (Mon f m)
instance (Functor f) => Functor (Mon f)
instance (Monad f) => Monad (Mon f)
instance (MonadPlus f) => MonadPlus (Mon f)
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 (Monad m) => Monad (MonadSum m)
instance (MonadPlus m) => MonadPlus (MonadSum m)
instance (Reducer c m, Monad f) => Reducer c (Mon f m)
instance (Group m, Monad f) => Group (Mon f m)
instance (Monoid m, Monad f) => Monoid (Mon f m)
instance (MonadPlus m) => Reducer (m a) (MonadSum m a)
instance (Monad m) => Applicative (MonadSum m)
instance (Monad m) => Functor (MonadSum m)
instance (Monad m, Monoid a) => Multiplicative (MonadSum m a)
instance (MonadPlus m) => Monoid (MonadSum m a)
instance (Monad m) => Reducer (m a) (Action m)
instance (Monad m) => Monoid (Action m)
-- | Utilities for working with Monoids that conflict with names from the
-- Prelude, Data.Foldable, Control.Monad or
-- elsewhere. Intended to be imported qualified.
--
--
-- import Data.Generator.Combinators as Generator
--
module Data.Generator.Combinators
-- | Efficiently mapReduce a Generator using the
-- Action monoid. A specialized version of its namesake from
-- Data.Foldable and Control.Monad
--
--
-- mapReduceWith getAction
--
mapM_ :: (Generator c, Monad m) => (Elem c -> m b) -> c -> m ()
-- | Convenience function as found in Data.Foldable and
-- Control.Monad
--
--
-- flip mapM_
--
forM_ :: (Generator c, Monad m) => c -> (Elem c -> m b) -> m ()
-- | The sum of a collection of actions, generalizing concat
--
--
-- reduceWith getMonadSum
--
msum :: (Generator c, MonadPlus m, (m a) ~ (Elem c)) => c -> m a
-- | Efficiently mapReduce a Generator using the
-- Traversal monoid. A specialized version of its namesake from
-- Data.Foldable
--
--
-- mapReduce getTraversal
--
traverse_ :: (Generator c, Applicative f) => (Elem c -> f b) -> c -> f ()
-- | Convenience function as found in Data.Foldable
--
--
-- flip traverse_
--
for_ :: (Generator c, Applicative f) => c -> (Elem c -> f b) -> f ()
-- | The sum of a collection of actions, generalizing concat
--
--
-- reduceWith getAlt
--
asum :: (Generator c, Alternative f, (f a) ~ (Elem c)) => c -> f a
-- | Efficiently reduce a Generator that contains values of
-- type Bool
--
--
-- reduceWith getAll
--
and :: (Generator c, (Elem c) ~ Bool) => c -> Bool
-- | Efficiently reduce a Generator that contains values of
-- type Bool
--
--
-- reduceWith getAny
--
or :: (Generator c, (Elem c) ~ Bool) => c -> Bool
-- | Efficiently mapReduce any Generator checking to see if
-- any of its values match the supplied predicate
--
--
-- mapReduceWith getAny
--
any :: (Generator c) => (Elem c -> Bool) -> c -> Bool
-- | Efficiently mapReduce any Generator checking to see if
-- all of its values match the supplied predicate
--
--
-- mapReduceWith getAll
--
all :: (Generator c) => (Elem c -> Bool) -> c -> Bool
-- | Efficiently mapReduce a Generator using the Self
-- monoid. A specialized version of its namesake from
-- Data.Foldable
--
--
-- mapReduceWith getSelf
--
foldMap :: (Monoid m, Generator c) => (Elem c -> m) -> c -> m
-- | Efficiently reduce a Generator using the Self
-- monoid. A specialized version of its namesake from
-- Data.Foldable
--
--
-- reduceWith getSelf
--
fold :: (Monoid m, Generator c, (Elem c) ~ m) => c -> m
-- | Convert any Generator to a list of its contents. Specialization
-- of reduce
toList :: (Generator c) => c -> [Elem c]
-- | Type specialization of foldMap above
concatMap :: (Generator c) => (Elem c -> [b]) -> c -> [b]
-- | Check to see if any member of the Generator matches the
-- supplied value
elem :: (Generator c, Eq (Elem c)) => Elem c -> c -> Bool
-- | Efficiently mapReduce a subset of the elements in a
-- Generator
filter :: (Generator c, Reducer (Elem c) m) => (Elem c -> Bool) -> c -> m
-- | Allows idiomatic specialization of filter by proving a function that
-- will be used to transform the output
filterWith :: (Generator c, Reducer (Elem c) m) => (m -> n) -> (Elem c -> Bool) -> c -> n
-- | A specialization of filter using the First
-- Monoid, analogous to Data.List.find
--
--
-- filterWith getFirst
--
find :: (Generator c) => (Elem c -> Bool) -> c -> Maybe (Elem c)
-- | Efficiently sum over the members of any Generator
--
--
-- reduceWith getSum
--
sum :: (Generator c, Num (Elem c)) => c -> Elem c
-- | Efficiently take the product of every member of a Generator
--
--
-- reduceWith getProduct
--
product :: (Generator c, Num (Elem c)) => c -> Elem c
-- | Check to make sure that the supplied value is not a member of the
-- Generator
notElem :: (Generator c, Eq (Elem c)) => Elem c -> c -> Bool
-- | Syntactic sugar for working with a Monoid and
-- Multiplicative instances that conflicts with names from the
-- Prelude.
--
--
-- import Prelude hiding ((+),(*),(^))
-- import Data.Monoid.Sugar
--
module Data.Monoid.Sugar
(+) :: (Monoid m) => m -> m -> m
(*) :: (Multiplicative r) => r -> r -> r
(^) :: (Multiplicative r, Integral b) => r -> b -> r
-- | Syntactic sugar for working with groups that conflicts with names from
-- the Prelude.
--
--
-- import Prelude hiding ((-), (+), (*), (/), (^), (^^), negate, subtract, recip)
-- import Data.Group.Sugar
--
module Data.Group.Sugar
(-) :: (Group g) => g -> g -> g
negate :: (Group g) => g -> g
subtract :: (Group g) => g -> g -> g
(/) :: (MultiplicativeGroup g) => g -> g -> g
(.\.) :: (MultiplicativeGroup g) => g -> g -> g
(^^) :: (MultiplicativeGroup g) => g -> Integer -> g
recip :: (MultiplicativeGroup g) => g -> g