diff --git a/compactable.cabal b/compactable.cabal
--- a/compactable.cabal
+++ b/compactable.cabal
@@ -1,5 +1,5 @@
 name:                compactable
-version:             0.1.1.1
+version:             0.1.2.0
 synopsis:            A typeclass for structures which can be catMaybed, filtered, and partitioned.
 description:         This provides polymorphic implimentations for filter, compact (catMaybes), and separate. It allows for higher performance implimentations to be used in place of defaults for all data structures, and endeavors to centerally document those implimentations. Compactable aims to be as general and unconstrained as possible, providing instances for non-Functors like Set, as well as some Contravariants (though not published here). Compactable fully subsumes Data.Witherable, offers more laws, and is more general.
 license:             BSD3
diff --git a/src/Control/Compactable.hs b/src/Control/Compactable.hs
--- a/src/Control/Compactable.hs
+++ b/src/Control/Compactable.hs
@@ -1,8 +1,11 @@
 {-# LANGUAGE ConstrainedClassMethods    #-}
 {-# LANGUAGE DefaultSignatures          #-}
+{-# LANGUAGE FlexibleContexts           #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
 {-# LANGUAGE KindSignatures             #-}
 {-# LANGUAGE LambdaCase                 #-}
+{-# LANGUAGE StandaloneDeriving         #-}
+{-# LANGUAGE TypeOperators              #-}
 
 module Control.Compactable
   (
@@ -34,7 +37,8 @@
 
 import           Control.Applicative
 import           Control.Arrow
-import           Control.Monad                   (MonadPlus (..), join)
+import           Control.Monad                   (MonadPlus, join)
+import           Control.Monad.Trans.Error       (Error)
 import           Control.Monad.Trans.Except
 import           Control.Monad.Trans.Maybe
 import           Data.Bifoldable
@@ -46,12 +50,14 @@
 import qualified Data.IntMap                     as IntMap
 import qualified Data.Map                        as Map
 import           Data.Maybe
+import           Data.Monoid
 import           Data.Proxy
 import           Data.Semigroup
 import qualified Data.Sequence                   as Seq
 import qualified Data.Set                        as Set
 import qualified Data.Vector                     as V
 import           GHC.Conc
+import           GHC.Generics
 import           Text.ParserCombinators.ReadP
 import           Text.ParserCombinators.ReadPrec
 
@@ -274,6 +280,9 @@
       go []     = pure []
     {-# INLINE traverseMaybe #-}
 
+instance Compactable ZipList where
+  compact (ZipList xs) = ZipList $ compact xs
+
 instance Compactable IO where
     compact = altDefaultCompact
     {-# INLINABLE compact #-}
@@ -295,7 +304,15 @@
     {-# INLINABLE applyMaybe #-}
     bindMaybe _ _ = Proxy
     {-# INLINABLE bindMaybe #-}
+    fmapEither _ _ = (Proxy, Proxy)
+    {-# INLINABLE fmapEither #-}
+    applyEither _ _ = (Proxy, Proxy)
+    {-# INLINABLE applyEither #-}
+    bindEither _ _ = (Proxy, Proxy)
+    {-# INLINABLE bindEither #-}
 
+instance Compactable U1
+
 instance Compactable Option where
     compact (Option x) = Option (join x)
     {-# INLINABLE compact #-}
@@ -366,8 +383,16 @@
     {-# INLINABLE compact #-}
     fmapMaybe _ (Const r) = Const r
     {-# INLINABLE fmapMaybe #-}
+    applyMaybe _ (Const r) = Const r
+    {-# INLINABLE applyMaybe #-}
     bindMaybe (Const r) _ = Const r
     {-# INLINABLE bindMaybe #-}
+    fmapEither _ (Const r) = (Const r, Const r)
+    {-# INLINABLE fmapEither #-}
+    applyEither _ (Const r) = (Const r, Const r)
+    {-# INLINABLE applyEither #-}
+    bindEither (Const r) _ = (Const r, Const r)
+    {-# INLINABLE bindEither #-}
     filter _ (Const r) = Const r
     {-# INLINABLE filter #-}
 
@@ -379,25 +404,26 @@
     filter = Set.filter
     {-# INLINABLE filter  #-}
 
-instance (ArrowApply a, ArrowPlus a) => Compactable (ArrowMonad a) where
-    compact = compactFold
-    {-# INLINE compact #-}
-    separate = separateFold
-    {-# INLINE separate #-}
-
+instance (ArrowPlus a, ArrowApply a) => Compactable (ArrowMonad a) where
+instance Monad a => Compactable (WrappedMonad a) where
+instance Functor a => Compactable (Rec1 a) where
+instance Functor a => Compactable (Alt a) where
+instance (Functor a, Functor b) => Compactable (a :*: b)
+instance Functor f => Compactable (M1 i c f)
+instance (Functor f, Functor g) => Compactable (f :.: g)
 
-newtype MonadSum f a = MonadSum { unMonadSum :: f a }
-    deriving (Functor, Applicative, Alternative, Monad, MonadPlus)
+newtype AltSum f a = AltSum { unAltSum :: f a }
+    deriving (Functor, Applicative, Alternative)
 
-instance MonadPlus f => Monoid (MonadSum f a) where
-    mempty = mzero
-    MonadSum a `mappend` MonadSum b = MonadSum (mplus a b)
+instance Alternative f => Monoid (AltSum f a) where
+    mempty = empty
+    AltSum a `mappend` AltSum b = AltSum (a <|> b)
 
 
 {-|
 class `CompactFold` provides the same methods as `Compactable` but generalized to work on any `Foldable`.
 
-When a type has MonadPlus (or similar) properties, we can extract the Maybe and the Either, and generalize to Foldable and Bifoldable.
+When a type has Alternative (or similar) properties, we can extract the Maybe and the Either, and generalize to Foldable and Bifoldable.
 
 Compactable can always be described in terms of CompactFold, because
 
@@ -411,12 +437,12 @@
 -}
 class Compactable f => CompactFold (f :: * -> *) where
     compactFold :: Foldable g => f (g a) -> f a
-    default compactFold :: (MonadPlus f, Foldable g) => f (g a) -> f a
+    default compactFold :: (Monad f, Alternative f, Foldable g) => f (g a) -> f a
     compactFold = (>>= mfold')
     {-# INLINEABLE compactFold #-}
 
     separateFold :: Bifoldable g => f (g a b) -> (f a, f b)
-    default separateFold :: (MonadPlus f, Bifoldable g) => f (g a b) -> (f a, f b)
+    default separateFold :: (Monad f, Alternative f, Bifoldable g) => f (g a b) -> (f a, f b)
     separateFold xs = (xs >>= mlefts, xs >>= mrights)
     {-# INLINEABLE separateFold #-}
 
@@ -453,25 +479,39 @@
     {-# INLINABLE traverseBifold #-}
 
 
-mfold' :: (Foldable f, MonadPlus m) => f a -> m a
-mfold' = unMonadSum . foldMap (MonadSum . pure)
+mfold' :: (Foldable f, Alternative m) => f a -> m a
+mfold' = unAltSum . foldMap (AltSum . pure)
 
-mlefts :: (Bifoldable f, MonadPlus m) => f a b -> m a
-mlefts = unMonadSum . bifoldMap (MonadSum . pure) (const mempty)
+mlefts :: (Bifoldable f, Alternative m) => f a b -> m a
+mlefts = unAltSum . bifoldMap (AltSum . pure) (const mempty)
 
-mrights :: (Bifoldable f, MonadPlus m) => f a b -> m b
-mrights = unMonadSum . bifoldMap (const mempty) (MonadSum . pure)
+mrights :: (Bifoldable f, Alternative m) => f a b -> m b
+mrights = unAltSum . bifoldMap (const mempty) (AltSum . pure)
 
 
 instance CompactFold [] where
-    compactFold = concat . fmap F.toList
+    compactFold = (>>= F.toList)
     {-# INLINEABLE compactFold #-}
 
 instance CompactFold Maybe
+instance (Monoid m, Error m) => CompactFold (Either m)
+instance CompactFold IO
 instance CompactFold ReadP
 instance CompactFold ReadPrec
 instance CompactFold STM
-instance (ArrowApply a, ArrowPlus a) => CompactFold (ArrowMonad a)
+instance CompactFold ZipList where
+  compactFold (ZipList xs) = ZipList $ compactFold xs
+  separateFold (ZipList xs) = bimap ZipList ZipList $ separateFold xs
+instance CompactFold Option
+instance CompactFold U1
+instance CompactFold Proxy
+instance (ArrowPlus a, ArrowApply a) => CompactFold (ArrowMonad a)
+instance MonadPlus a => CompactFold (WrappedMonad a)
+instance (Alternative a, Monad a) => CompactFold (Rec1 a)
+instance (Alternative a, Monad a) => CompactFold (Alt a)
+instance (Alternative f, Monad f, Alternative g, Monad g) => CompactFold (f :*: g)
+instance (Compactable f, Alternative f, Monad f, Compactable g, Alternative g, Monad g) => CompactFold (FP.Product f g)
+instance (Alternative f, Monad f) => CompactFold (M1 i c f)
 
 
 fforMaybe :: (Compactable f, Functor f) => f a -> (a -> Maybe b) -> f b