diff --git a/reducers.cabal b/reducers.cabal
--- a/reducers.cabal
+++ b/reducers.cabal
@@ -1,6 +1,6 @@
 name:          reducers
 category:      Data, Math, Numerical, Semigroups
-version:       3.10.1.1
+version:       3.10.2
 license:       BSD3
 cabal-version: >= 1.6
 license-file:  LICENSE
diff --git a/src/Data/Generator.hs b/src/Data/Generator.hs
--- a/src/Data/Generator.hs
+++ b/src/Data/Generator.hs
@@ -12,7 +12,7 @@
 -- Stability   :  experimental
 -- Portability :  portable
 --
--- A 'Generator' @c@ is a possibly-specialized container, which contains values of 
+-- 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.
 --
@@ -37,7 +37,7 @@
 
 import Data.Monoid (Monoid, mappend, mempty)
 
-import Data.Array 
+import Data.Array
 import Data.Text (Text)
 import qualified Data.Text as Text
 import qualified Data.ByteString as Strict (ByteString, foldl')
@@ -69,7 +69,7 @@
 class Generator c where
   type Elem c
   mapReduce :: (Reducer e m, Monoid m) => (Elem c -> e) -> c -> m
-  mapTo     :: (Reducer e m, Monoid m) => (Elem c -> e) -> m -> c -> m 
+  mapTo     :: (Reducer e m, Monoid m) => (Elem c -> e) -> m -> c -> m
   mapFrom   :: (Reducer e m, Monoid m) => (Elem c -> e) -> c -> m -> m
 
   mapReduce f = mapTo f mempty
@@ -123,7 +123,7 @@
   mapReduce f = mapReduce f . IntMap.toList
 
 instance Generator (Map k v) where
-  type Elem (Map k v) = (k,v) 
+  type Elem (Map k v) = (k,v)
   mapReduce f = mapReduce f . Map.toList
 
 instance Generator (HashMap k v) where
@@ -135,7 +135,7 @@
   mapReduce f = mapReduce f . assocs
 
 -- | a 'Generator' transformer that asks only for the keys of an indexed container
-newtype Keys c = Keys { getKeys :: c } 
+newtype Keys c = Keys { getKeys :: c }
 
 instance Generator (Keys (IntMap v)) where
   type Elem (Keys (IntMap v)) = Int
@@ -150,7 +150,7 @@
   mapReduce f = mapReduce f . range . bounds . getKeys
 
 -- | a 'Generator' transformer that asks only for the values contained in an indexed container
-newtype Values c = Values { getValues :: c } 
+newtype Values c = Values { getValues :: c }
 
 instance Generator (Values (IntMap v)) where
   type Elem (Values (IntMap v)) = v
@@ -166,7 +166,7 @@
 
 -- | 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 { getChar8 :: c } 
+newtype Char8 c = Char8 { getChar8 :: c }
 
 instance Generator (Char8 Strict.ByteString) where
   type Elem (Char8 Strict.ByteString) = Char
diff --git a/src/Data/Generator/Combinators.hs b/src/Data/Generator/Combinators.hs
--- a/src/Data/Generator/Combinators.hs
+++ b/src/Data/Generator/Combinators.hs
@@ -38,7 +38,7 @@
     -- * Monoidal Reduction
     , foldMap
     , fold
-    , toList 
+    , toList
     -- * List-Like Reduction
     , concatMap
     , elem
@@ -50,7 +50,7 @@
     , notElem
     ) where
 
-import Prelude hiding 
+import Prelude hiding
   ( mapM_, any, all, elem, filter, concatMap, and, or
   , sum, product, notElem, replicate, cycle, repeat
   )
@@ -73,7 +73,7 @@
 traverse_ :: (Generator c, Applicative f) => (Elem c -> f b) -> c -> f ()
 traverse_ = mapReduceWith getTraversal
 {-# INLINE traverse_ #-}
-    
+
 -- | Convenience function as found in "Data.Foldable"
 --
 -- @
@@ -87,16 +87,16 @@
 --
 -- @
 --    'reduceWith' 'getAlt'
--- @ 
+-- @
 asum :: (Generator c, Alternative f, f a ~ Elem c) => c -> f a
 asum = reduceWith getAlternate
 {-# INLINE asum #-}
 
 -- | 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 ()
 mapM_ = mapReduceWith getAction
 {-# INLINE mapM_ #-}
@@ -219,7 +219,7 @@
 {-# INLINE filter #-}
 
 -- | Allows idiomatic specialization of filter by proving a function that will be used to transform the output
-filterWith :: (Generator c, Reducer (Elem c) m, Monoid m) => (m -> n) -> (Elem c -> Bool) -> c -> n 
+filterWith :: (Generator c, Reducer (Elem c) m, Monoid m) => (m -> n) -> (Elem c -> Bool) -> c -> n
 filterWith f p = f . filter p
 {-# INLINE filterWith #-}
 
diff --git a/src/Data/Semigroup/Alt.hs b/src/Data/Semigroup/Alt.hs
--- a/src/Data/Semigroup/Alt.hs
+++ b/src/Data/Semigroup/Alt.hs
@@ -13,7 +13,7 @@
 -- Stability   :  experimental
 -- Portability :  non-portable (MPTCs)
 --
--- A semigroup for working 'Alt' or 'Plus' 
+-- A semigroup for working 'Alt' or 'Plus'
 --
 -----------------------------------------------------------------------------
 
@@ -28,15 +28,18 @@
 
 -- | A 'Alter' turns any 'Alt' instance into a 'Semigroup'.
 
-newtype Alter f a = Alter { getAlter :: f a } 
-    deriving (Functor,Alt,Plus)
+newtype Alter f a = Alter { getAlter :: f a }
+    deriving (Functor,Plus)
 
+instance Alt f => Alt (Alter f) where
+    Alter a <!> Alter b = Alter (a <!> b)
+
 instance Alt f => Semigroup (Alter f a) where
-    Alter a <> Alter b = Alter (a <!> b) 
+    Alter a <> Alter b = Alter (a <!> b)
 
 instance Plus f => Monoid (Alter f a) where
     mempty = zero
-    Alter a `mappend` Alter b = Alter (a <!> b) 
+    Alter a `mappend` Alter b = Alter (a <!> b)
 
 instance Alt f => Reducer (f a) (Alter f a) where
     unit = Alter
diff --git a/src/Data/Semigroup/Alternative.hs b/src/Data/Semigroup/Alternative.hs
--- a/src/Data/Semigroup/Alternative.hs
+++ b/src/Data/Semigroup/Alternative.hs
@@ -28,16 +28,16 @@
 
 -- | A 'Alternate' turns any 'Alternative' instance into a 'Monoid'.
 
-newtype Alternate f a = Alternate { getAlternate :: f a } 
+newtype Alternate f a = Alternate { getAlternate :: f a }
   deriving (Functor,Applicative,Alternative)
 
 instance Alternative f => Semigroup (Alternate f a) where
   Alternate a <> Alternate b = Alternate (a <|> b)
-   
+
 instance Alternative f => Monoid (Alternate f a) where
-  mempty = empty 
-  Alternate a `mappend` Alternate b = Alternate (a <|> b) 
+  mempty = empty
+  Alternate a `mappend` Alternate b = Alternate (a <|> b)
 
 instance Alternative f => Reducer (f a) (Alternate f a) where
-  unit = Alternate 
+  unit = Alternate
 
diff --git a/src/Data/Semigroup/Applicative.hs b/src/Data/Semigroup/Applicative.hs
--- a/src/Data/Semigroup/Applicative.hs
+++ b/src/Data/Semigroup/Applicative.hs
@@ -17,7 +17,7 @@
 --
 -----------------------------------------------------------------------------
 
-module Data.Semigroup.Applicative 
+module Data.Semigroup.Applicative
     ( Traversal(..)
     , Ap(..)
     ) where
@@ -28,9 +28,9 @@
 import Data.Semigroup.Reducer (Reducer(..))
 
 -- | A 'Traversal' uses an glues together 'Applicative' actions with (*>)
---   in the manner of 'traverse_' from "Data.Foldable". Any values returned by 
+--   in the manner of 'traverse_' from "Data.Foldable". Any values returned by
 --   reduced actions are discarded.
-newtype Traversal f = Traversal { getTraversal :: f () } 
+newtype Traversal f = Traversal { getTraversal :: f () }
 
 instance Applicative f => Semigroup (Traversal f) where
   Traversal a <> Traversal b = Traversal (a *> b)
@@ -51,7 +51,7 @@
 {-# RULES "unitTraversal" unit = Traversal #-}
 {-# RULES "snocTraversal" snoc = snocTraversal #-}
 
-newtype Ap f m = Ap { getApp :: f m } 
+newtype Ap f m = Ap { getApp :: f m }
   deriving (Functor,Applicative)
 
 instance (Applicative f, Semigroup m) => Semigroup (Ap f m) where
diff --git a/src/Data/Semigroup/Apply.hs b/src/Data/Semigroup/Apply.hs
--- a/src/Data/Semigroup/Apply.hs
+++ b/src/Data/Semigroup/Apply.hs
@@ -28,9 +28,9 @@
 import Data.Semigroup.Reducer (Reducer(..))
 
 -- | A 'Trav' uses an glues together 'Applicative' actions with (*>)
---   in the manner of 'traverse_' from "Data.Foldable". Any values returned by 
+--   in the manner of 'traverse_' from "Data.Foldable". Any values returned by
 --   reduced actions are discarded.
-newtype Trav f = Trav { getTrav :: f () } 
+newtype Trav f = Trav { getTrav :: f () }
 
 instance Apply f => Semigroup (Trav f) where
   Trav a <> Trav b = Trav (a .> b)
@@ -49,7 +49,7 @@
 
 -- | A 'App' turns any 'Apply' wrapped around a 'Semigroup' into a 'Semigroup'
 
-newtype App f m = App { getApp :: f m } 
+newtype App f m = App { getApp :: f m }
   deriving (Functor,Apply)
 
 instance (Apply f, Semigroup m) => Semigroup (App f m) where
diff --git a/src/Data/Semigroup/Generator.hs b/src/Data/Semigroup/Generator.hs
--- a/src/Data/Semigroup/Generator.hs
+++ b/src/Data/Semigroup/Generator.hs
@@ -12,7 +12,7 @@
 -- Stability   :  experimental
 -- Portability :  portable
 --
--- A 'Generator1' @c@ is a possibly-specialized container, which contains values of 
+-- A 'Generator1' @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.
 --
@@ -40,7 +40,7 @@
 -- | minimal definition 'mapReduce1' or 'mapTo1'
 class Generator c => Generator1 c where
   mapReduce1 :: Reducer e m => (Elem c -> e) -> c -> m
-  mapTo1     :: Reducer e m => (Elem c -> e) -> m -> c -> m 
+  mapTo1     :: Reducer e m => (Elem c -> e) -> m -> c -> m
   mapFrom1   :: Reducer e m => (Elem c -> e) -> c -> m -> m
 
   mapTo1 f m = (<>) m . mapReduce1 f
@@ -51,13 +51,13 @@
 
 {-
 mapReduceDefault :: (Generator1 c, Reducer (Elem c) m, Monoid m) => (Elem c -> e) -> c -> m
-mapReduceDefault f = unwrapMonoid . mapReduce1 f 
+mapReduceDefault f = unwrapMonoid . mapReduce1 f
 
 mapToDefault :: (Generator1 c, Reducer (Elem c) m, Monoid m) => (Elem c -> e) -> m -> c -> m
-mapToDefault f = unwrapMonoid . mapTo1 f 
+mapToDefault f = unwrapMonoid . mapTo1 f
 
 mapFromDefault :: (Generator1 c, Reducer (Elem c) m, Monoid m) => (Elem c -> e) -> m -> c -> m
-mapFromDefault f = unwrapMonoid . mapFrom1 f 
+mapFromDefault f = unwrapMonoid . mapFrom1 f
 -}
 
 -- | Apply a 'Reducer' directly to the elements of a 'Generator'
diff --git a/src/Data/Semigroup/Monad.hs b/src/Data/Semigroup/Monad.hs
--- a/src/Data/Semigroup/Monad.hs
+++ b/src/Data/Semigroup/Monad.hs
@@ -23,6 +23,7 @@
     ) where
 
 import Control.Monad (liftM, liftM2)
+import Control.Applicative (Applicative(..))
 import Data.Monoid (Monoid(..))
 import Data.Semigroup (Semigroup(..))
 import Data.Semigroup.Reducer (Reducer(..))
@@ -52,7 +53,7 @@
 {-# RULES "snocAction" snoc = snocAction #-}
 
 newtype Mon f m = Mon { getMon :: f m }
-  deriving (Monad)
+  deriving (Functor,Applicative,Monad)
 
 instance (Monad f, Semigroup m) => Semigroup (Mon f m) where
   (<>) = liftM2 (<>)
diff --git a/src/Data/Semigroup/MonadPlus.hs b/src/Data/Semigroup/MonadPlus.hs
--- a/src/Data/Semigroup/MonadPlus.hs
+++ b/src/Data/Semigroup/MonadPlus.hs
@@ -22,6 +22,7 @@
     ) where
 
 import Control.Monad (MonadPlus(..))
+import Control.Applicative (Applicative(..),Alternative(..))
 import Data.Monoid (Monoid(..))
 import Data.Semigroup (Semigroup(..))
 import Data.Semigroup.Reducer (Reducer(..))
@@ -29,7 +30,7 @@
 -- | A 'MonadSum' turns any 'MonadPlus' instance into a 'Monoid'.
 
 newtype MonadSum f a = MonadSum { getMonadSum :: f a }
-  deriving (Monad,MonadPlus)
+  deriving (Functor,Applicative,Alternative,Monad,MonadPlus)
 
 instance MonadPlus f => Semigroup (MonadSum f a) where
   MonadSum a <> MonadSum b = MonadSum (mplus a b)
diff --git a/src/Data/Semigroup/Reducer.hs b/src/Data/Semigroup/Reducer.hs
--- a/src/Data/Semigroup/Reducer.hs
+++ b/src/Data/Semigroup/Reducer.hs
@@ -17,13 +17,13 @@
 -----------------------------------------------------------------------------
 
 module Data.Semigroup.Reducer
-    ( Reducer(..)
-    , foldMapReduce, foldMapReduce1
-    , foldReduce, foldReduce1
-    , pureUnit
-    , returnUnit
-    , Count(..)
-    ) where
+  ( Reducer(..)
+  , foldMapReduce, foldMapReduce1
+  , foldReduce, foldReduce1
+  , pureUnit
+  , returnUnit
+  , Count(..)
+  ) where
 
 import Control.Applicative
 
@@ -64,17 +64,17 @@
 -- 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 
+-- this is not the case, and the few remaining cases can be handled by using an explicit
 -- type annotation.
 --
 -- Minimal definition: 'unit'
 class Semigroup m => Reducer c m where
   -- | Convert a value into a 'Semigroup'
-  unit :: c -> m 
+  unit :: c -> m
   -- | Append a value to a 'Semigroup' for use in left-to-right reduction
   snoc :: m -> c -> m
   -- | Prepend a value onto a 'Semigroup' for use during right-to-left reduction
-  cons :: c -> m -> m 
+  cons :: c -> m -> m
 
   snoc m = (<>) m . unit
   cons = (<>) . unit
@@ -94,13 +94,13 @@
 foldReduce1 :: (Foldable1 f, Reducer e m) => f e -> m
 foldReduce1 = foldMap1 unit
 
-returnUnit :: (Monad m, Reducer c n) => c -> m n 
+returnUnit :: (Monad m, Reducer c n) => c -> m n
 returnUnit = return . unit
 
 pureUnit :: (Applicative f, Reducer c n) => c -> f n
 pureUnit = pure . unit
 
-newtype Count = Count { getCount :: Int } deriving 
+newtype Count = Count { getCount :: Int } deriving
   ( Eq, Ord, Show, Read
 #ifdef LANGUAGE_DeriveDataTypeable
   , Data, Typeable
@@ -122,7 +122,7 @@
   unit _ = Count 1
   Count n `snoc` _ = Count (n + 1)
   _ `cons` Count n = Count (n + 1)
-  
+
 instance (Reducer c m, Reducer c n) => Reducer c (m,n) where
   unit x = (unit x,unit x)
   (m,n) `snoc` x = (m `snoc` x, n `snoc` x)
@@ -159,7 +159,7 @@
 
 instance Semigroup a => Reducer a (Dual a) where
   unit = Dual
-    
+
 instance Num a => Reducer a (Sum a) where
   unit = Sum
 
@@ -187,7 +187,7 @@
 instance Measured v a => Reducer a (FingerTree v a) where
   unit = singleton
   cons = (<|)
-  snoc = (|>) 
+  snoc = (|>)
 
 --instance (Stream s m t, Reducer c a) => Reducer c (ParsecT s u m a) where
 --    unit = return . unit
@@ -206,7 +206,7 @@
   unit = Set.singleton
   cons = Set.insert
   -- pedantic about order in case 'Eq' doesn't implement structural equality
-  snoc s m | Set.member m s = s 
+  snoc s m | Set.member m s = s
            | otherwise = Set.insert m s
 
 instance Reducer (Int, v) (IntMap v) where
diff --git a/src/Data/Semigroup/Reducer/With.hs b/src/Data/Semigroup/Reducer/With.hs
--- a/src/Data/Semigroup/Reducer/With.hs
+++ b/src/Data/Semigroup/Reducer/With.hs
@@ -16,8 +16,8 @@
 -----------------------------------------------------------------------------
 
 module Data.Semigroup.Reducer.With
-    ( WithReducer(..)
-    ) where
+  ( WithReducer(..)
+  ) where
 
 import Control.Applicative
 import Data.FingerTree
@@ -34,7 +34,7 @@
 --   This can be used to quickly select a "Reducer" for use as a 'FingerTree'
 --   'measure'.
 
-newtype WithReducer m c = WithReducer { withoutReducer :: c } 
+newtype WithReducer m c = WithReducer { withoutReducer :: c }
   deriving (Eq, Ord, Show, Read)
 
 instance Hashable c => Hashable (WithReducer m c) where
@@ -56,7 +56,7 @@
   traverse1 f (WithReducer a) = WithReducer <$> f a
 
 instance Reducer c m => Reducer (WithReducer m c) m where
-    unit = unit . withoutReducer 
+  unit = unit . withoutReducer
 
 instance (Monoid m, Reducer c m) => Measured m (WithReducer m c) where
-    measure = unit . withoutReducer
+  measure = unit . withoutReducer
diff --git a/src/Data/Semigroup/Union.hs b/src/Data/Semigroup/Union.hs
--- a/src/Data/Semigroup/Union.hs
+++ b/src/Data/Semigroup/Union.hs
@@ -104,7 +104,7 @@
 
 
 -- | The 'Monoid' @('union','empty')@
-newtype Union f = Union { getUnion :: f } 
+newtype Union f = Union { getUnion :: f }
   deriving (Eq,Ord,Show,Read)
 
 instance HasUnion f => Semigroup (Union f) where
@@ -141,30 +141,30 @@
 {-# SPECIALIZE unionWith :: Eq k => (a -> a -> a) -> HashMap k a -> HashMap k a -> HashMap k a #-}
 
 class HasUnionWith f => HasUnionWith0 f where
-  emptyWith :: f a 
+  emptyWith :: f a
 
-instance HasUnionWith IntMap where 
+instance HasUnionWith IntMap where
   unionWith = IntMap.unionWith
 
-instance HasUnionWith0 IntMap where 
+instance HasUnionWith0 IntMap where
   emptyWith = IntMap.empty
 
-instance Ord k => HasUnionWith (Map k) where 
+instance Ord k => HasUnionWith (Map k) where
   unionWith = Map.unionWith
 
-instance Ord k => HasUnionWith0 (Map k) where 
+instance Ord k => HasUnionWith0 (Map k) where
   emptyWith = Map.empty
 
 -- TODO: add unionWith to unordered-containers
 
---instance Eq k => HasUnionWith (HashMap k) where 
+--instance Eq k => HasUnionWith (HashMap k) where
 --  unionWith = HashMap.unionWith
 
---instance Ord k => HasUnionWith0 (Map k) where 
+--instance Ord k => HasUnionWith0 (Map k) where
 --  emptyWith = Map.empty
 
 -- | The 'Monoid' @('unionWith mappend','empty')@ for containers full of monoids.
-newtype UnionWith f m = UnionWith { getUnionWith :: f m } 
+newtype UnionWith f m = UnionWith { getUnionWith :: f m }
 
 instance (HasUnionWith f, Semigroup m) => Semigroup (UnionWith f m) where
     UnionWith a <> UnionWith b = UnionWith (unionWith (<>) a b)