packages feed

reducers 3.12.1 → 3.12.2

raw patch · 7 files changed

+121/−42 lines, 7 filesdep ~fingertreedep ~unordered-containersnew-uploaderPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: fingertree, unordered-containers

API changes (from Hackage documentation)

- Data.Generator: getChar8 :: Char8 c -> c
- Data.Generator: getKeys :: Keys c -> c
- Data.Generator: getValues :: Values c -> c
- Data.Generator: instance Generator (Char8 ByteString)
- Data.Generator: instance Generator (HashMap k v)
- Data.Generator: instance Generator (HashSet a)
- Data.Generator: instance Generator (IntMap v)
- Data.Generator: instance Generator (Keys (IntMap v))
- Data.Generator: instance Generator (Keys (Map k v))
- Data.Generator: instance Generator (Map k v)
- Data.Generator: instance Generator (NonEmpty c)
- Data.Generator: instance Generator (Seq c)
- Data.Generator: instance Generator (Set a)
- Data.Generator: instance Generator (Values (IntMap v))
- Data.Generator: instance Generator (Values (Map k v))
- Data.Generator: instance Generator ByteString
- Data.Generator: instance Generator IntSet
- Data.Generator: instance Generator Text
- Data.Generator: instance Generator [c]
- Data.Generator: instance Ix i => Generator (Array i e)
- Data.Generator: instance Ix i => Generator (Keys (Array i e))
- Data.Generator: instance Ix i => Generator (Values (Array i e))
- Data.Generator: instance Measured v e => Generator (FingerTree v e)
- Data.Semigroup.Alt: getAlter :: Alter f a -> f a
- Data.Semigroup.Alt: instance Alt f => Alt (Alter f)
- Data.Semigroup.Alt: instance Alt f => Reducer (f a) (Alter f a)
- Data.Semigroup.Alt: instance Alt f => Semigroup (Alter f a)
- Data.Semigroup.Alt: instance Functor f => Functor (Alter f)
- Data.Semigroup.Alt: instance Plus f => Monoid (Alter f a)
- Data.Semigroup.Alt: instance Plus f => Plus (Alter f)
- Data.Semigroup.Alternative: getAlternate :: Alternate f a -> f a
- Data.Semigroup.Alternative: instance Alternative f => Alternative (Alternate f)
- Data.Semigroup.Alternative: instance Alternative f => Monoid (Alternate f a)
- Data.Semigroup.Alternative: instance Alternative f => Reducer (f a) (Alternate f a)
- Data.Semigroup.Alternative: instance Alternative f => Semigroup (Alternate f a)
- Data.Semigroup.Alternative: instance Applicative f => Applicative (Alternate f)
- Data.Semigroup.Alternative: instance Functor f => Functor (Alternate f)
- Data.Semigroup.Applicative: getAp :: Ap f m -> f m
- Data.Semigroup.Applicative: getTraversal :: Traversal f -> f ()
- Data.Semigroup.Applicative: instance (Applicative f, Monoid m) => Monoid (Ap f m)
- Data.Semigroup.Applicative: instance (Applicative f, Reducer c m) => Reducer (f c) (Ap f m)
- Data.Semigroup.Applicative: instance (Applicative f, Semigroup m) => Semigroup (Ap f m)
- Data.Semigroup.Applicative: instance Applicative f => Applicative (Ap f)
- Data.Semigroup.Applicative: instance Applicative f => Monoid (Traversal f)
- Data.Semigroup.Applicative: instance Applicative f => Reducer (f a) (Traversal f)
- Data.Semigroup.Applicative: instance Applicative f => Semigroup (Traversal f)
- Data.Semigroup.Applicative: instance Functor f => Functor (Ap f)
- Data.Semigroup.Apply: getApp :: App f m -> f m
- Data.Semigroup.Apply: getTrav :: Trav f -> f ()
- Data.Semigroup.Apply: instance (Apply f, Reducer c m) => Reducer (f c) (App f m)
- Data.Semigroup.Apply: instance (Apply f, Semigroup m) => Semigroup (App f m)
- Data.Semigroup.Apply: instance Apply f => Apply (App f)
- Data.Semigroup.Apply: instance Apply f => Reducer (f a) (Trav f)
- Data.Semigroup.Apply: instance Apply f => Semigroup (Trav f)
- Data.Semigroup.Apply: instance Functor f => Functor (App f)
- Data.Semigroup.Generator: instance Generator1 (NonEmpty e)
- Data.Semigroup.Instances: instance Measured v a => Semigroup (FingerTree v a)
- Data.Semigroup.Monad: getAction :: Action f -> f ()
- Data.Semigroup.Monad: getMon :: Mon f m -> f m
- Data.Semigroup.Monad: instance (Monad f, Monoid m) => Monoid (Mon f m)
- Data.Semigroup.Monad: instance (Monad f, Reducer c m) => Reducer (f c) (Mon f m)
- Data.Semigroup.Monad: instance (Monad f, Semigroup m) => Semigroup (Mon f m)
- Data.Semigroup.Monad: instance Applicative f => Applicative (Mon f)
- Data.Semigroup.Monad: instance Functor f => Functor (Mon f)
- Data.Semigroup.Monad: instance Monad f => Monad (Mon f)
- Data.Semigroup.Monad: instance Monad f => Monoid (Action f)
- Data.Semigroup.Monad: instance Monad f => Reducer (f a) (Action f)
- Data.Semigroup.Monad: instance Monad f => Semigroup (Action f)
- Data.Semigroup.MonadPlus: getMonadSum :: MonadSum f a -> f a
- Data.Semigroup.MonadPlus: instance Alternative f => Alternative (MonadSum f)
- Data.Semigroup.MonadPlus: instance Applicative f => Applicative (MonadSum f)
- Data.Semigroup.MonadPlus: instance Functor f => Functor (MonadSum f)
- Data.Semigroup.MonadPlus: instance Monad f => Monad (MonadSum f)
- Data.Semigroup.MonadPlus: instance MonadPlus f => MonadPlus (MonadSum f)
- Data.Semigroup.MonadPlus: instance MonadPlus f => Monoid (MonadSum f a)
- Data.Semigroup.MonadPlus: instance MonadPlus f => Reducer (f a) (MonadSum f a)
- Data.Semigroup.MonadPlus: instance MonadPlus f => Semigroup (MonadSum f a)
- Data.Semigroup.Reducer: getCount :: Count -> Int
- Data.Semigroup.Reducer: instance (Reducer c m, Reducer c n) => Reducer c (m, n)
- Data.Semigroup.Reducer: instance (Reducer c m, Reducer c n, Reducer c o) => Reducer c (m, n, o)
- Data.Semigroup.Reducer: instance (Reducer c m, Reducer c n, Reducer c o, Reducer c p) => Reducer c (m, n, o, p)
- Data.Semigroup.Reducer: instance Data Count
- Data.Semigroup.Reducer: instance Eq Count
- Data.Semigroup.Reducer: instance Hashable Count
- Data.Semigroup.Reducer: instance Measured v a => Reducer a (FingerTree v a)
- Data.Semigroup.Reducer: instance Monoid Count
- Data.Semigroup.Reducer: instance Monoid m => Reducer m (WrappedMonoid m)
- Data.Semigroup.Reducer: instance Num a => Reducer a (Product a)
- Data.Semigroup.Reducer: instance Num a => Reducer a (Sum a)
- Data.Semigroup.Reducer: instance Ord Count
- Data.Semigroup.Reducer: instance Ord a => Reducer a (Max a)
- Data.Semigroup.Reducer: instance Ord a => Reducer a (Min a)
- Data.Semigroup.Reducer: instance Ord a => Reducer a (Set a)
- Data.Semigroup.Reducer: instance Ord k => Reducer (k, v) (Map k v)
- Data.Semigroup.Reducer: instance Read Count
- Data.Semigroup.Reducer: instance Reducer (Int, v) (IntMap v)
- Data.Semigroup.Reducer: instance Reducer (Maybe a) (First a)
- Data.Semigroup.Reducer: instance Reducer (Maybe a) (Last a)
- Data.Semigroup.Reducer: instance Reducer (a -> a) (Endo a)
- Data.Semigroup.Reducer: instance Reducer Bool All
- Data.Semigroup.Reducer: instance Reducer Bool Any
- Data.Semigroup.Reducer: instance Reducer Int IntSet
- Data.Semigroup.Reducer: instance Reducer a (First a)
- Data.Semigroup.Reducer: instance Reducer a (Last a)
- Data.Semigroup.Reducer: instance Reducer a (Seq a)
- Data.Semigroup.Reducer: instance Reducer a Count
- Data.Semigroup.Reducer: instance Reducer c ()
- Data.Semigroup.Reducer: instance Reducer c [c]
- Data.Semigroup.Reducer: instance Semigroup Count
- Data.Semigroup.Reducer: instance Semigroup a => Reducer a (Dual a)
- Data.Semigroup.Reducer: instance Show Count
- Data.Semigroup.Reducer: instance Typeable Count
- Data.Semigroup.Reducer.With: instance (Monoid m, Reducer c m) => Measured m (WithReducer m c)
- Data.Semigroup.Reducer.With: instance Eq c => Eq (WithReducer m c)
- Data.Semigroup.Reducer.With: instance Foldable (WithReducer m)
- Data.Semigroup.Reducer.With: instance Foldable1 (WithReducer m)
- Data.Semigroup.Reducer.With: instance Functor (WithReducer m)
- Data.Semigroup.Reducer.With: instance Hashable c => Hashable (WithReducer m c)
- Data.Semigroup.Reducer.With: instance Ord c => Ord (WithReducer m c)
- Data.Semigroup.Reducer.With: instance Read c => Read (WithReducer m c)
- Data.Semigroup.Reducer.With: instance Reducer c m => Reducer (WithReducer m c) m
- Data.Semigroup.Reducer.With: instance Show c => Show (WithReducer m c)
- Data.Semigroup.Reducer.With: instance Traversable (WithReducer m)
- Data.Semigroup.Reducer.With: instance Traversable1 (WithReducer m)
- Data.Semigroup.Reducer.With: withoutReducer :: WithReducer m c -> c
- Data.Semigroup.Self: getSelf :: Self m -> m
- Data.Semigroup.Self: instance Foldable Self
- Data.Semigroup.Self: instance Foldable1 Self
- Data.Semigroup.Self: instance Functor Self
- Data.Semigroup.Self: instance Monoid m => Monoid (Self m)
- Data.Semigroup.Self: instance Semigroup m => Reducer m (Self m)
- Data.Semigroup.Self: instance Semigroup m => Semigroup (Self m)
- Data.Semigroup.Self: instance Traversable Self
- Data.Semigroup.Self: instance Traversable1 Self
- Data.Semigroup.Union: getUnion :: Union f -> f
- Data.Semigroup.Union: getUnionWith :: UnionWith f m -> f m
- Data.Semigroup.Union: instance (Eq a, Hashable a) => HasUnion (HashSet a)
- Data.Semigroup.Union: instance (Eq a, Hashable a) => HasUnion0 (HashSet a)
- Data.Semigroup.Union: instance (Eq k, Hashable k) => HasUnion (HashMap k a)
- Data.Semigroup.Union: instance (Eq k, Hashable k) => HasUnion0 (HashMap k a)
- Data.Semigroup.Union: instance (HasUnionWith f, Semigroup m) => Semigroup (UnionWith f m)
- Data.Semigroup.Union: instance (HasUnionWith f, Semigroup m, Monoid m) => Reducer (f m) (UnionWith f m)
- Data.Semigroup.Union: instance (HasUnionWith0 f, Monoid m) => Monoid (UnionWith f m)
- Data.Semigroup.Union: instance Eq a => HasUnion [a]
- Data.Semigroup.Union: instance Eq a => HasUnion0 [a]
- Data.Semigroup.Union: instance Eq f => Eq (Union f)
- Data.Semigroup.Union: instance Foldable Union
- Data.Semigroup.Union: instance Foldable1 Union
- Data.Semigroup.Union: instance Functor Union
- Data.Semigroup.Union: instance HasUnion (IntMap a)
- Data.Semigroup.Union: instance HasUnion IntSet
- Data.Semigroup.Union: instance HasUnion f => Reducer f (Union f)
- Data.Semigroup.Union: instance HasUnion f => Semigroup (Union f)
- Data.Semigroup.Union: instance HasUnion0 (IntMap a)
- Data.Semigroup.Union: instance HasUnion0 IntSet
- Data.Semigroup.Union: instance HasUnion0 f => Monoid (Union f)
- Data.Semigroup.Union: instance HasUnionWith IntMap
- Data.Semigroup.Union: instance HasUnionWith0 IntMap
- Data.Semigroup.Union: instance Ord a => HasUnion (Set a)
- Data.Semigroup.Union: instance Ord a => HasUnion0 (Set a)
- Data.Semigroup.Union: instance Ord f => Ord (Union f)
- Data.Semigroup.Union: instance Ord k => HasUnion (Map k a)
- Data.Semigroup.Union: instance Ord k => HasUnion0 (Map k a)
- Data.Semigroup.Union: instance Ord k => HasUnionWith (Map k)
- Data.Semigroup.Union: instance Ord k => HasUnionWith0 (Map k)
- Data.Semigroup.Union: instance Read f => Read (Union f)
- Data.Semigroup.Union: instance Show f => Show (Union f)
- Data.Semigroup.Union: instance Traversable Union
- Data.Semigroup.Union: instance Traversable1 Union
+ Data.Generator: [getChar8] :: Char8 c -> c
+ Data.Generator: [getKeys] :: Keys c -> c
+ Data.Generator: [getValues] :: Values c -> c
+ Data.Generator: instance Data.Generator.Generator (Data.FingerTree.FingerTree v e)
+ Data.Generator: instance Data.Generator.Generator (Data.Generator.Char8 Data.ByteString.Internal.ByteString)
+ Data.Generator: instance Data.Generator.Generator (Data.Generator.Char8 Data.ByteString.Lazy.Internal.ByteString)
+ Data.Generator: instance Data.Generator.Generator (Data.Generator.Keys (Data.IntMap.Base.IntMap v))
+ Data.Generator: instance Data.Generator.Generator (Data.Generator.Keys (Data.Map.Base.Map k v))
+ Data.Generator: instance Data.Generator.Generator (Data.Generator.Values (Data.IntMap.Base.IntMap v))
+ Data.Generator: instance Data.Generator.Generator (Data.Generator.Values (Data.Map.Base.Map k v))
+ Data.Generator: instance Data.Generator.Generator (Data.Generator.Values (GHC.Arr.Array i e))
+ Data.Generator: instance Data.Generator.Generator (Data.HashMap.Base.HashMap k v)
+ Data.Generator: instance Data.Generator.Generator (Data.HashSet.HashSet a)
+ Data.Generator: instance Data.Generator.Generator (Data.IntMap.Base.IntMap v)
+ Data.Generator: instance Data.Generator.Generator (Data.List.NonEmpty.NonEmpty c)
+ Data.Generator: instance Data.Generator.Generator (Data.Map.Base.Map k v)
+ Data.Generator: instance Data.Generator.Generator (Data.Sequence.Seq c)
+ Data.Generator: instance Data.Generator.Generator (Data.Set.Base.Set a)
+ Data.Generator: instance Data.Generator.Generator Data.ByteString.Internal.ByteString
+ Data.Generator: instance Data.Generator.Generator Data.ByteString.Lazy.Internal.ByteString
+ Data.Generator: instance Data.Generator.Generator Data.IntSet.Base.IntSet
+ Data.Generator: instance Data.Generator.Generator Data.Text.Internal.Text
+ Data.Generator: instance Data.Generator.Generator [c]
+ Data.Generator: instance GHC.Arr.Ix i => Data.Generator.Generator (Data.Generator.Keys (GHC.Arr.Array i e))
+ Data.Generator: instance GHC.Arr.Ix i => Data.Generator.Generator (GHC.Arr.Array i e)
+ Data.Generator: type family Elem c;
+ Data.Generator: }
+ Data.Semigroup.Alt: [getAlter] :: Alter f a -> f a
+ Data.Semigroup.Alt: instance Data.Functor.Alt.Alt f => Data.Functor.Alt.Alt (Data.Semigroup.Alt.Alter f)
+ Data.Semigroup.Alt: instance Data.Functor.Alt.Alt f => Data.Semigroup.Reducer.Reducer (f a) (Data.Semigroup.Alt.Alter f a)
+ Data.Semigroup.Alt: instance Data.Functor.Alt.Alt f => Data.Semigroup.Semigroup (Data.Semigroup.Alt.Alter f a)
+ Data.Semigroup.Alt: instance Data.Functor.Plus.Plus f => Data.Functor.Plus.Plus (Data.Semigroup.Alt.Alter f)
+ Data.Semigroup.Alt: instance Data.Functor.Plus.Plus f => GHC.Base.Monoid (Data.Semigroup.Alt.Alter f a)
+ Data.Semigroup.Alt: instance GHC.Base.Functor f => GHC.Base.Functor (Data.Semigroup.Alt.Alter f)
+ Data.Semigroup.Alternative: [getAlternate] :: Alternate f a -> f a
+ Data.Semigroup.Alternative: instance GHC.Base.Alternative f => Data.Semigroup.Reducer.Reducer (f a) (Data.Semigroup.Alternative.Alternate f a)
+ Data.Semigroup.Alternative: instance GHC.Base.Alternative f => Data.Semigroup.Semigroup (Data.Semigroup.Alternative.Alternate f a)
+ Data.Semigroup.Alternative: instance GHC.Base.Alternative f => GHC.Base.Alternative (Data.Semigroup.Alternative.Alternate f)
+ Data.Semigroup.Alternative: instance GHC.Base.Alternative f => GHC.Base.Monoid (Data.Semigroup.Alternative.Alternate f a)
+ Data.Semigroup.Alternative: instance GHC.Base.Applicative f => GHC.Base.Applicative (Data.Semigroup.Alternative.Alternate f)
+ Data.Semigroup.Alternative: instance GHC.Base.Functor f => GHC.Base.Functor (Data.Semigroup.Alternative.Alternate f)
+ Data.Semigroup.Applicative: [getAp] :: Ap f m -> f m
+ Data.Semigroup.Applicative: [getTraversal] :: Traversal f -> f ()
+ Data.Semigroup.Applicative: instance (GHC.Base.Applicative f, Data.Semigroup.Reducer.Reducer c m) => Data.Semigroup.Reducer.Reducer (f c) (Data.Semigroup.Applicative.Ap f m)
+ Data.Semigroup.Applicative: instance (GHC.Base.Applicative f, Data.Semigroup.Semigroup m) => Data.Semigroup.Semigroup (Data.Semigroup.Applicative.Ap f m)
+ Data.Semigroup.Applicative: instance (GHC.Base.Applicative f, GHC.Base.Monoid m) => GHC.Base.Monoid (Data.Semigroup.Applicative.Ap f m)
+ Data.Semigroup.Applicative: instance GHC.Base.Applicative f => Data.Semigroup.Reducer.Reducer (f a) (Data.Semigroup.Applicative.Traversal f)
+ Data.Semigroup.Applicative: instance GHC.Base.Applicative f => Data.Semigroup.Semigroup (Data.Semigroup.Applicative.Traversal f)
+ Data.Semigroup.Applicative: instance GHC.Base.Applicative f => GHC.Base.Applicative (Data.Semigroup.Applicative.Ap f)
+ Data.Semigroup.Applicative: instance GHC.Base.Applicative f => GHC.Base.Monoid (Data.Semigroup.Applicative.Traversal f)
+ Data.Semigroup.Applicative: instance GHC.Base.Functor f => GHC.Base.Functor (Data.Semigroup.Applicative.Ap f)
+ Data.Semigroup.Apply: [getApp] :: App f m -> f m
+ Data.Semigroup.Apply: [getTrav] :: Trav f -> f ()
+ Data.Semigroup.Apply: instance (Data.Functor.Bind.Class.Apply f, Data.Semigroup.Reducer.Reducer c m) => Data.Semigroup.Reducer.Reducer (f c) (Data.Semigroup.Apply.App f m)
+ Data.Semigroup.Apply: instance (Data.Functor.Bind.Class.Apply f, Data.Semigroup.Semigroup m) => Data.Semigroup.Semigroup (Data.Semigroup.Apply.App f m)
+ Data.Semigroup.Apply: instance Data.Functor.Bind.Class.Apply f => Data.Functor.Bind.Class.Apply (Data.Semigroup.Apply.App f)
+ Data.Semigroup.Apply: instance Data.Functor.Bind.Class.Apply f => Data.Semigroup.Reducer.Reducer (f a) (Data.Semigroup.Apply.Trav f)
+ Data.Semigroup.Apply: instance Data.Functor.Bind.Class.Apply f => Data.Semigroup.Semigroup (Data.Semigroup.Apply.Trav f)
+ Data.Semigroup.Apply: instance GHC.Base.Functor f => GHC.Base.Functor (Data.Semigroup.Apply.App f)
+ Data.Semigroup.Generator: instance Data.Semigroup.Generator.Generator1 (Data.List.NonEmpty.NonEmpty e)
+ Data.Semigroup.Monad: [getAction] :: Action f -> f ()
+ Data.Semigroup.Monad: [getMon] :: Mon f m -> f m
+ Data.Semigroup.Monad: instance (GHC.Base.Monad f, Data.Semigroup.Reducer.Reducer c m) => Data.Semigroup.Reducer.Reducer (f c) (Data.Semigroup.Monad.Mon f m)
+ Data.Semigroup.Monad: instance (GHC.Base.Monad f, Data.Semigroup.Semigroup m) => Data.Semigroup.Semigroup (Data.Semigroup.Monad.Mon f m)
+ Data.Semigroup.Monad: instance (GHC.Base.Monad f, GHC.Base.Monoid m) => GHC.Base.Monoid (Data.Semigroup.Monad.Mon f m)
+ Data.Semigroup.Monad: instance GHC.Base.Applicative f => GHC.Base.Applicative (Data.Semigroup.Monad.Mon f)
+ Data.Semigroup.Monad: instance GHC.Base.Functor f => GHC.Base.Functor (Data.Semigroup.Monad.Mon f)
+ Data.Semigroup.Monad: instance GHC.Base.Monad f => Data.Semigroup.Reducer.Reducer (f a) (Data.Semigroup.Monad.Action f)
+ Data.Semigroup.Monad: instance GHC.Base.Monad f => Data.Semigroup.Semigroup (Data.Semigroup.Monad.Action f)
+ Data.Semigroup.Monad: instance GHC.Base.Monad f => GHC.Base.Monad (Data.Semigroup.Monad.Mon f)
+ Data.Semigroup.Monad: instance GHC.Base.Monad f => GHC.Base.Monoid (Data.Semigroup.Monad.Action f)
+ Data.Semigroup.MonadPlus: [getMonadSum] :: MonadSum f a -> f a
+ Data.Semigroup.MonadPlus: instance GHC.Base.Alternative f => GHC.Base.Alternative (Data.Semigroup.MonadPlus.MonadSum f)
+ Data.Semigroup.MonadPlus: instance GHC.Base.Applicative f => GHC.Base.Applicative (Data.Semigroup.MonadPlus.MonadSum f)
+ Data.Semigroup.MonadPlus: instance GHC.Base.Functor f => GHC.Base.Functor (Data.Semigroup.MonadPlus.MonadSum f)
+ Data.Semigroup.MonadPlus: instance GHC.Base.Monad f => GHC.Base.Monad (Data.Semigroup.MonadPlus.MonadSum f)
+ Data.Semigroup.MonadPlus: instance GHC.Base.MonadPlus f => Data.Semigroup.Reducer.Reducer (f a) (Data.Semigroup.MonadPlus.MonadSum f a)
+ Data.Semigroup.MonadPlus: instance GHC.Base.MonadPlus f => Data.Semigroup.Semigroup (Data.Semigroup.MonadPlus.MonadSum f a)
+ Data.Semigroup.MonadPlus: instance GHC.Base.MonadPlus f => GHC.Base.MonadPlus (Data.Semigroup.MonadPlus.MonadSum f)
+ Data.Semigroup.MonadPlus: instance GHC.Base.MonadPlus f => GHC.Base.Monoid (Data.Semigroup.MonadPlus.MonadSum f a)
+ Data.Semigroup.Reducer: [getCount] :: Count -> Int
+ Data.Semigroup.Reducer: instance (Data.Semigroup.Reducer.Reducer c m, Data.Semigroup.Reducer.Reducer c n) => Data.Semigroup.Reducer.Reducer c (m, n)
+ Data.Semigroup.Reducer: instance (Data.Semigroup.Reducer.Reducer c m, Data.Semigroup.Reducer.Reducer c n, Data.Semigroup.Reducer.Reducer c o) => Data.Semigroup.Reducer.Reducer c (m, n, o)
+ Data.Semigroup.Reducer: instance (Data.Semigroup.Reducer.Reducer c m, Data.Semigroup.Reducer.Reducer c n, Data.Semigroup.Reducer.Reducer c o, Data.Semigroup.Reducer.Reducer c p) => Data.Semigroup.Reducer.Reducer c (m, n, o, p)
+ Data.Semigroup.Reducer: instance (GHC.Classes.Eq k, Data.Hashable.Class.Hashable k) => Data.Semigroup.Reducer.Reducer (k, v) (Data.HashMap.Base.HashMap k v)
+ Data.Semigroup.Reducer: instance Data.Data.Data Data.Semigroup.Reducer.Count
+ Data.Semigroup.Reducer: instance Data.FingerTree.Measured v a => Data.Semigroup.Reducer.Reducer a (Data.FingerTree.FingerTree v a)
+ Data.Semigroup.Reducer: instance Data.Hashable.Class.Hashable Data.Semigroup.Reducer.Count
+ Data.Semigroup.Reducer: instance Data.Semigroup.Reducer.Reducer (GHC.Base.Maybe a) (Data.Monoid.First a)
+ Data.Semigroup.Reducer: instance Data.Semigroup.Reducer.Reducer (GHC.Base.Maybe a) (Data.Monoid.Last a)
+ Data.Semigroup.Reducer: instance Data.Semigroup.Reducer.Reducer (GHC.Types.Int, v) (Data.IntMap.Base.IntMap v)
+ Data.Semigroup.Reducer: instance Data.Semigroup.Reducer.Reducer (a -> a) (Data.Monoid.Endo a)
+ Data.Semigroup.Reducer: instance Data.Semigroup.Reducer.Reducer GHC.Types.Bool Data.Monoid.All
+ Data.Semigroup.Reducer: instance Data.Semigroup.Reducer.Reducer GHC.Types.Bool Data.Monoid.Any
+ Data.Semigroup.Reducer: instance Data.Semigroup.Reducer.Reducer GHC.Types.Int Data.IntSet.Base.IntSet
+ Data.Semigroup.Reducer: instance Data.Semigroup.Reducer.Reducer a (Data.Semigroup.First a)
+ Data.Semigroup.Reducer: instance Data.Semigroup.Reducer.Reducer a (Data.Semigroup.Last a)
+ Data.Semigroup.Reducer: instance Data.Semigroup.Reducer.Reducer a (Data.Sequence.Seq a)
+ Data.Semigroup.Reducer: instance Data.Semigroup.Reducer.Reducer a Data.Semigroup.Reducer.Count
+ Data.Semigroup.Reducer: instance Data.Semigroup.Reducer.Reducer c ()
+ Data.Semigroup.Reducer: instance Data.Semigroup.Reducer.Reducer c [c]
+ Data.Semigroup.Reducer: instance Data.Semigroup.Semigroup Data.Semigroup.Reducer.Count
+ Data.Semigroup.Reducer: instance Data.Semigroup.Semigroup a => Data.Semigroup.Reducer.Reducer a (Data.Monoid.Dual a)
+ Data.Semigroup.Reducer: instance GHC.Base.Monoid Data.Semigroup.Reducer.Count
+ Data.Semigroup.Reducer: instance GHC.Base.Monoid m => Data.Semigroup.Reducer.Reducer m (Data.Semigroup.WrappedMonoid m)
+ Data.Semigroup.Reducer: instance GHC.Classes.Eq Data.Semigroup.Reducer.Count
+ Data.Semigroup.Reducer: instance GHC.Classes.Ord Data.Semigroup.Reducer.Count
+ Data.Semigroup.Reducer: instance GHC.Classes.Ord a => Data.Semigroup.Reducer.Reducer a (Data.Semigroup.Max a)
+ Data.Semigroup.Reducer: instance GHC.Classes.Ord a => Data.Semigroup.Reducer.Reducer a (Data.Semigroup.Min a)
+ Data.Semigroup.Reducer: instance GHC.Classes.Ord a => Data.Semigroup.Reducer.Reducer a (Data.Set.Base.Set a)
+ Data.Semigroup.Reducer: instance GHC.Classes.Ord k => Data.Semigroup.Reducer.Reducer (k, v) (Data.Map.Base.Map k v)
+ Data.Semigroup.Reducer: instance GHC.Num.Num a => Data.Semigroup.Reducer.Reducer a (Data.Monoid.Product a)
+ Data.Semigroup.Reducer: instance GHC.Num.Num a => Data.Semigroup.Reducer.Reducer a (Data.Monoid.Sum a)
+ Data.Semigroup.Reducer: instance GHC.Read.Read Data.Semigroup.Reducer.Count
+ Data.Semigroup.Reducer: instance GHC.Show.Show Data.Semigroup.Reducer.Count
+ Data.Semigroup.Reducer.With: [withoutReducer] :: WithReducer m c -> c
+ Data.Semigroup.Reducer.With: instance (GHC.Base.Monoid m, Data.Semigroup.Reducer.Reducer c m) => Data.FingerTree.Measured m (Data.Semigroup.Reducer.With.WithReducer m c)
+ Data.Semigroup.Reducer.With: instance Data.Foldable.Foldable (Data.Semigroup.Reducer.With.WithReducer m)
+ Data.Semigroup.Reducer.With: instance Data.Hashable.Class.Hashable c => Data.Hashable.Class.Hashable (Data.Semigroup.Reducer.With.WithReducer m c)
+ Data.Semigroup.Reducer.With: instance Data.Semigroup.Foldable.Class.Foldable1 (Data.Semigroup.Reducer.With.WithReducer m)
+ Data.Semigroup.Reducer.With: instance Data.Semigroup.Reducer.Reducer c m => Data.Semigroup.Reducer.Reducer (Data.Semigroup.Reducer.With.WithReducer m c) m
+ Data.Semigroup.Reducer.With: instance Data.Semigroup.Traversable.Class.Traversable1 (Data.Semigroup.Reducer.With.WithReducer m)
+ Data.Semigroup.Reducer.With: instance Data.Traversable.Traversable (Data.Semigroup.Reducer.With.WithReducer m)
+ Data.Semigroup.Reducer.With: instance GHC.Base.Functor (Data.Semigroup.Reducer.With.WithReducer m)
+ Data.Semigroup.Reducer.With: instance GHC.Classes.Eq c => GHC.Classes.Eq (Data.Semigroup.Reducer.With.WithReducer m c)
+ Data.Semigroup.Reducer.With: instance GHC.Classes.Ord c => GHC.Classes.Ord (Data.Semigroup.Reducer.With.WithReducer m c)
+ Data.Semigroup.Reducer.With: instance GHC.Read.Read c => GHC.Read.Read (Data.Semigroup.Reducer.With.WithReducer m c)
+ Data.Semigroup.Reducer.With: instance GHC.Show.Show c => GHC.Show.Show (Data.Semigroup.Reducer.With.WithReducer m c)
+ Data.Semigroup.Self: [getSelf] :: Self m -> m
+ Data.Semigroup.Self: instance Data.Foldable.Foldable Data.Semigroup.Self.Self
+ Data.Semigroup.Self: instance Data.Semigroup.Foldable.Class.Foldable1 Data.Semigroup.Self.Self
+ Data.Semigroup.Self: instance Data.Semigroup.Semigroup m => Data.Semigroup.Reducer.Reducer m (Data.Semigroup.Self.Self m)
+ Data.Semigroup.Self: instance Data.Semigroup.Semigroup m => Data.Semigroup.Semigroup (Data.Semigroup.Self.Self m)
+ Data.Semigroup.Self: instance Data.Semigroup.Traversable.Class.Traversable1 Data.Semigroup.Self.Self
+ Data.Semigroup.Self: instance Data.Traversable.Traversable Data.Semigroup.Self.Self
+ Data.Semigroup.Self: instance GHC.Base.Functor Data.Semigroup.Self.Self
+ Data.Semigroup.Self: instance GHC.Base.Monoid m => GHC.Base.Monoid (Data.Semigroup.Self.Self m)
+ Data.Semigroup.Union: [getUnionWith] :: UnionWith f m -> f m
+ Data.Semigroup.Union: [getUnion] :: Union f -> f
+ Data.Semigroup.Union: instance (Data.Semigroup.Union.HasUnionWith f, Data.Semigroup.Semigroup m) => Data.Semigroup.Semigroup (Data.Semigroup.Union.UnionWith f m)
+ Data.Semigroup.Union: instance (Data.Semigroup.Union.HasUnionWith f, Data.Semigroup.Semigroup m, GHC.Base.Monoid m) => Data.Semigroup.Reducer.Reducer (f m) (Data.Semigroup.Union.UnionWith f m)
+ Data.Semigroup.Union: instance (Data.Semigroup.Union.HasUnionWith0 f, GHC.Base.Monoid m) => GHC.Base.Monoid (Data.Semigroup.Union.UnionWith f m)
+ Data.Semigroup.Union: instance (GHC.Classes.Eq a, Data.Hashable.Class.Hashable a) => Data.Semigroup.Union.HasUnion (Data.HashSet.HashSet a)
+ Data.Semigroup.Union: instance (GHC.Classes.Eq a, Data.Hashable.Class.Hashable a) => Data.Semigroup.Union.HasUnion0 (Data.HashSet.HashSet a)
+ Data.Semigroup.Union: instance (GHC.Classes.Eq k, Data.Hashable.Class.Hashable k) => Data.Semigroup.Union.HasUnion (Data.HashMap.Base.HashMap k a)
+ Data.Semigroup.Union: instance (GHC.Classes.Eq k, Data.Hashable.Class.Hashable k) => Data.Semigroup.Union.HasUnion0 (Data.HashMap.Base.HashMap k a)
+ Data.Semigroup.Union: instance (GHC.Classes.Eq k, Data.Hashable.Class.Hashable k) => Data.Semigroup.Union.HasUnionWith (Data.HashMap.Base.HashMap k)
+ Data.Semigroup.Union: instance (GHC.Classes.Eq k, Data.Hashable.Class.Hashable k) => Data.Semigroup.Union.HasUnionWith0 (Data.HashMap.Base.HashMap k)
+ Data.Semigroup.Union: instance Data.Foldable.Foldable Data.Semigroup.Union.Union
+ Data.Semigroup.Union: instance Data.Semigroup.Foldable.Class.Foldable1 Data.Semigroup.Union.Union
+ Data.Semigroup.Union: instance Data.Semigroup.Traversable.Class.Traversable1 Data.Semigroup.Union.Union
+ Data.Semigroup.Union: instance Data.Semigroup.Union.HasUnion (Data.IntMap.Base.IntMap a)
+ Data.Semigroup.Union: instance Data.Semigroup.Union.HasUnion Data.IntSet.Base.IntSet
+ Data.Semigroup.Union: instance Data.Semigroup.Union.HasUnion f => Data.Semigroup.Reducer.Reducer f (Data.Semigroup.Union.Union f)
+ Data.Semigroup.Union: instance Data.Semigroup.Union.HasUnion f => Data.Semigroup.Semigroup (Data.Semigroup.Union.Union f)
+ Data.Semigroup.Union: instance Data.Semigroup.Union.HasUnion0 (Data.IntMap.Base.IntMap a)
+ Data.Semigroup.Union: instance Data.Semigroup.Union.HasUnion0 Data.IntSet.Base.IntSet
+ Data.Semigroup.Union: instance Data.Semigroup.Union.HasUnion0 f => GHC.Base.Monoid (Data.Semigroup.Union.Union f)
+ Data.Semigroup.Union: instance Data.Semigroup.Union.HasUnionWith Data.IntMap.Base.IntMap
+ Data.Semigroup.Union: instance Data.Semigroup.Union.HasUnionWith0 Data.IntMap.Base.IntMap
+ Data.Semigroup.Union: instance Data.Traversable.Traversable Data.Semigroup.Union.Union
+ Data.Semigroup.Union: instance GHC.Base.Functor Data.Semigroup.Union.Union
+ Data.Semigroup.Union: instance GHC.Classes.Eq a => Data.Semigroup.Union.HasUnion [a]
+ Data.Semigroup.Union: instance GHC.Classes.Eq a => Data.Semigroup.Union.HasUnion0 [a]
+ Data.Semigroup.Union: instance GHC.Classes.Eq f => GHC.Classes.Eq (Data.Semigroup.Union.Union f)
+ Data.Semigroup.Union: instance GHC.Classes.Ord a => Data.Semigroup.Union.HasUnion (Data.Set.Base.Set a)
+ Data.Semigroup.Union: instance GHC.Classes.Ord a => Data.Semigroup.Union.HasUnion0 (Data.Set.Base.Set a)
+ Data.Semigroup.Union: instance GHC.Classes.Ord f => GHC.Classes.Ord (Data.Semigroup.Union.Union f)
+ Data.Semigroup.Union: instance GHC.Classes.Ord k => Data.Semigroup.Union.HasUnion (Data.Map.Base.Map k a)
+ Data.Semigroup.Union: instance GHC.Classes.Ord k => Data.Semigroup.Union.HasUnion0 (Data.Map.Base.Map k a)
+ Data.Semigroup.Union: instance GHC.Classes.Ord k => Data.Semigroup.Union.HasUnionWith (Data.Map.Base.Map k)
+ Data.Semigroup.Union: instance GHC.Classes.Ord k => Data.Semigroup.Union.HasUnionWith0 (Data.Map.Base.Map k)
+ Data.Semigroup.Union: instance GHC.Read.Read f => GHC.Read.Read (Data.Semigroup.Union.Union f)
+ Data.Semigroup.Union: instance GHC.Show.Show f => GHC.Show.Show (Data.Semigroup.Union.Union f)
- Data.Generator: class Generator c where type family Elem c mapReduce f = mapTo f mempty mapTo f m = mappend m . mapReduce f mapFrom f = mappend . mapReduce f
+ Data.Generator: class Generator c where type Elem c mapReduce f = mapTo f mempty mapTo f m = mappend m . mapReduce f mapFrom f = mappend . mapReduce f where {

Files

.travis.yml view
@@ -1,49 +1,110 @@+# This file has been generated -- see https://github.com/hvr/multi-ghc-travis language: c sudo: false +cache:+  directories:+    - $HOME/.cabsnap+    - $HOME/.cabal/packages++before_cache:+  - rm -fv $HOME/.cabal/packages/hackage.haskell.org/build-reports.log+  - rm -fv $HOME/.cabal/packages/hackage.haskell.org/00-index.tar+ matrix:   include:-    - env: CABALVER=1.16 GHCVER=7.4.2-      addons: {apt: {packages: [cabal-install-1.16,ghc-7.4.2], sources: [hvr-ghc]}}-    - env: CABALVER=1.16 GHCVER=7.6.3-      addons: {apt: {packages: [cabal-install-1.16,ghc-7.6.3], sources: [hvr-ghc]}}-    - env: CABALVER=1.18 GHCVER=7.8.4-      addons: {apt: {packages: [cabal-install-1.18,ghc-7.8.4], sources: [hvr-ghc]}}-    - env: CABALVER=1.22 GHCVER=7.10.1-      addons: {apt: {packages: [cabal-install-1.22,ghc-7.10.1],sources: [hvr-ghc]}}+    - env: CABALVER=1.24 GHCVER=7.0.4+      compiler: ": #GHC 7.0.4"+      addons: {apt: {packages: [cabal-install-1.24,ghc-7.0.4], sources: [hvr-ghc]}}+    - env: CABALVER=1.24 GHCVER=7.2.2+      compiler: ": #GHC 7.2.2"+      addons: {apt: {packages: [cabal-install-1.24,ghc-7.2.2], sources: [hvr-ghc]}}+    - env: CABALVER=1.24 GHCVER=7.4.2+      compiler: ": #GHC 7.4.2"+      addons: {apt: {packages: [cabal-install-1.24,ghc-7.4.2], sources: [hvr-ghc]}}+    - env: CABALVER=1.24 GHCVER=7.6.3+      compiler: ": #GHC 7.6.3"+      addons: {apt: {packages: [cabal-install-1.24,ghc-7.6.3], sources: [hvr-ghc]}}+    - env: CABALVER=1.24 GHCVER=7.8.4+      compiler: ": #GHC 7.8.4"+      addons: {apt: {packages: [cabal-install-1.24,ghc-7.8.4], sources: [hvr-ghc]}}+    - env: CABALVER=1.24 GHCVER=7.10.3+      compiler: ": #GHC 7.10.3"+      addons: {apt: {packages: [cabal-install-1.24,ghc-7.10.3], sources: [hvr-ghc]}}+    - env: CABALVER=1.24 GHCVER=8.0.2+      compiler: ": #GHC 8.0.2"+      addons: {apt: {packages: [cabal-install-1.24,ghc-8.0.2], sources: [hvr-ghc]}}+    - env: CABALVER=2.0 GHCVER=8.2.1+      compiler: ": #GHC 8.2.1"+      addons: {apt: {packages: [cabal-install-2.0,ghc-8.2.1], sources: [hvr-ghc]}}     - env: CABALVER=head GHCVER=head-      addons: {apt: {packages: [cabal-install-head,ghc-head],  sources: [hvr-ghc]}}+      compiler: ": #GHC head"+      addons: {apt: {packages: [cabal-install-head,ghc-head], sources: [hvr-ghc]}}    allow_failures:-   - env: CABALVER=head GHCVER=head+    - env: CABALVER=head GHCVER=head  before_install:+ - unset CC  - export PATH=/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH- - export CABAL=cabal-$CABALVER- - $CABAL --version  install:- - travis_retry $CABAL update- - $CABAL install --enable-tests --only-dependencies+ - cabal --version+ - echo "$(ghc --version) [$(ghc --print-project-git-commit-id 2> /dev/null || echo '?')]"+ - if [ -f $HOME/.cabal/packages/hackage.haskell.org/00-index.tar.gz ];+   then+     zcat $HOME/.cabal/packages/hackage.haskell.org/00-index.tar.gz >+          $HOME/.cabal/packages/hackage.haskell.org/00-index.tar;+   fi+ - travis_retry cabal update -v+ - sed -i 's/^jobs:/-- jobs:/' ${HOME}/.cabal/config+ - cabal install --only-dependencies --enable-tests --enable-benchmarks --dry -v > installplan.txt+ - sed -i -e '1,/^Resolving /d' installplan.txt; cat installplan.txt -script:- - $CABAL configure -v2 --enable-tests- - $CABAL build- - $CABAL test- - $CABAL sdist- - export SRC_TGZ=$(cabal info . | awk '{print $2 ".tar.gz";exit}') ;-   cd dist/;-   if [ -f "$SRC_TGZ" ]; then-      $CABAL install "$SRC_TGZ";+# check whether current requested install-plan matches cached package-db snapshot+ - if diff -u installplan.txt $HOME/.cabsnap/installplan.txt;+   then+     echo "cabal build-cache HIT";+     rm -rfv .ghc;+     cp -a $HOME/.cabsnap/ghc $HOME/.ghc;+     cp -a $HOME/.cabsnap/lib $HOME/.cabsnap/share $HOME/.cabsnap/bin $HOME/.cabal/;    else-      echo "expected '$SRC_TGZ' not found";-      exit 1;+     echo "cabal build-cache MISS";+     rm -rf $HOME/.cabsnap;+     mkdir -p $HOME/.ghc $HOME/.cabal/lib $HOME/.cabal/share $HOME/.cabal/bin;+     cabal install -j --only-dependencies --enable-tests --enable-benchmarks;    fi +# snapshot package-db on cache miss+ - if [ ! -d $HOME/.cabsnap ];+   then+      echo "snapshotting package-db to build-cache";+      mkdir $HOME/.cabsnap;+      cp -a $HOME/.ghc $HOME/.cabsnap/ghc;+      cp -a $HOME/.cabal/lib $HOME/.cabal/share $HOME/.cabal/bin installplan.txt $HOME/.cabsnap/;+   fi++# Here starts the actual work to be performed for the package under test;+# any command which exits with a non-zero exit code causes the build to fail.+script:+ - if [ -f configure.ac ]; then autoreconf -i; fi+ - cabal configure --enable-tests --enable-benchmarks -v2  # -v2 provides useful information for debugging+ - cabal build   # this builds all libraries and executables (including tests/benchmarks)+ - cabal test+ - cabal sdist   # tests that a source-distribution can be generated++# Check that the resulting source distribution can be built & installed.+# If there are no other `.tar.gz` files in `dist`, this can be even simpler:+# `cabal install --force-reinstalls dist/*-*.tar.gz`+ - SRC_TGZ=$(cabal info . | awk '{print $2;exit}').tar.gz &&+   (cd dist && cabal install --force-reinstalls "$SRC_TGZ")+ notifications:   irc:     channels:       - "irc.freenode.org#haskell-lens"     skip_join: true     template:-      - "\x0313reducers\x0f/\x0306%{branch}\x0f \x0314%{commit}\x0f %{message} \x0302\x1f%{build_url}\x0f"+      - "\x0313reducers\x03/\x0306%{branch}\x03 \x0314%{commit}\x03 %{build_url} %{message}"++# EOF
LICENSE view
@@ -1,4 +1,4 @@-Copyright 2008-2011 Edward Kmett+Copyright 2008-2016 Edward Kmett  All rights reserved. 
reducers.cabal view
@@ -1,6 +1,6 @@ name:          reducers category:      Data, Math, Numerical, Semigroups-version:       3.12.1+version:       3.12.2 license:       BSD3 cabal-version: >= 1.6 license-file:  LICENSE@@ -9,7 +9,7 @@ stability:     provisional homepage:      http://github.com/ekmett/reducers/ bug-reports:   http://github.com/ekmett/reducers/issues-copyright:     Copyright (C) 2008-2013 Edward A. Kmett+copyright:     Copyright (C) 2008-2016 Edward A. Kmett synopsis:      Semigroups, specialized containers and a general map/reduce framework description:   Semigroups, specialized containers and a general map/reduce framework build-type:    Simple@@ -25,13 +25,13 @@   build-depends:     base                   >= 4        && < 5,     array                  >= 0.3      && < 0.6,-    transformers           >= 0.2      && < 0.5,+    transformers           >= 0.2      && < 0.6,     bytestring             >= 0.9.1    && < 0.11,     containers             >= 0.3      && < 0.6,     fingertree             >= 0.1      && < 0.2,     hashable               >= 1.1.2.1  && < 1.3,     text                   >= 0.11.1.5 && < 1.3,-    unordered-containers   >= 0.1.4    && < 0.3,+    unordered-containers   >= 0.2      && < 0.3,     semigroups             >= 0.9      && < 1,     semigroupoids          >= 4        && < 6 @@ -56,3 +56,8 @@     cpp-options: -DLANGUAGE_DeriveDataTypeable    ghc-options: -Wall++  -- hack around the buggy unused matches check for class associated types in ghc 8 rc1+  if impl(ghc >= 8)+    ghc-options: -fno-warn-unused-matches+
src/Data/Generator.hs view
@@ -1,12 +1,13 @@ {-# LANGUAGE UndecidableInstances, FlexibleContexts, MultiParamTypeClasses, FlexibleInstances, TypeFamilies, CPP #-}-#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702-{-# LANGUAGE Trustworthy #-}++#ifndef MIN_VERSION_base+#define MIN_VERSION_base(x,y,z) 1 #endif  ----------------------------------------------------------------------------- -- | -- Module      :  Data.Generator--- Copyright   :  (c) Edward Kmett 2009+-- Copyright   :  (c) Edward Kmett 2009-2016 -- License     :  BSD-style -- Maintainer  :  ekmett@gmail.com -- Stability   :  experimental@@ -47,7 +48,7 @@ import qualified Data.ByteString.Lazy as Lazy (ByteString, toChunks) import qualified Data.ByteString.Lazy.Char8 as Lazy8 (toChunks) import Data.Word (Word8)-import Data.FingerTree (Measured, FingerTree)+import Data.FingerTree (FingerTree) import Data.Sequence (Seq) import qualified Data.Set as Set import Data.Set (Set)@@ -104,7 +105,7 @@   type Elem (NonEmpty c) = c   mapReduce f = mapReduce f . NonEmpty.toList -instance Measured v e => Generator (FingerTree v e) where+instance Generator (FingerTree v e) where   type Elem (FingerTree v e) = e   mapReduce f = foldMap (unit . f) @@ -166,7 +167,11 @@   type Elem (Values (Map k v)) = v   mapReduce f = mapReduce f . Map.elems . getValues +#if MIN_VERSION_base(4,9,0)+instance Generator (Values (Array i e)) where+#else instance Ix i => Generator (Values (Array i e)) where+#endif   type Elem (Values (Array i e)) = e   mapReduce f = mapReduce f . elems . getValues 
src/Data/Semigroup/Instances.hs view
@@ -5,8 +5,10 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} module Data.Semigroup.Instances where +#if !(MIN_VERSION_fingertree(0,1,2) && MIN_VERSION_base(4,9,0)) import Data.FingerTree import Data.Semigroup  instance Measured v a => Semigroup (FingerTree v a) where   (<>) = mappend+#endif
src/Data/Semigroup/Reducer.hs view
@@ -55,6 +55,8 @@ import Data.IntMap (IntMap) import qualified Data.Map as Map import Data.Map (Map)+import qualified Data.HashMap.Lazy as HashMap+import Data.HashMap.Lazy (HashMap)  #ifdef LANGUAGE_DeriveDataTypeable import Data.Data@@ -232,6 +234,12 @@   unit = uncurry Map.singleton   cons = uncurry Map.insert   snoc = flip . uncurry . Map.insertWith $ const id+++instance (Eq k, Hashable k) => Reducer (k, v) (HashMap k v) where+  unit = uncurry HashMap.singleton+  cons = uncurry HashMap.insert+  snoc = flip . uncurry . HashMap.insertWith $ const id  instance Monoid m => Reducer m (WrappedMonoid m) where   unit = WrapMonoid
src/Data/Semigroup/Union.hs view
@@ -157,13 +157,11 @@ instance Ord k => HasUnionWith0 (Map k) where   emptyWith = Map.empty --- TODO: add unionWith to unordered-containers----instance Eq k => HasUnionWith (HashMap k) where---  unionWith = HashMap.unionWith+instance (Eq k, Hashable k) => HasUnionWith (HashMap k) where+  unionWith = HashMap.unionWith ---instance Ord k => HasUnionWith0 (Map k) where---  emptyWith = Map.empty+instance (Eq k, Hashable k) => HasUnionWith0 (HashMap k) where+  emptyWith = HashMap.empty  -- | The 'Monoid' @('unionWith mappend','empty')@ for containers full of monoids. newtype UnionWith f m = UnionWith { getUnionWith :: f m }