diff --git a/Makefile b/Makefile
--- a/Makefile
+++ b/Makefile
@@ -5,4 +5,4 @@
 	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
+	doctest-extract-0.1 -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,6 +1,6 @@
 Cabal-Version:    2.2
 Name:             non-empty
-Version:          0.3.3
+Version:          0.3.4
 License:          BSD-3-Clause
 License-File:     LICENSE
 Author:           Henning Thielemann <haskell@henning-thielemann.de>
@@ -68,7 +68,7 @@
   Makefile
 
 Source-Repository this
-  Tag:         0.3.3
+  Tag:         0.3.4
   Type:        darcs
   Location:    https://hub.darcs.net/thielema/non-empty/
 
@@ -79,7 +79,7 @@
 Library
   Build-Depends:
     containers >=0.4 && <0.7,
-    deepseq >=1.3 && <1.5,
+    deepseq >=1.3 && <1.6,
     utility-ht >=0.0.8 && <0.1,
     QuickCheck >=2.1 && <3,
     base >=4 && <5
@@ -88,6 +88,7 @@
   GHC-Options:      -Wall
   Hs-Source-Dirs:   src
   Exposed-Modules:
+    Data.FixedLengthList
     Data.NonEmpty
     Data.NonEmpty.Class
     Data.NonEmpty.Mixed
diff --git a/src/Data/Empty.hs b/src/Data/Empty.hs
--- a/src/Data/Empty.hs
+++ b/src/Data/Empty.hs
@@ -4,6 +4,7 @@
 
 import qualified Data.Traversable as Trav
 import qualified Data.Foldable as Fold
+import qualified Data.Ix as Ix
 import Control.Applicative (pure, )
 import Control.DeepSeq (NFData, rnf, )
 
@@ -80,3 +81,20 @@
 
 instance NFData (T a) where
    rnf Cons = ()
+
+
+instance C.Ix T where
+   range (Cons, Cons) = [Cons]
+   index (Cons, Cons) Cons = 0
+   inRange (Cons, Cons) Cons = True
+   rangeSize (Cons, Cons) = 1
+
+instance (Ix.Ix i) => Ix.Ix (T i) where
+   range = C.range
+   index = C.index
+   inRange = C.inRange
+   rangeSize = C.rangeSize
+
+
+switch :: b -> T a -> b
+switch b Cons = b
diff --git a/src/Data/FixedLengthList.hs b/src/Data/FixedLengthList.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/FixedLengthList.hs
@@ -0,0 +1,128 @@
+{- |
+Word with fixed length lists constructed from 'NonEmpty' and 'Empty' types.
+-}
+module Data.FixedLengthList where
+
+import qualified Data.NonEmptyPrivate as NonEmpty
+import qualified Data.Empty as Empty
+import Data.NonEmptyPrivate (uncurrier, currier)
+
+
+
+type T0 = Empty.T
+type T1 = NonEmpty.T T0
+type T2 = NonEmpty.T T1
+type T3 = NonEmpty.T T2
+type T4 = NonEmpty.T T3
+type T5 = NonEmpty.T T4
+type T6 = NonEmpty.T T5
+type T7 = NonEmpty.T T6
+type T8 = NonEmpty.T T7
+type T9 = NonEmpty.T T8
+
+type Func0 a b = b
+type Func1 a b = a -> Func0 a b
+type Func2 a b = a -> Func1 a b
+type Func3 a b = a -> Func2 a b
+type Func4 a b = a -> Func3 a b
+type Func5 a b = a -> Func4 a b
+type Func6 a b = a -> Func5 a b
+type Func7 a b = a -> Func6 a b
+type Func8 a b = a -> Func7 a b
+type Func9 a b = a -> Func8 a b
+
+
+
+uncurry0 :: Func0 a b -> T0 a -> b
+uncurry0 = Empty.switch
+
+uncurry1 :: Func1 a b -> T1 a -> b
+uncurry1 = uncurrier uncurry0
+
+uncurry2 :: Func2 a b -> T2 a -> b
+uncurry2 = uncurrier uncurry1
+
+uncurry3 :: Func3 a b -> T3 a -> b
+uncurry3 = uncurrier uncurry2
+
+uncurry4 :: Func4 a b -> T4 a -> b
+uncurry4 = uncurrier uncurry3
+
+uncurry5 :: Func5 a b -> T5 a -> b
+uncurry5 = uncurrier uncurry4
+
+uncurry6 :: Func6 a b -> T6 a -> b
+uncurry6 = uncurrier uncurry5
+
+uncurry7 :: Func7 a b -> T7 a -> b
+uncurry7 = uncurrier uncurry6
+
+uncurry8 :: Func8 a b -> T8 a -> b
+uncurry8 = uncurrier uncurry7
+
+uncurry9 :: Func9 a b -> T9 a -> b
+uncurry9 = uncurrier uncurry8
+
+
+
+curry0 :: (T0 a -> b) -> Func0 a b
+curry0 f = f Empty.Cons
+
+curry1 :: (T1 a -> b) -> Func1 a b
+curry1 = currier curry0
+
+curry2 :: (T2 a -> b) -> Func2 a b
+curry2 = currier curry1
+
+curry3 :: (T3 a -> b) -> Func3 a b
+curry3 = currier curry2
+
+curry4 :: (T4 a -> b) -> Func4 a b
+curry4 = currier curry3
+
+curry5 :: (T5 a -> b) -> Func5 a b
+curry5 = currier curry4
+
+curry6 :: (T6 a -> b) -> Func6 a b
+curry6 = currier curry5
+
+curry7 :: (T7 a -> b) -> Func7 a b
+curry7 = currier curry6
+
+curry8 :: (T8 a -> b) -> Func8 a b
+curry8 = currier curry7
+
+curry9 :: (T9 a -> b) -> Func9 a b
+curry9 = currier curry8
+
+
+
+consAll0 :: Func0 a (T0 a)
+consAll0 = curry0 id
+
+consAll1 :: Func1 a (T1 a)
+consAll1 = curry1 id
+
+consAll2 :: Func2 a (T2 a)
+consAll2 = curry2 id
+
+consAll3 :: Func3 a (T3 a)
+consAll3 = curry3 id
+
+consAll4 :: Func4 a (T4 a)
+consAll4 = curry4 id
+
+consAll5 :: Func5 a (T5 a)
+consAll5 = curry5 id
+
+consAll6 :: Func6 a (T6 a)
+consAll6 = curry6 id
+
+consAll7 :: Func7 a (T7 a)
+consAll7 = curry7 id
+
+consAll8 :: Func8 a (T8 a)
+consAll8 = curry8 id
+
+consAll9 :: Func9 a (T9 a)
+consAll9 = curry9 id
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.Ix as Ix
 import qualified Data.List.Key as Key
 import qualified Data.List.HT as ListHT
 import qualified Data.List as List
@@ -346,3 +347,32 @@
 
 instance (DeepSeq.NFData k) => NFData (Map k) where
    rnf = DeepSeq.rnf
+
+
+class Ix f where
+   {-# MINIMAL range, (index | indexHorner), inRange #-}
+   range :: (Ix.Ix i) => (f i, f i) -> [f i]
+   index :: (Ix.Ix i) => (f i, f i) -> f i -> Int
+   index =
+      if True
+         then flip indexHorner 0
+         else snd . rangeSizeIndex
+   inRange :: (Ix.Ix i) => (f i, f i) -> f i -> Bool
+   rangeSize :: (Ix.Ix i) => (f i, f i) -> Int
+   rangeSize b@(_l,h) = if inRange b h then index b h + 1 else 0
+   {- |
+   The default implementation causes quadratic runtime
+   on nested index tuple types.
+   This affects the 'index' function, too.
+   -}
+   rangeSizeIndex :: (Ix.Ix i) => (f i, f i) -> (Int, f i -> Int)
+   rangeSizeIndex b = (rangeSize b, index b)
+   {- |
+   A custom implementation of this function
+   allows for an even more efficient implementation
+   of 'index' on nested NonEmpty constructors.
+   -}
+   indexHorner :: (Ix.Ix i) => (f i, f i) -> Int -> f i -> Int
+   indexHorner b =
+      let size = rangeSize b
+      in \offset i -> offset * size + index b i
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
@@ -176,6 +176,7 @@
       Nothing -> (x,xs)
       Just (y,ys) -> (y, uncurry Map.insert x ys)
 
+{-# WARNING fromList "Dangerous because it silently drops colliding key/value pairs. Better use fromListWith." #-}
 -- | 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
@@ -200,6 +201,7 @@
 flatten (Cons x xs) = uncurry Map.insert x xs
 
 
+{-# WARNING union "Dangerous because it silently drops colliding key/value pairs. Better use unionWith." #-}
 {-
 Could be implemented in terms of unionRight
 but that would require inspection of the plain Map using Map.minViewWithKey.
@@ -215,10 +217,12 @@
             GT -> (y, uncurry Map.insert x zs)
             EQ -> (x, zs)
 
+{-# WARNING unionLeft "Dangerous because it silently drops colliding key/value pairs. Better use unionLeftWith." #-}
 -- | 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
 
+{-# WARNING unionRight "Dangerous because it silently drops colliding key/value pairs. Better use unionRightWith." #-}
 -- | 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
diff --git a/src/Data/NonEmptyPrivate.hs b/src/Data/NonEmptyPrivate.hs
--- a/src/Data/NonEmptyPrivate.hs
+++ b/src/Data/NonEmptyPrivate.hs
@@ -12,6 +12,7 @@
 import qualified Data.List.Match as Match
 import qualified Data.List.HT as ListHT
 import qualified Data.List as List
+import qualified Data.Ix as Ix
 import Data.Traversable (Traversable, mapAccumL, mapAccumR)
 import Data.Foldable (Foldable, )
 import Control.Monad.HT (void, )
@@ -30,16 +31,26 @@
 import Data.Tuple.HT (mapFst, mapSnd, swap, )
 import Data.Tuple (fst, snd, )
 import qualified Prelude as P
-import Prelude (Eq, Show, Num, Int, uncurry, ($!), )
+import Prelude (Eq, Show, Num, Int, uncurry, ($!), (*), (+), )
 
 import qualified Test.QuickCheck as QC
 
 
 {- $setup
 >>> import qualified Data.NonEmpty as NonEmpty
+>>> import qualified Data.Empty as Empty
 >>> import qualified Data.Either.HT as EitherHT
+>>> import qualified Control.Functor.HT as FuncHT
+>>> import qualified Data.Ix as Ix
+>>> import Data.NonEmpty ((!:))
 >>> import Data.Tuple.HT (swap)
 >>> import Data.Maybe (mapMaybe)
+>>> import Control.Applicative (liftA2)
+>>> import qualified Test.QuickCheck as QC
+>>>
+>>> forRange :: (QC.Testable test) => ((Char,Char) -> test) -> QC.Property
+>>> forRange =
+>>>    QC.forAll (liftA2 (,) (QC.choose ('a','h')) (QC.choose ('a','h')))
 -}
 
 {-
@@ -258,6 +269,16 @@
 viewR (Cons x xs) = swap $ mapAccumL (flip (,)) x xs
 
 
+switchL :: (a -> f a -> b) -> T f a -> b
+switchL f (Cons x xs) = f x xs
+
+uncurrier :: (b -> f a -> c) -> (a -> b) -> T f a -> c
+uncurrier g = switchL . (g .)
+
+currier :: ((f a -> b) -> c) -> (T f a -> b) -> a -> c
+currier g f x = g $ \xs -> f $ x !: xs
+
+
 mapHead :: (a -> a) -> T f a -> T f a
 mapHead f (Cons x xs) = f x !: xs
 
@@ -739,3 +760,30 @@
       (Left l, (ls,rs)) -> Left (Cons l ls, rs)
       (Right r, (ls,rs)) ->
          maybe (Right $ Cons r rs) (Left . flip (,) (r:rs)) $ fetch ls
+
+
+{- |
+prop> forRange $ \b0 -> forRange $ \b1 -> forRange $ \b2 -> let b = FuncHT.unzip $ b0!:b1!:b2!:Empty.Cons in map (Ix.index b) (Ix.range b) == take (Ix.rangeSize b) [0..]
+-}
+instance C.Ix f => C.Ix (T f) where
+   range (Cons l ls, Cons u us) =
+      liftA2 Cons (Ix.range (l,u)) (C.range (ls,us))
+   inRange (Cons l ls, Cons u us) (Cons i is) =
+      Ix.inRange (l,u) i && C.inRange (ls,us) is
+   rangeSize (Cons l ls, Cons u us) =
+      Ix.rangeSize (l,u) * C.rangeSize (ls,us)
+   rangeSizeIndex (Cons l ls, Cons u us) =
+      let size = Ix.rangeSize (l,u)
+          (subSize, subIndex) = C.rangeSizeIndex (ls,us)
+      in (size*subSize,
+            \(Cons i is) -> Ix.index (l,u) i * subSize + subIndex is)
+   indexHorner (Cons l ls, Cons u us) =
+      let size = Ix.rangeSize (l,u)
+      in \superOffset (Cons i is) ->
+            C.indexHorner (ls,us) (superOffset*size + Ix.index (l,u) i) is
+
+instance (C.Ix f, Ix.Ix i, Ord (f i)) => Ix.Ix (T f i) where
+   range = C.range
+   index = C.index
+   inRange = C.inRange
+   rangeSize = C.rangeSize
diff --git a/test/Test/Data/NonEmpty/Map.hs b/test/Test/Data/NonEmpty/Map.hs
--- a/test/Test/Data/NonEmpty/Map.hs
+++ b/test/Test/Data/NonEmpty/Map.hs
@@ -34,53 +34,53 @@
  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.printPrefix "Data.NonEmpty.Map:180: "
+{-# LINE 180 "src/Data/NonEmpty/Map.hs" #-}
  DocTest.property
-{-# LINE 179 "src/Data/NonEmpty/Map.hs" #-}
+{-# LINE 180 "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.printPrefix "Data.NonEmpty.Map:184: "
+{-# LINE 184 "src/Data/NonEmpty/Map.hs" #-}
  DocTest.property
-{-# LINE 183 "src/Data/NonEmpty/Map.hs" #-}
+{-# LINE 184 "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.printPrefix "Data.NonEmpty.Map:189: "
+{-# LINE 189 "src/Data/NonEmpty/Map.hs" #-}
  DocTest.property
-{-# LINE 188 "src/Data/NonEmpty/Map.hs" #-}
+{-# LINE 189 "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.printPrefix "Data.NonEmpty.Map:193: "
+{-# LINE 193 "src/Data/NonEmpty/Map.hs" #-}
  DocTest.property
-{-# LINE 192 "src/Data/NonEmpty/Map.hs" #-}
+{-# LINE 193 "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.printPrefix "Data.NonEmpty.Map:209: "
+{-# LINE 209 "src/Data/NonEmpty/Map.hs" #-}
  DocTest.property
-{-# LINE 207 "src/Data/NonEmpty/Map.hs" #-}
+{-# LINE 209 "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.printPrefix "Data.NonEmpty.Map:221: "
+{-# LINE 221 "src/Data/NonEmpty/Map.hs" #-}
  DocTest.property
-{-# LINE 218 "src/Data/NonEmpty/Map.hs" #-}
+{-# LINE 221 "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.printPrefix "Data.NonEmpty.Map:226: "
+{-# LINE 226 "src/Data/NonEmpty/Map.hs" #-}
  DocTest.property
-{-# LINE 222 "src/Data/NonEmpty/Map.hs" #-}
+{-# LINE 226 "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.printPrefix "Data.NonEmpty.Map:231: "
+{-# LINE 231 "src/Data/NonEmpty/Map.hs" #-}
  DocTest.property
-{-# LINE 227 "src/Data/NonEmpty/Map.hs" #-}
+{-# LINE 231 "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.printPrefix "Data.NonEmpty.Map:242: "
+{-# LINE 242 "src/Data/NonEmpty/Map.hs" #-}
  DocTest.property
-{-# LINE 238 "src/Data/NonEmpty/Map.hs" #-}
+{-# LINE 242 "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.printPrefix "Data.NonEmpty.Map:247: "
+{-# LINE 247 "src/Data/NonEmpty/Map.hs" #-}
  DocTest.property
-{-# LINE 243 "src/Data/NonEmpty/Map.hs" #-}
+{-# LINE 247 "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
--- a/test/Test/Data/NonEmptyPrivate.hs
+++ b/test/Test/Data/NonEmptyPrivate.hs
@@ -1,35 +1,50 @@
 -- Do not edit! Automatically created with doctest-extract from src/Data/NonEmptyPrivate.hs
-{-# LINE 38 "src/Data/NonEmptyPrivate.hs" #-}
+{-# LINE 39 "src/Data/NonEmptyPrivate.hs" #-}
 
 module Test.Data.NonEmptyPrivate where
 
 import qualified Test.DocTest.Driver as DocTest
 
-{-# LINE 39 "src/Data/NonEmptyPrivate.hs" #-}
+{-# LINE 40 "src/Data/NonEmptyPrivate.hs" #-}
 import     qualified Data.NonEmpty as NonEmpty
+import     qualified Data.Empty as Empty
 import     qualified Data.Either.HT as EitherHT
+import     qualified Control.Functor.HT as FuncHT
+import     qualified Data.Ix as Ix
+import     Data.NonEmpty ((!:))
 import     Data.Tuple.HT (swap)
 import     Data.Maybe (mapMaybe)
+import     Control.Applicative (liftA2)
+import     qualified Test.QuickCheck as QC
 
+forRange     :: (QC.Testable test) => ((Char,Char) -> test) -> QC.Property
+forRange     =
+       QC.forAll (liftA2 (,) (QC.choose ('a','h')) (QC.choose ('a','h')))
+
 test :: DocTest.T ()
 test = do
- DocTest.printPrefix "Data.NonEmptyPrivate:722: "
-{-# LINE 722 "src/Data/NonEmptyPrivate.hs" #-}
+ DocTest.printPrefix "Data.NonEmptyPrivate:743: "
+{-# LINE 743 "src/Data/NonEmptyPrivate.hs" #-}
  DocTest.property
-{-# LINE 722 "src/Data/NonEmptyPrivate.hs" #-}
+{-# LINE 743 "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.printPrefix "Data.NonEmptyPrivate:744: "
+{-# LINE 744 "src/Data/NonEmptyPrivate.hs" #-}
  DocTest.property
-{-# LINE 723 "src/Data/NonEmptyPrivate.hs" #-}
+{-# LINE 744 "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.printPrefix "Data.NonEmptyPrivate:745: "
+{-# LINE 745 "src/Data/NonEmptyPrivate.hs" #-}
  DocTest.property
-{-# LINE 724 "src/Data/NonEmptyPrivate.hs" #-}
+{-# LINE 745 "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.printPrefix "Data.NonEmptyPrivate:755: "
+{-# LINE 755 "src/Data/NonEmptyPrivate.hs" #-}
  DocTest.property
-{-# LINE 734 "src/Data/NonEmptyPrivate.hs" #-}
+{-# LINE 755 "src/Data/NonEmptyPrivate.hs" #-}
      (\xs -> NonEmpty.partitionEithersLeft (fmap EitherHT.swap xs) == EitherHT.mapRight swap (EitherHT.swap (NonEmpty.partitionEithersRight (xs::NonEmpty.T[](Either Char Int)))))
+ DocTest.printPrefix "Data.NonEmptyPrivate:766: "
+{-# LINE 766 "src/Data/NonEmptyPrivate.hs" #-}
+ DocTest.property
+{-# LINE 766 "src/Data/NonEmptyPrivate.hs" #-}
+     (forRange $ \b0 -> forRange $ \b1 -> forRange $ \b2 -> let b = FuncHT.unzip $ b0!:b1!:b2!:Empty.Cons in map (Ix.index b) (Ix.range b) == take (Ix.rangeSize b) [0..])