diff --git a/Makefile b/Makefile
new file mode 100644
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,8 @@
+run-test:	update-test
+	runhaskell Setup configure --user --enable-tests
+	runhaskell Setup build
+	runhaskell Setup haddock
+	runhaskell Setup test non-empty-test --show-details=streaming
+
+update-test:
+	doctest-extract -i src/ -o test/ --executable-main=Main.hs Data.NonEmptyPrivate Data.NonEmpty.Map
diff --git a/non-empty.cabal b/non-empty.cabal
--- a/non-empty.cabal
+++ b/non-empty.cabal
@@ -1,10 +1,11 @@
+Cabal-Version:    2.2
 Name:             non-empty
-Version:          0.3.2
-License:          BSD3
+Version:          0.3.3
+License:          BSD-3-Clause
 License-File:     LICENSE
 Author:           Henning Thielemann <haskell@henning-thielemann.de>
 Maintainer:       Henning Thielemann <haskell@henning-thielemann.de>
-Homepage:         http://hub.darcs.net/thielema/non-empty/
+Homepage:         https://hub.darcs.net/thielema/non-empty/
 Category:         Data
 Synopsis:         List-like structures with static restrictions on the number of elements
 Description:
@@ -62,17 +63,18 @@
     Requires multi-parameter type classes with functional dependencies.
 
 Tested-With:      GHC==7.4.2, GHC==7.6.3, GHC==7.8.4, GHC==7.10.1
-Cabal-Version:    >=1.8
 Build-Type:       Simple
+Extra-Source-Files:
+  Makefile
 
 Source-Repository this
-  Tag:         0.3.2
+  Tag:         0.3.3
   Type:        darcs
-  Location:    http://hub.darcs.net/thielema/non-empty/
+  Location:    https://hub.darcs.net/thielema/non-empty/
 
 Source-Repository head
   Type:        darcs
-  Location:    http://hub.darcs.net/thielema/non-empty/
+  Location:    https://hub.darcs.net/thielema/non-empty/
 
 Library
   Build-Depends:
@@ -82,6 +84,7 @@
     QuickCheck >=2.1 && <3,
     base >=4 && <5
 
+  Default-Language: Haskell98
   GHC-Options:      -Wall
   Hs-Source-Dirs:   src
   Exposed-Modules:
@@ -104,13 +107,16 @@
 Test-Suite non-empty-test
   Type:             exitcode-stdio-1.0
   Main-Is:          Main.hs
+  Default-Language: Haskell98
   GHC-Options:      -Wall
   Hs-source-dirs:   test
   Build-Depends:
     non-empty,
     containers,
-    utility-ht,
+    utility-ht >=0.0.16,
+    doctest-exitcode-stdio >=0.0 && <0.1,
     QuickCheck,
     base
   Other-Modules:
-    Test.Map
+    Test.Data.NonEmpty.Map
+    Test.Data.NonEmptyPrivate
diff --git a/src/Data/NonEmpty.hs b/src/Data/NonEmpty.hs
--- a/src/Data/NonEmpty.hs
+++ b/src/Data/NonEmpty.hs
@@ -23,6 +23,7 @@
    minimum, minimumBy, minimumKey,
    sum,
    product,
+   chop,
    append, appendLeft, appendRight,
    cycle,
    zipWith,
@@ -32,6 +33,8 @@
    scanl, scanr,
    tails, inits, initsRev,
    removeEach,
+   partitionEithersLeft,
+   partitionEithersRight,
    ) where
 
 import Data.NonEmptyPrivate
diff --git a/src/Data/NonEmpty/Class.hs b/src/Data/NonEmpty/Class.hs
--- a/src/Data/NonEmpty/Class.hs
+++ b/src/Data/NonEmpty/Class.hs
@@ -3,6 +3,7 @@
 import qualified Data.Sequence as Seq
 import qualified Data.Map as Map
 import qualified Data.Set as Set
+import qualified Data.List.Key as Key
 import qualified Data.List.HT as ListHT
 import qualified Data.List as List
 import qualified Control.DeepSeq as DeepSeq
@@ -12,6 +13,7 @@
 import Data.Traversable (Traversable, mapAccumL, mapAccumR)
 import Control.Monad (liftM2, )
 import Data.Tuple.HT (swap, )
+import Data.Ord.HT (comparing, )
 
 import qualified Test.QuickCheck as QC
 
@@ -245,6 +247,22 @@
    sortBy = Seq.sortBy
 
 
+class Sort f => SortKey f where
+   sortKey :: (Ord b) => (a -> b) -> f a -> f a
+
+instance SortKey [] where
+   sortKey = Key.sort
+
+instance SortKey Maybe where
+   sortKey _f = id
+
+instance SortKey Seq where
+   sortKey = sortKeyGen
+
+sortKeyGen :: (SortBy f, Functor f, Ord b) => (a -> b) -> f a -> f a
+sortKeyGen f = fmap snd . sortBy (comparing fst) . fmap (\x -> (f x, x))
+
+
 class Reverse f where
    reverse :: f a -> f a
 
@@ -264,6 +282,12 @@
              foldr (.) (showString "[]") $
              map (\x -> P.showsPrec 6 x . showString ":") xs
 
+instance Show Maybe where
+   showsPrec = P.showsPrec
+
+instance Show Seq where
+   showsPrec = P.showsPrec
+
 instance Show Set where
    showsPrec = P.showsPrec
 
@@ -276,21 +300,36 @@
    arbitrary = QC.arbitrary
    shrink = QC.shrink
 
+instance Arbitrary Seq where
+   arbitrary = QC.arbitrary
+   shrink = QC.shrink
+
 instance Arbitrary Maybe where
    arbitrary = QC.arbitrary
    shrink = QC.shrink
 
+instance (QC.Arbitrary k, Ord k) => Arbitrary (Map k) where
+   arbitrary = QC.arbitrary
+   shrink = QC.shrink
 
+
 class (Arbitrary f) => Gen f where
    genOf :: QC.Gen a -> QC.Gen (f a)
 
 instance Gen [] where
    genOf = QC.listOf
 
+instance Gen Seq where
+   genOf = fmap Seq.fromList . QC.listOf
+
 instance Gen Maybe where
    genOf gen = do
       b <- QC.arbitrary
       if b then fmap Just gen else return Nothing
+
+instance (QC.Arbitrary k, Ord k) => Gen (Map k) where
+   genOf gen =
+      fmap Map.fromList $ mapM (\k -> fmap ((,) k) gen) =<< QC.arbitrary
 
 
 class NFData f where
diff --git a/src/Data/NonEmpty/Map.hs b/src/Data/NonEmpty/Map.hs
--- a/src/Data/NonEmpty/Map.hs
+++ b/src/Data/NonEmpty/Map.hs
@@ -36,18 +36,33 @@
 import Data.Map (Map, )
 
 import Control.Monad (mzero, )
-import Control.Applicative (liftA2, )
+import Control.Applicative (liftA2, liftA3)
 import Control.DeepSeq (NFData, rnf, )
 import Data.Traversable (Traversable, traverse, )
 import Data.Foldable (Foldable, foldMap, )
 import Data.Monoid (mappend, )
-import Data.Maybe (fromMaybe, )
+import Data.Maybe (fromMaybe, mapMaybe)
 import Data.Tuple.HT (forcePair, mapSnd, )
 import Data.Ord.HT (comparing, )
 
+import qualified Test.QuickCheck as QC
+
 import Prelude hiding (map, lookup, )
 
 
+{- $setup
+>>> import qualified Data.NonEmpty.Map as NonEmptyMap
+>>> import qualified Data.NonEmpty as NonEmpty
+>>> import qualified Data.Map as Map
+>>> import qualified Test.QuickCheck as QC
+>>>
+>>> forAllMap :: (QC.Testable test) => (Map.Map Int String -> test) -> QC.Property
+>>> forAllMap = QC.forAll (fmap Map.fromList QC.arbitrary)
+>>>
+>>> forAllNonEmptyMap :: (QC.Testable test) => (NonEmptyMap.T Int String -> test) -> QC.Property
+>>> forAllNonEmptyMap = QC.forAll (fmap NonEmptyMap.fromList QC.arbitrary)
+-}
+
 {-
 The first field will always contain the smallest element.
 -}
@@ -76,10 +91,23 @@
 instance (NFData k) => C.NFData (T k) where
    rnf (Cons x xs) = rnf (x, C.rnf xs)
 
+instance (QC.Arbitrary k, Ord k, QC.Arbitrary a) => QC.Arbitrary (T k a) where
+   arbitrary = C.arbitrary
+   shrink = C.shrink
 
+instance (QC.Arbitrary k, Ord k) => C.Arbitrary (T k) where
+   arbitrary = liftA3 insert QC.arbitrary QC.arbitrary QC.arbitrary
+   shrink = mapMaybe fetch . QC.shrink . flatten
+
+instance (QC.Arbitrary k, Ord k) => C.Gen (T k) where
+   genOf gen = liftA3 insert QC.arbitrary gen $ C.genOf gen
+
+
+-- | prop> \k a -> forAllMap $ \m -> Map.insert k a m == NonEmptyMap.flatten (NonEmptyMap.insert k a m)
 insert :: Ord k => k -> a -> Map k a -> T k a
 insert = curry $ insertGen Map.insert fst
 
+-- | prop> \k a -> forAllMap $ \m -> Map.insertWith (++) k a m == NonEmptyMap.flatten (NonEmptyMap.insertWith (++) k a m)
 insertWith :: Ord k => (a -> a -> a) -> k -> a -> Map k a -> T k a
 insertWith f = curry $ insertGen (Map.insertWith f) (applyFst f)
 
@@ -133,6 +161,7 @@
      then Just $ snd x
      else Map.lookup y xs
 
+-- | prop> \k -> forAllNonEmptyMap $ \m -> Map.delete k (NonEmptyMap.flatten m) == NonEmptyMap.delete k m
 delete :: (Ord k) => k -> T k a -> Map k a
 delete y (Cons x xs) =
    if y == fst x then xs else uncurry Map.insert x $ Map.delete y xs
@@ -147,16 +176,20 @@
       Nothing -> (x,xs)
       Just (y,ys) -> (y, uncurry Map.insert x ys)
 
+-- | prop> \xs -> Map.fromList (NonEmpty.flatten xs) == NonEmptyMap.flatten (NonEmptyMap.fromList (xs::NonEmpty.T [] (Int,Char)))
 fromList :: (Ord k) => NonEmpty.T [] (k,a) -> T k a
 fromList (NonEmpty.Cons x xs) = insertRight x $ Map.fromList xs
 
+-- | prop> \xs -> Map.fromListWith (++) (NonEmpty.flatten xs) == NonEmptyMap.flatten (NonEmptyMap.fromListWith (++) (xs::NonEmpty.T [] (Int,String)))
 fromListWith :: (Ord k) => (a -> a -> a) -> NonEmpty.T [] (k,a) -> T k a
 fromListWith f (NonEmpty.Cons x xs) =
    insertRightWith f x $ Map.fromListWith f xs
 
+-- | prop> forAllNonEmptyMap $ \m -> NonEmptyMap.fromAscList (NonEmptyMap.toAscList m) == m
 fromAscList :: (Ord k) => NonEmpty.T [] (k,a) -> T k a
 fromAscList (NonEmpty.Cons x xs) = Cons x $ Map.fromAscList xs
 
+-- | prop> forAllNonEmptyMap $ \m -> NonEmpty.flatten (NonEmptyMap.toAscList m) == Map.toAscList (NonEmptyMap.flatten m)
 toAscList :: T k a -> NonEmpty.T [] (k,a)
 toAscList (Cons x xs) = NonEmpty.cons x $ Map.toAscList xs
 
@@ -171,6 +204,7 @@
 Could be implemented in terms of unionRight
 but that would require inspection of the plain Map using Map.minViewWithKey.
 -}
+-- | prop> forAllNonEmptyMap $ \xs -> forAllNonEmptyMap $ \ys -> Map.union (NonEmptyMap.flatten xs) (NonEmptyMap.flatten ys) == NonEmptyMap.flatten (NonEmptyMap.union xs ys)
 union :: (Ord k) => T k a -> T k a -> T k a
 union (Cons x xs) (Cons y ys) =
    uncurry Cons $
@@ -181,13 +215,16 @@
             GT -> (y, uncurry Map.insert x zs)
             EQ -> (x, zs)
 
+-- | prop> forAllMap $ \xm -> forAllNonEmptyMap $ \ym -> Map.union xm (NonEmptyMap.flatten ym) == NonEmptyMap.flatten (NonEmptyMap.unionLeft xm ym)
 unionLeft :: (Ord k) => Map k a -> T k a -> T k a
 unionLeft xs (Cons y ys) = insertRight y $ Map.union xs ys
 
+-- | prop> forAllNonEmptyMap $ \xm -> forAllMap $ \ym -> Map.union (NonEmptyMap.flatten xm) ym == NonEmptyMap.flatten (NonEmptyMap.unionRight xm ym)
 unionRight :: (Ord k) => T k a -> Map k a -> T k a
 unionRight (Cons x xs) ys = uncurry insert x $ Map.union xs ys
 
 
+-- | prop> forAllNonEmptyMap $ \xs -> forAllNonEmptyMap $ \ys -> Map.unionWith (++) (NonEmptyMap.flatten xs) (NonEmptyMap.flatten ys) == NonEmptyMap.flatten (NonEmptyMap.unionWith (++) xs ys)
 unionWith :: (Ord k) => (a -> a -> a) -> T k a -> T k a -> T k a
 unionWith f (Cons x xs) (Cons y ys) =
    uncurry Cons $
@@ -198,10 +235,12 @@
             GT -> (y, uncurry (Map.insertWith f) x zs)
             EQ -> (applyFst f (x,y), zs)
 
+-- | prop> forAllMap $ \xm -> forAllNonEmptyMap $ \ym -> Map.unionWith (++) xm (NonEmptyMap.flatten ym) == NonEmptyMap.flatten (NonEmptyMap.unionLeftWith (++) xm ym)
 unionLeftWith :: (Ord k) => (a -> a -> a) -> Map k a -> T k a -> T k a
 unionLeftWith f xs (Cons y ys) =
    insertRightWith f y $ Map.unionWith f xs ys
 
+-- | prop> forAllNonEmptyMap $ \xm -> forAllMap $ \ym -> Map.unionWith (++) (NonEmptyMap.flatten xm) ym == NonEmptyMap.flatten (NonEmptyMap.unionRightWith (++) xm ym)
 unionRightWith :: (Ord k) => (a -> a -> a) -> T k a -> Map k a -> T k a
 unionRightWith f (Cons x xs) ys =
    uncurry (insertWith f) x $ Map.unionWith f xs ys
diff --git a/src/Data/NonEmpty/Set.hs b/src/Data/NonEmpty/Set.hs
--- a/src/Data/NonEmpty/Set.hs
+++ b/src/Data/NonEmpty/Set.hs
@@ -31,11 +31,14 @@
 import Data.Set (Set, )
 
 import Control.Monad (mzero, )
+import Control.Applicative (liftA2)
 import Control.DeepSeq (NFData, rnf, )
-import Data.Maybe (fromMaybe, )
+import Data.Maybe (fromMaybe, mapMaybe)
 import Data.Tuple.HT (forcePair, mapSnd, )
 
+import qualified Test.QuickCheck as QC
 
+
 {-
 The first field will always contain the smallest element.
 We do not use the NonEmpty data type here
@@ -57,6 +60,11 @@
 
 instance C.NFData T where
    rnf (Cons x xs) = rnf (x, C.rnf xs)
+
+
+instance (QC.Arbitrary a, Ord a) => QC.Arbitrary (T a) where
+   arbitrary = liftA2 insert QC.arbitrary QC.arbitrary
+   shrink = mapMaybe fetch . QC.shrink . flatten
 
 
 {- |
diff --git a/src/Data/NonEmptyPrivate.hs b/src/Data/NonEmptyPrivate.hs
--- a/src/Data/NonEmptyPrivate.hs
+++ b/src/Data/NonEmptyPrivate.hs
@@ -14,12 +14,14 @@
 import qualified Data.List as List
 import Data.Traversable (Traversable, mapAccumL, mapAccumR)
 import Data.Foldable (Foldable, )
+import Control.Monad.HT (void, )
 import Control.Monad (Monad, return, (=<<), )
 import Control.Applicative (Applicative, liftA2, pure, (<*>), )
 import Control.DeepSeq (NFData, rnf, )
 
 import Data.Functor (Functor, fmap, )
 import Data.Function (flip, const, ($), (.), )
+import Data.Either (Either(Left, Right), )
 import Data.Maybe (Maybe(Just, Nothing), maybe, mapMaybe, )
 import Data.Bool.HT (if', )
 import Data.Bool (Bool(True), (&&), )
@@ -33,6 +35,13 @@
 import qualified Test.QuickCheck as QC
 
 
+{- $setup
+>>> import qualified Data.NonEmpty as NonEmpty
+>>> import qualified Data.Either.HT as EitherHT
+>>> import Data.Tuple.HT (swap)
+>>> import Data.Maybe (mapMaybe)
+-}
+
 {-
 We could also have (:!) as constructor,
 but in order to import it unqualified we have to import 'T' unqualified, too,
@@ -215,6 +224,22 @@
 snoc xs x =
    uncurry Cons $ mapAccumR (flip (,)) x xs
 
+-- name of the class could also be ShiftL
+class Snoc f where snocFast :: f a -> a -> T f a
+instance Snoc [] where snocFast = snocGeneric
+instance Snoc Seq where snocFast = snocGeneric
+instance Snoc Empty.T where snocFast ~Empty.Cons x = Cons x Empty.Cons
+instance Snoc Maybe where
+   snocFast mx y = uncurry Cons $ maybe (y, Nothing) (\x -> (x, Just y)) mx
+
+-- | For 'Seq' faster than 'snoc'.
+snocGeneric :: (C.ViewL f, C.Empty f, C.Snoc f) => f a -> a -> T f a
+snocGeneric xs x =
+   uncurry Cons $
+   case C.viewL xs of
+      Nothing -> (x, C.empty)
+      Just (y,ys) -> (y, C.snoc ys x)
+
 snocAlt :: (C.Cons f, Traversable f) => f a -> a -> f a
 snocAlt xs x = flatten $ snoc xs x
 
@@ -353,6 +378,12 @@
 product = foldl1 (P.*)
 
 
+chop :: (a -> Bool) -> [a] -> T [] [a]
+chop p =
+   uncurry cons .
+   P.foldr (\ x ~(y,ys) -> if p x then ([],y:ys) else ((x:y),ys) ) ([],[])
+
+
 instance (C.Cons f, C.Append f) => C.Append (T f) where
    append xs ys = appendRight xs (flatten ys)
 
@@ -546,8 +577,16 @@
 removeEach :: (Traversable f) => T f a -> T f (a, f a)
 removeEach xs  =  mapWithIndex (\n _ -> removeAt n xs) 0 xs
 
+takeUntil :: (a -> Bool) -> T [] a -> T [] a
+takeUntil p (Cons x xs) =
+   x !: if p x then [] else ListHT.takeUntil p xs
 
+takeUntilAlt :: (a -> Bool) -> T [] a -> T [] a
+takeUntilAlt p xs =
+   zipWith const xs $ Cons () $ void $ List.takeWhile (P.not . p) $ flatten xs
 
+
+
 {-
 It is somehow better than the variant in NonEmpty.Mixed,
 since it can be applied to nested NonEmptys.
@@ -678,3 +717,25 @@
 -}
 mapAdjacent1 :: (Traversable f) => (a -> a -> b -> c) -> a -> f (a,b) -> f c
 mapAdjacent1 f = (snd.) . mapAccumL (\a0 (a1,b) -> (a1, f a0 a1 b))
+
+{- |
+prop> \xs -> mapMaybe EitherHT.maybeLeft (NonEmpty.flatten xs) == either NonEmpty.flatten fst (NonEmpty.partitionEithersLeft (xs::NonEmpty.T[](Either Char Int)))
+prop> \xs -> mapMaybe EitherHT.maybeRight (NonEmpty.flatten xs) == either (const []) (NonEmpty.flatten . snd) (NonEmpty.partitionEithersLeft (xs::NonEmpty.T[](Either Char Int)))
+prop> \xs -> NonEmpty.partitionEithersRight (fmap EitherHT.swap xs) == EitherHT.mapLeft swap (EitherHT.swap (NonEmpty.partitionEithersLeft (xs::NonEmpty.T[](Either Char Int))))
+-}
+partitionEithersLeft :: T [] (Either a b) -> Either (T [] a) ([a], T [] b)
+partitionEithersLeft (Cons x xs) =
+   case (x, ListHT.unzipEithers xs) of
+      (Right r, (ls,rs)) -> Right (ls, Cons r rs)
+      (Left l, (ls,rs)) ->
+         maybe (Left $ Cons l ls) (Right . (,) (l:ls)) $ fetch rs
+
+{- |
+prop> \xs -> NonEmpty.partitionEithersLeft (fmap EitherHT.swap xs) == EitherHT.mapRight swap (EitherHT.swap (NonEmpty.partitionEithersRight (xs::NonEmpty.T[](Either Char Int))))
+-}
+partitionEithersRight :: T [] (Either a b) -> Either (T [] a, [b]) (T [] b)
+partitionEithersRight (Cons x xs) =
+   case (x, ListHT.unzipEithers xs) of
+      (Left l, (ls,rs)) -> Left (Cons l ls, rs)
+      (Right r, (ls,rs)) ->
+         maybe (Right $ Cons r rs) (Left . flip (,) (r:rs)) $ fetch ls
diff --git a/test/Main.hs b/test/Main.hs
--- a/test/Main.hs
+++ b/test/Main.hs
@@ -1,18 +1,12 @@
+-- Do not edit! Automatically created with doctest-extract.
 module Main where
 
-import qualified Test.Map as Map
-
-import qualified Test.QuickCheck as QC
-
-import Data.Tuple.HT (mapFst)
-
+import qualified Test.Data.NonEmptyPrivate
+import qualified Test.Data.NonEmpty.Map
 
-prefix :: String -> [(String, test)] -> [(String, test)]
-prefix msg = map (mapFst (\str -> msg ++ "." ++ str))
+import qualified Test.DocTest.Driver as DocTest
 
 main :: IO ()
-main =
-   mapM_ (\(msg,prop) -> putStr (msg++": ") >> QC.quickCheck prop) $
-   concat $
-      prefix "Map" Map.tests :
-      []
+main = DocTest.run $ do
+    Test.Data.NonEmptyPrivate.test
+    Test.Data.NonEmpty.Map.test
diff --git a/test/Test/Data/NonEmpty/Map.hs b/test/Test/Data/NonEmpty/Map.hs
new file mode 100644
--- /dev/null
+++ b/test/Test/Data/NonEmpty/Map.hs
@@ -0,0 +1,86 @@
+-- Do not edit! Automatically created with doctest-extract from src/Data/NonEmpty/Map.hs
+{-# LINE 53 "src/Data/NonEmpty/Map.hs" #-}
+
+module Test.Data.NonEmpty.Map where
+
+import qualified Test.DocTest.Driver as DocTest
+
+{-# LINE 54 "src/Data/NonEmpty/Map.hs" #-}
+import     qualified Data.NonEmpty.Map as NonEmptyMap
+import     qualified Data.NonEmpty as NonEmpty
+import     qualified Data.Map as Map
+import     qualified Test.QuickCheck as QC
+
+forAllMap     :: (QC.Testable test) => (Map.Map Int String -> test) -> QC.Property
+forAllMap     = QC.forAll (fmap Map.fromList QC.arbitrary)
+
+forAllNonEmptyMap     :: (QC.Testable test) => (NonEmptyMap.T Int String -> test) -> QC.Property
+forAllNonEmptyMap     = QC.forAll (fmap NonEmptyMap.fromList QC.arbitrary)
+
+test :: DocTest.T ()
+test = do
+ DocTest.printPrefix "Data.NonEmpty.Map:106: "
+{-# LINE 106 "src/Data/NonEmpty/Map.hs" #-}
+ DocTest.property
+{-# LINE 106 "src/Data/NonEmpty/Map.hs" #-}
+          (\k a -> forAllMap $ \m -> Map.insert k a m == NonEmptyMap.flatten (NonEmptyMap.insert k a m))
+ DocTest.printPrefix "Data.NonEmpty.Map:110: "
+{-# LINE 110 "src/Data/NonEmpty/Map.hs" #-}
+ DocTest.property
+{-# LINE 110 "src/Data/NonEmpty/Map.hs" #-}
+          (\k a -> forAllMap $ \m -> Map.insertWith (++) k a m == NonEmptyMap.flatten (NonEmptyMap.insertWith (++) k a m))
+ DocTest.printPrefix "Data.NonEmpty.Map:164: "
+{-# LINE 164 "src/Data/NonEmpty/Map.hs" #-}
+ DocTest.property
+{-# LINE 164 "src/Data/NonEmpty/Map.hs" #-}
+          (\k -> forAllNonEmptyMap $ \m -> Map.delete k (NonEmptyMap.flatten m) == NonEmptyMap.delete k m)
+ DocTest.printPrefix "Data.NonEmpty.Map:179: "
+{-# LINE 179 "src/Data/NonEmpty/Map.hs" #-}
+ DocTest.property
+{-# LINE 179 "src/Data/NonEmpty/Map.hs" #-}
+          (\xs -> Map.fromList (NonEmpty.flatten xs) == NonEmptyMap.flatten (NonEmptyMap.fromList (xs::NonEmpty.T [] (Int,Char))))
+ DocTest.printPrefix "Data.NonEmpty.Map:183: "
+{-# LINE 183 "src/Data/NonEmpty/Map.hs" #-}
+ DocTest.property
+{-# LINE 183 "src/Data/NonEmpty/Map.hs" #-}
+          (\xs -> Map.fromListWith (++) (NonEmpty.flatten xs) == NonEmptyMap.flatten (NonEmptyMap.fromListWith (++) (xs::NonEmpty.T [] (Int,String))))
+ DocTest.printPrefix "Data.NonEmpty.Map:188: "
+{-# LINE 188 "src/Data/NonEmpty/Map.hs" #-}
+ DocTest.property
+{-# LINE 188 "src/Data/NonEmpty/Map.hs" #-}
+          (forAllNonEmptyMap $ \m -> NonEmptyMap.fromAscList (NonEmptyMap.toAscList m) == m)
+ DocTest.printPrefix "Data.NonEmpty.Map:192: "
+{-# LINE 192 "src/Data/NonEmpty/Map.hs" #-}
+ DocTest.property
+{-# LINE 192 "src/Data/NonEmpty/Map.hs" #-}
+          (forAllNonEmptyMap $ \m -> NonEmpty.flatten (NonEmptyMap.toAscList m) == Map.toAscList (NonEmptyMap.flatten m))
+ DocTest.printPrefix "Data.NonEmpty.Map:207: "
+{-# LINE 207 "src/Data/NonEmpty/Map.hs" #-}
+ DocTest.property
+{-# LINE 207 "src/Data/NonEmpty/Map.hs" #-}
+          (forAllNonEmptyMap $ \xs -> forAllNonEmptyMap $ \ys -> Map.union (NonEmptyMap.flatten xs) (NonEmptyMap.flatten ys) == NonEmptyMap.flatten (NonEmptyMap.union xs ys))
+ DocTest.printPrefix "Data.NonEmpty.Map:218: "
+{-# LINE 218 "src/Data/NonEmpty/Map.hs" #-}
+ DocTest.property
+{-# LINE 218 "src/Data/NonEmpty/Map.hs" #-}
+          (forAllMap $ \xm -> forAllNonEmptyMap $ \ym -> Map.union xm (NonEmptyMap.flatten ym) == NonEmptyMap.flatten (NonEmptyMap.unionLeft xm ym))
+ DocTest.printPrefix "Data.NonEmpty.Map:222: "
+{-# LINE 222 "src/Data/NonEmpty/Map.hs" #-}
+ DocTest.property
+{-# LINE 222 "src/Data/NonEmpty/Map.hs" #-}
+          (forAllNonEmptyMap $ \xm -> forAllMap $ \ym -> Map.union (NonEmptyMap.flatten xm) ym == NonEmptyMap.flatten (NonEmptyMap.unionRight xm ym))
+ DocTest.printPrefix "Data.NonEmpty.Map:227: "
+{-# LINE 227 "src/Data/NonEmpty/Map.hs" #-}
+ DocTest.property
+{-# LINE 227 "src/Data/NonEmpty/Map.hs" #-}
+          (forAllNonEmptyMap $ \xs -> forAllNonEmptyMap $ \ys -> Map.unionWith (++) (NonEmptyMap.flatten xs) (NonEmptyMap.flatten ys) == NonEmptyMap.flatten (NonEmptyMap.unionWith (++) xs ys))
+ DocTest.printPrefix "Data.NonEmpty.Map:238: "
+{-# LINE 238 "src/Data/NonEmpty/Map.hs" #-}
+ DocTest.property
+{-# LINE 238 "src/Data/NonEmpty/Map.hs" #-}
+          (forAllMap $ \xm -> forAllNonEmptyMap $ \ym -> Map.unionWith (++) xm (NonEmptyMap.flatten ym) == NonEmptyMap.flatten (NonEmptyMap.unionLeftWith (++) xm ym))
+ DocTest.printPrefix "Data.NonEmpty.Map:243: "
+{-# LINE 243 "src/Data/NonEmpty/Map.hs" #-}
+ DocTest.property
+{-# LINE 243 "src/Data/NonEmpty/Map.hs" #-}
+          (forAllNonEmptyMap $ \xm -> forAllMap $ \ym -> Map.unionWith (++) (NonEmptyMap.flatten xm) ym == NonEmptyMap.flatten (NonEmptyMap.unionRightWith (++) xm ym))
diff --git a/test/Test/Data/NonEmptyPrivate.hs b/test/Test/Data/NonEmptyPrivate.hs
new file mode 100644
--- /dev/null
+++ b/test/Test/Data/NonEmptyPrivate.hs
@@ -0,0 +1,35 @@
+-- Do not edit! Automatically created with doctest-extract from src/Data/NonEmptyPrivate.hs
+{-# LINE 38 "src/Data/NonEmptyPrivate.hs" #-}
+
+module Test.Data.NonEmptyPrivate where
+
+import qualified Test.DocTest.Driver as DocTest
+
+{-# LINE 39 "src/Data/NonEmptyPrivate.hs" #-}
+import     qualified Data.NonEmpty as NonEmpty
+import     qualified Data.Either.HT as EitherHT
+import     Data.Tuple.HT (swap)
+import     Data.Maybe (mapMaybe)
+
+test :: DocTest.T ()
+test = do
+ DocTest.printPrefix "Data.NonEmptyPrivate:722: "
+{-# LINE 722 "src/Data/NonEmptyPrivate.hs" #-}
+ DocTest.property
+{-# LINE 722 "src/Data/NonEmptyPrivate.hs" #-}
+     (\xs -> mapMaybe EitherHT.maybeLeft (NonEmpty.flatten xs) == either NonEmpty.flatten fst (NonEmpty.partitionEithersLeft (xs::NonEmpty.T[](Either Char Int))))
+ DocTest.printPrefix "Data.NonEmptyPrivate:723: "
+{-# LINE 723 "src/Data/NonEmptyPrivate.hs" #-}
+ DocTest.property
+{-# LINE 723 "src/Data/NonEmptyPrivate.hs" #-}
+     (\xs -> mapMaybe EitherHT.maybeRight (NonEmpty.flatten xs) == either (const []) (NonEmpty.flatten . snd) (NonEmpty.partitionEithersLeft (xs::NonEmpty.T[](Either Char Int))))
+ DocTest.printPrefix "Data.NonEmptyPrivate:724: "
+{-# LINE 724 "src/Data/NonEmptyPrivate.hs" #-}
+ DocTest.property
+{-# LINE 724 "src/Data/NonEmptyPrivate.hs" #-}
+     (\xs -> NonEmpty.partitionEithersRight (fmap EitherHT.swap xs) == EitherHT.mapLeft swap (EitherHT.swap (NonEmpty.partitionEithersLeft (xs::NonEmpty.T[](Either Char Int)))))
+ DocTest.printPrefix "Data.NonEmptyPrivate:734: "
+{-# LINE 734 "src/Data/NonEmptyPrivate.hs" #-}
+ DocTest.property
+{-# LINE 734 "src/Data/NonEmptyPrivate.hs" #-}
+     (\xs -> NonEmpty.partitionEithersLeft (fmap EitherHT.swap xs) == EitherHT.mapRight swap (EitherHT.swap (NonEmpty.partitionEithersRight (xs::NonEmpty.T[](Either Char Int)))))
diff --git a/test/Test/Map.hs b/test/Test/Map.hs
deleted file mode 100644
--- a/test/Test/Map.hs
+++ /dev/null
@@ -1,125 +0,0 @@
-module Test.Map where
-
-import qualified Data.NonEmpty.Map as NonEmptyMap
-import qualified Data.NonEmpty as NonEmpty
-import qualified Data.Map as Map
-
-import qualified Test.QuickCheck as QC
-
-
-insert :: (Int,Char) -> [(Int,Char)] -> Bool
-insert (k,a) xs =
-   let m = Map.fromList xs
-   in Map.insert k a m
-      ==
-      NonEmptyMap.flatten (NonEmptyMap.insert k a m)
-
-insertWith :: (Int,String) -> [(Int,String)] -> Bool
-insertWith (k,a) xs =
-   let m = Map.fromList xs
-   in Map.insertWith (++) k a m
-      ==
-      NonEmptyMap.flatten (NonEmptyMap.insertWith (++) k a m)
-
-delete :: Int -> NonEmpty.T [] (Int,Char) -> Bool
-delete k xs =
-   let m = NonEmptyMap.fromList xs
-   in Map.delete k (NonEmptyMap.flatten m)
-      ==
-      NonEmptyMap.delete k m
-
-
-fromList :: NonEmpty.T [] (Int,Char) -> Bool
-fromList xs =
-   Map.fromList (NonEmpty.flatten xs)
-   ==
-   NonEmptyMap.flatten (NonEmptyMap.fromList xs)
-
-fromListWith :: NonEmpty.T [] (Int,String) -> Bool
-fromListWith xs =
-   Map.fromListWith (++) (NonEmpty.flatten xs)
-   ==
-   NonEmptyMap.flatten (NonEmptyMap.fromListWith (++) xs)
-
-fromAscList :: NonEmpty.T [] (Int,Char) -> Bool
-fromAscList xs =
-   let m = NonEmptyMap.fromList xs
-   in NonEmptyMap.fromAscList (NonEmptyMap.toAscList m) == m
-
-toAscList :: NonEmpty.T [] (Int,Char) -> Bool
-toAscList xs =
-   let m = NonEmptyMap.fromList xs
-   in NonEmpty.flatten (NonEmptyMap.toAscList m)
-      ==
-      Map.toAscList (NonEmptyMap.flatten m)
-
-
-union :: NonEmpty.T [] (Int,Char) -> NonEmpty.T [] (Int,Char) -> Bool
-union xs ys =
-   Map.union
-      (Map.fromList (NonEmpty.flatten xs))
-      (Map.fromList (NonEmpty.flatten ys))
-   ==
-   NonEmptyMap.flatten
-      (NonEmptyMap.union
-         (NonEmptyMap.fromList xs)
-         (NonEmptyMap.fromList ys))
-
-unionWith :: NonEmpty.T [] (Int,String) -> NonEmpty.T [] (Int,String) -> Bool
-unionWith xs ys =
-   Map.unionWith (++)
-      (Map.fromList (NonEmpty.flatten xs))
-      (Map.fromList (NonEmpty.flatten ys))
-   ==
-   NonEmptyMap.flatten
-      (NonEmptyMap.unionWith (++)
-         (NonEmptyMap.fromList xs)
-         (NonEmptyMap.fromList ys))
-
-unionLeft :: [] (Int,Char) -> NonEmpty.T [] (Int,Char) -> Bool
-unionLeft xs ys =
-   let xm = Map.fromList xs
-   in Map.union xm (Map.fromList (NonEmpty.flatten ys))
-      ==
-      NonEmptyMap.flatten (NonEmptyMap.unionLeft xm (NonEmptyMap.fromList ys))
-
-unionLeftWith :: [] (Int,String) -> NonEmpty.T [] (Int,String) -> Bool
-unionLeftWith xs ys =
-   let xm = Map.fromList xs
-   in Map.unionWith (++) xm (Map.fromList (NonEmpty.flatten ys))
-      ==
-      NonEmptyMap.flatten
-         (NonEmptyMap.unionLeftWith (++) xm (NonEmptyMap.fromList ys))
-
-unionRight :: NonEmpty.T [] (Int,Char) -> [] (Int,Char) -> Bool
-unionRight xs ys =
-   let ym = Map.fromList ys
-   in Map.union (Map.fromList (NonEmpty.flatten xs)) ym
-      ==
-      NonEmptyMap.flatten (NonEmptyMap.unionRight (NonEmptyMap.fromList xs) ym)
-
-unionRightWith :: NonEmpty.T [] (Int,String) -> [] (Int,String) -> Bool
-unionRightWith xs ys =
-   let ym = Map.fromList ys
-   in Map.unionWith (++) (Map.fromList (NonEmpty.flatten xs)) ym
-      ==
-      NonEmptyMap.flatten
-         (NonEmptyMap.unionRightWith (++) (NonEmptyMap.fromList xs) ym)
-
-
-tests :: [(String, QC.Property)]
-tests =
-   ("insert", QC.property insert) :
-   ("insertWith", QC.property insertWith) :
-   ("delete", QC.property delete) :
-   ("fromList", QC.property fromList) :
-   ("fromListWith", QC.property fromListWith) :
-   ("fromAscList", QC.property fromAscList) :
-   ("toAscList", QC.property toAscList) :
-   ("union", QC.property union) :
-   ("unionWith", QC.property unionWith) :
-   ("unionLeft", QC.property unionLeft) :
-   ("unionLeftWith", QC.property unionLeftWith) :
-   ("unionRight", QC.property unionRight) :
-   ("unionRightWith", QC.property unionRightWith) :
-   []