packages feed

non-empty 0.3.3 → 0.3.4

raw patch · 9 files changed

+293/−49 lines, 9 filesdep ~deepseq

Dependency ranges changed: deepseq

Files

Makefile view
@@ -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
non-empty.cabal view
@@ -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
src/Data/Empty.hs view
@@ -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
+ src/Data/FixedLengthList.hs view
@@ -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
src/Data/NonEmpty/Class.hs view
@@ -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
src/Data/NonEmpty/Map.hs view
@@ -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
src/Data/NonEmptyPrivate.hs view
@@ -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
test/Test/Data/NonEmpty/Map.hs view
@@ -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))
test/Test/Data/NonEmptyPrivate.hs view
@@ -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..])