Rename D.V.IVector, D.V.MVector and D.V.MVector.New
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Mon, 16 Nov 2009 11:08:26 +0000 (11:08 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Mon, 16 Nov 2009 11:08:26 +0000 (11:08 +0000)
They are now called D.V.Generic, D.V.Generic.Mutable and D.V.Generic.New

Data/Vector.hs
Data/Vector/Generic.hs [moved from Data/Vector/IVector.hs with 72% similarity]
Data/Vector/Generic/Mutable.hs [moved from Data/Vector/MVector.hs with 98% similarity]
Data/Vector/Generic/New.hs [moved from Data/Vector/MVector/New.hs with 94% similarity]
Data/Vector/Mutable.hs
Data/Vector/Primitive.hs
Data/Vector/Primitive/Mutable.hs
Data/Vector/Storable.hs
Data/Vector/Storable/Mutable.hs
vector.cabal

index 1e823f3..8ea1c05 100644 (file)
@@ -63,8 +63,7 @@ module Data.Vector (
   toList, fromList
 ) where
 
-import           Data.Vector.IVector ( IVector(..) )
-import qualified Data.Vector.IVector as IV
+import qualified Data.Vector.Generic as G
 import qualified Data.Vector.Mutable as Mut
 import           Data.Primitive.Array
 
@@ -92,7 +91,7 @@ data Vector a = Vector {-# UNPACK #-} !Int
 instance Show a => Show (Vector a) where
     show = (Prelude.++ " :: Data.Vector.Vector") . ("fromList " Prelude.++) . show . toList
 
-instance IVector Vector a where
+instance G.Vector Vector a where
   {-# INLINE vnew #-}
   vnew init = runST (do
                        Mut.Vector i n marr <- init
@@ -110,22 +109,22 @@ instance IVector Vector a where
 
 instance Eq a => Eq (Vector a) where
   {-# INLINE (==) #-}
-  (==) = IV.eq
+  (==) = G.eq
 
 instance Ord a => Ord (Vector a) where
   {-# INLINE compare #-}
-  compare = IV.cmp
+  compare = G.cmp
 
 -- Length
 -- ------
 
 length :: Vector a -> Int
 {-# INLINE length #-}
-length = IV.length
+length = G.length
 
 null :: Vector a -> Bool
 {-# INLINE null #-}
-null = IV.null
+null = G.null
 
 -- Construction
 -- ------------
@@ -133,38 +132,38 @@ null = IV.null
 -- | Empty vector
 empty :: Vector a
 {-# INLINE empty #-}
-empty = IV.empty
+empty = G.empty
 
 -- | Vector with exaclty one element
 singleton :: a -> Vector a
 {-# INLINE singleton #-}
-singleton = IV.singleton
+singleton = G.singleton
 
 -- | Vector of the given length with the given value in each position
 replicate :: Int -> a -> Vector a
 {-# INLINE replicate #-}
-replicate = IV.replicate
+replicate = G.replicate
 
 -- | Prepend an element
 cons :: a -> Vector a -> Vector a
 {-# INLINE cons #-}
-cons = IV.cons
+cons = G.cons
 
 -- | Append an element
 snoc :: Vector a -> a -> Vector a
 {-# INLINE snoc #-}
-snoc = IV.snoc
+snoc = G.snoc
 
 infixr 5 ++
 -- | Concatenate two vectors
 (++) :: Vector a -> Vector a -> Vector a
 {-# INLINE (++) #-}
-(++) = (IV.++)
+(++) = (G.++)
 
 -- | Create a copy of a vector. Useful when dealing with slices.
 copy :: Vector a -> Vector a
 {-# INLINE copy #-}
-copy = IV.copy
+copy = G.copy
 
 -- Accessing individual elements
 -- -----------------------------
@@ -172,31 +171,31 @@ copy = IV.copy
 -- | Indexing
 (!) :: Vector a -> Int -> a
 {-# INLINE (!) #-}
-(!) = (IV.!)
+(!) = (G.!)
 
 -- | First element
 head :: Vector a -> a
 {-# INLINE head #-}
-head = IV.head
+head = G.head
 
 -- | Last element
 last :: Vector a -> a
 {-# INLINE last #-}
-last = IV.last
+last = G.last
 
 -- | Monadic indexing which can be strict in the vector while remaining lazy in
 -- the element
 indexM :: Monad m => Vector a -> Int -> m a
 {-# INLINE indexM #-}
-indexM = IV.indexM
+indexM = G.indexM
 
 headM :: Monad m => Vector a -> m a
 {-# INLINE headM #-}
-headM = IV.headM
+headM = G.headM
 
 lastM :: Monad m => Vector a -> m a
 {-# INLINE lastM #-}
-lastM = IV.lastM
+lastM = G.lastM
 
 -- Subarrays
 -- ---------
@@ -207,50 +206,50 @@ slice :: Vector a -> Int   -- ^ starting index
                   -> Int   -- ^ length
                   -> Vector a
 {-# INLINE slice #-}
-slice = IV.slice
+slice = G.slice
 
 -- | Yield all but the last element without copying.
 init :: Vector a -> Vector a
 {-# INLINE init #-}
-init = IV.init
+init = G.init
 
 -- | All but the first element (without copying).
 tail :: Vector a -> Vector a
 {-# INLINE tail #-}
-tail = IV.tail
+tail = G.tail
 
 -- | Yield the first @n@ elements without copying.
 take :: Int -> Vector a -> Vector a
 {-# INLINE take #-}
-take = IV.take
+take = G.take
 
 -- | Yield all but the first @n@ elements without copying.
 drop :: Int -> Vector a -> Vector a
 {-# INLINE drop #-}
-drop = IV.drop
+drop = G.drop
 
 -- Permutations
 -- ------------
 
 accum :: (a -> b -> a) -> Vector a -> [(Int,b)] -> Vector a
 {-# INLINE accum #-}
-accum = IV.accum
+accum = G.accum
 
 (//) :: Vector a -> [(Int, a)] -> Vector a
 {-# INLINE (//) #-}
-(//) = (IV.//)
+(//) = (G.//)
 
 update :: Vector a -> Vector (Int, a) -> Vector a
 {-# INLINE update #-}
-update = IV.update
+update = G.update
 
 backpermute :: Vector a -> Vector Int -> Vector a
 {-# INLINE backpermute #-}
-backpermute = IV.backpermute
+backpermute = G.backpermute
 
 reverse :: Vector a -> Vector a
 {-# INLINE reverse #-}
-reverse = IV.reverse
+reverse = G.reverse
 
 -- Mapping
 -- -------
@@ -258,11 +257,11 @@ reverse = IV.reverse
 -- | Map a function over a vector
 map :: (a -> b) -> Vector a -> Vector b
 {-# INLINE map #-}
-map = IV.map
+map = G.map
 
 concatMap :: (a -> Vector b) -> Vector a -> Vector b
 {-# INLINE concatMap #-}
-concatMap = IV.concatMap
+concatMap = G.concatMap
 
 -- Zipping/unzipping
 -- -----------------
@@ -270,28 +269,28 @@ concatMap = IV.concatMap
 -- | Zip two vectors with the given function.
 zipWith :: (a -> b -> c) -> Vector a -> Vector b -> Vector c
 {-# INLINE zipWith #-}
-zipWith = IV.zipWith
+zipWith = G.zipWith
 
 -- | Zip three vectors with the given function.
 zipWith3 :: (a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
 {-# INLINE zipWith3 #-}
-zipWith3 = IV.zipWith3
+zipWith3 = G.zipWith3
 
 zip :: Vector a -> Vector b -> Vector (a, b)
 {-# INLINE zip #-}
-zip = IV.zip
+zip = G.zip
 
 zip3 :: Vector a -> Vector b -> Vector c -> Vector (a, b, c)
 {-# INLINE zip3 #-}
-zip3 = IV.zip3
+zip3 = G.zip3
 
 unzip :: Vector (a, b) -> (Vector a, Vector b)
 {-# INLINE unzip #-}
-unzip = IV.unzip
+unzip = G.unzip
 
 unzip3 :: Vector (a, b, c) -> (Vector a, Vector b, Vector c)
 {-# INLINE unzip3 #-}
-unzip3 = IV.unzip3
+unzip3 = G.unzip3
 
 -- Filtering
 -- ---------
@@ -299,17 +298,17 @@ unzip3 = IV.unzip3
 -- | Drop elements which do not satisfy the predicate
 filter :: (a -> Bool) -> Vector a -> Vector a
 {-# INLINE filter #-}
-filter = IV.filter
+filter = G.filter
 
 -- | Yield the longest prefix of elements satisfying the predicate.
 takeWhile :: (a -> Bool) -> Vector a -> Vector a
 {-# INLINE takeWhile #-}
-takeWhile = IV.takeWhile
+takeWhile = G.takeWhile
 
 -- | Drop the longest prefix of elements that satisfy the predicate.
 dropWhile :: (a -> Bool) -> Vector a -> Vector a
 {-# INLINE dropWhile #-}
-dropWhile = IV.dropWhile
+dropWhile = G.dropWhile
 
 -- Searching
 -- ---------
@@ -318,25 +317,25 @@ infix 4 `elem`
 -- | Check whether the vector contains an element
 elem :: Eq a => a -> Vector a -> Bool
 {-# INLINE elem #-}
-elem = IV.elem
+elem = G.elem
 
 infix 4 `notElem`
 -- | Inverse of `elem`
 notElem :: Eq a => a -> Vector a -> Bool
 {-# INLINE notElem #-}
-notElem = IV.notElem
+notElem = G.notElem
 
 -- | Yield 'Just' the first element matching the predicate or 'Nothing' if no
 -- such element exists.
 find :: (a -> Bool) -> Vector a -> Maybe a
 {-# INLINE find #-}
-find = IV.find
+find = G.find
 
 -- | Yield 'Just' the index of the first element matching the predicate or
 -- 'Nothing' if no such element exists.
 findIndex :: (a -> Bool) -> Vector a -> Maybe Int
 {-# INLINE findIndex #-}
-findIndex = IV.findIndex
+findIndex = G.findIndex
 
 -- Folding
 -- -------
@@ -344,66 +343,66 @@ findIndex = IV.findIndex
 -- | Left fold
 foldl :: (a -> b -> a) -> a -> Vector b -> a
 {-# INLINE foldl #-}
-foldl = IV.foldl
+foldl = G.foldl
 
 -- | Lefgt fold on non-empty vectors
 foldl1 :: (a -> a -> a) -> Vector a -> a
 {-# INLINE foldl1 #-}
-foldl1 = IV.foldl1
+foldl1 = G.foldl1
 
 -- | Left fold with strict accumulator
 foldl' :: (a -> b -> a) -> a -> Vector b -> a
 {-# INLINE foldl' #-}
-foldl' = IV.foldl'
+foldl' = G.foldl'
 
 -- | Left fold on non-empty vectors with strict accumulator
 foldl1' :: (a -> a -> a) -> Vector a -> a
 {-# INLINE foldl1' #-}
-foldl1' = IV.foldl1'
+foldl1' = G.foldl1'
 
 -- | Right fold
 foldr :: (a -> b -> b) -> b -> Vector a -> b
 {-# INLINE foldr #-}
-foldr = IV.foldr
+foldr = G.foldr
 
 -- | Right fold on non-empty vectors
 foldr1 :: (a -> a -> a) -> Vector a -> a
 {-# INLINE foldr1 #-}
-foldr1 = IV.foldr1
+foldr1 = G.foldr1
 
 -- Specialised folds
 -- -----------------
 
 and :: Vector Bool -> Bool
 {-# INLINE and #-}
-and = IV.and
+and = G.and
 
 or :: Vector Bool -> Bool
 {-# INLINE or #-}
-or = IV.or
+or = G.or
 
 sum :: Num a => Vector a -> a
 {-# INLINE sum #-}
-sum = IV.sum
+sum = G.sum
 
 product :: Num a => Vector a -> a
 {-# INLINE product #-}
-product = IV.product
+product = G.product
 
 maximum :: Ord a => Vector a -> a
 {-# INLINE maximum #-}
-maximum = IV.maximum
+maximum = G.maximum
 
 minimum :: Ord a => Vector a -> a
 {-# INLINE minimum #-}
-minimum = IV.minimum
+minimum = G.minimum
 
 -- Unfolding
 -- ---------
 
 unfoldr :: (b -> Maybe (a, b)) -> b -> Vector a
 {-# INLINE unfoldr #-}
-unfoldr = IV.unfoldr
+unfoldr = G.unfoldr
 
 -- Scans
 -- -----
@@ -411,53 +410,53 @@ unfoldr = IV.unfoldr
 -- | Prefix scan
 prescanl :: (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE prescanl #-}
-prescanl = IV.prescanl
+prescanl = G.prescanl
 
 -- | Prefix scan with strict accumulator
 prescanl' :: (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE prescanl' #-}
-prescanl' = IV.prescanl'
+prescanl' = G.prescanl'
 
 -- | Suffix scan
 postscanl :: (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE postscanl #-}
-postscanl = IV.postscanl
+postscanl = G.postscanl
 
 -- | Suffix scan with strict accumulator
 postscanl' :: (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE postscanl' #-}
-postscanl' = IV.postscanl'
+postscanl' = G.postscanl'
 
 -- | Haskell-style scan
 scanl :: (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE scanl #-}
-scanl = IV.scanl
+scanl = G.scanl
 
 -- | Haskell-style scan with strict accumulator
 scanl' :: (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE scanl' #-}
-scanl' = IV.scanl'
+scanl' = G.scanl'
 
 -- | Scan over a non-empty 'Vector'
 scanl1 :: (a -> a -> a) -> Vector a -> Vector a
 {-# INLINE scanl1 #-}
-scanl1 = IV.scanl1
+scanl1 = G.scanl1
 
 -- | Scan over a non-empty 'Vector' with a strict accumulator
 scanl1' :: (a -> a -> a) -> Vector a -> Vector a
 {-# INLINE scanl1' #-}
-scanl1' = IV.scanl1'
+scanl1' = G.scanl1'
 
 -- Enumeration
 -- -----------
 
 enumFromTo :: Enum a => a -> a -> Vector a
 {-# INLINE enumFromTo #-}
-enumFromTo = IV.enumFromTo
+enumFromTo = G.enumFromTo
 
 enumFromThenTo :: Enum a => a -> a -> a -> Vector a
 {-# INLINE enumFromThenTo #-}
-enumFromThenTo = IV.enumFromThenTo
+enumFromThenTo = G.enumFromThenTo
 
 -- Conversion to/from lists
 -- ------------------------
@@ -465,10 +464,10 @@ enumFromThenTo = IV.enumFromThenTo
 -- | Convert a vector to a list
 toList :: Vector a -> [a]
 {-# INLINE toList #-}
-toList = IV.toList
+toList = G.toList
 
 -- | Convert a list to a vector
 fromList :: [a] -> Vector a
 {-# INLINE fromList #-}
-fromList = IV.fromList
+fromList = G.fromList
 
similarity index 72%
rename from Data/Vector/IVector.hs
rename to Data/Vector/Generic.hs
index 2e038b4..98f27a6 100644 (file)
@@ -1,8 +1,8 @@
 {-# LANGUAGE Rank2Types, MultiParamTypeClasses, FlexibleContexts,
              ScopedTypeVariables #-}
 -- |
--- Module      : Data.Vector.IVector
--- Copyright   : (c) Roman Leshchinskiy 2008
+-- Module      : Data.Vector.Generic
+-- Copyright   : (c) Roman Leshchinskiy 2008-2009
 -- License     : BSD-style
 --
 -- Maintainer  : Roman Leshchinskiy <rl@cse.unsw.edu.au>
@@ -14,9 +14,9 @@
 
 #include "phases.h"
 
-module Data.Vector.IVector (
+module Data.Vector.Generic (
   -- * Immutable vectors
-  IVector(..),
+  Vector(..),
 
   -- * Length information
   length, null,
@@ -75,11 +75,11 @@ module Data.Vector.IVector (
   new
 ) where
 
-import qualified Data.Vector.MVector as MVector
-import           Data.Vector.MVector ( MVector )
+import qualified Data.Vector.Generic.Mutable as Mut
+import           Data.Vector.Generic.Mutable ( MVector )
 
-import qualified Data.Vector.MVector.New as New
-import           Data.Vector.MVector.New ( New )
+import qualified Data.Vector.Generic.New as New
+import           Data.Vector.Generic.New ( New )
 
 import qualified Data.Vector.Fusion.Stream as Stream
 import           Data.Vector.Fusion.Stream ( Stream, MStream )
@@ -104,7 +104,7 @@ import Prelude hiding ( length, null,
 
 -- | Class of immutable vectors.
 --
-class IVector v a where
+class Vector v a where
   -- | Construct a pure vector from a monadic initialiser (not fusible!)
   vnew         :: (forall mv m. MVector mv m a => m (mv a)) -> v a
 
@@ -141,7 +141,7 @@ class IVector v a where
 -- ------
 
 -- | Construct a pure vector from a monadic initialiser 
-new :: IVector v a => New a -> v a
+new :: Vector v a => New a -> v a
 {-# INLINE new #-}
 new m = new' undefined m
 
@@ -149,12 +149,12 @@ new m = new' undefined m
 -- the rule @uninplace@.
 --
 -- See http://hackage.haskell.org/trac/ghc/ticket/2600
-new' :: IVector v a => v a -> New a -> v a
+new' :: Vector v a => v a -> New a -> v a
 {-# INLINE_STREAM new' #-}
 new' _ m = vnew (New.run m)
 
 -- | Convert a vector to a 'Stream'
-stream :: IVector v a => v a -> Stream a
+stream :: Vector v a => v a -> Stream a
 {-# INLINE_STREAM stream #-}
 stream v = v `seq` (Stream.unfoldr get 0 `Stream.sized` Exact n)
   where
@@ -165,16 +165,16 @@ stream v = v `seq` (Stream.unfoldr get 0 `Stream.sized` Exact n)
           | otherwise = Nothing
 
 -- | Create a vector from a 'Stream'
-unstream :: IVector v a => Stream a -> v a
+unstream :: Vector v a => Stream a -> v a
 {-# INLINE unstream #-}
 unstream s = new (New.unstream s)
 
 {-# RULES
 
-"stream/unstream [IVector]" forall v s.
+"stream/unstream [Vector]" forall v s.
   stream (new' v (New.unstream s)) = s
 
-"New.unstream/stream/new [IVector]" forall v p.
+"New.unstream/stream/new [Vector]" forall v p.
   New.unstream (stream (new' v p)) = p
 
  #-}
@@ -186,15 +186,15 @@ inplace f s = f s
 
 {-# RULES
 
-"inplace [IVector]"
+"inplace [Vector]"
   forall (f :: forall m. Monad m => MStream m a -> MStream m a) v m.
   New.unstream (inplace f (stream (new' v m))) = New.transform f m
 
-"uninplace [IVector]"
+"uninplace [Vector]"
   forall (f :: forall m. Monad m => MStream m a -> MStream m a) v m.
   stream (new' v (New.transform f m)) = inplace f (stream (new' v m))
 
-"inplace/inplace [IVector]"
+"inplace/inplace [Vector]"
   forall (f :: forall m. Monad m => MStream m a -> MStream m a)
          (g :: forall m. Monad m => MStream m a -> MStream m a)
          s.
@@ -205,24 +205,24 @@ inplace f s = f s
 -- Length
 -- ------
 
-length :: IVector v a => v a -> Int
+length :: Vector v a => v a -> Int
 {-# INLINE_STREAM length #-}
 length v = vlength v
 
 {-# RULES
 
-"length/unstream [IVector]" forall v s.
+"length/unstream [Vector]" forall v s.
   length (new' v (New.unstream s)) = Stream.length s
 
   #-}
 
-null :: IVector v a => v a -> Bool
+null :: Vector v a => v a -> Bool
 {-# INLINE_STREAM null #-}
 null v = vlength v == 0
 
 {-# RULES
 
-"null/unstream [IVector]" forall v s.
+"null/unstream [Vector]" forall v s.
   null (new' v (New.unstream s)) = Stream.null s
 
   #-}
@@ -231,44 +231,44 @@ null v = vlength v == 0
 -- ------------
 
 -- | Empty vector
-empty :: IVector v a => v a
+empty :: Vector v a => v a
 {-# INLINE empty #-}
 empty = unstream Stream.empty
 
 -- | Vector with exaclty one element
-singleton :: IVector v a => a -> v a
+singleton :: Vector v a => a -> v a
 {-# INLINE singleton #-}
 singleton x = unstream (Stream.singleton x)
 
 -- | Vector of the given length with the given value in each position
-replicate :: IVector v a => Int -> a -> v a
+replicate :: Vector v a => Int -> a -> v a
 {-# INLINE replicate #-}
 replicate n = unstream . Stream.replicate n
 
 -- | Prepend an element
-cons :: IVector v a => a -> v a -> v a
+cons :: Vector v a => a -> v a -> v a
 {-# INLINE cons #-}
 cons x = unstream . Stream.cons x . stream
 
 -- | Append an element
-snoc :: IVector v a => v a -> a -> v a
+snoc :: Vector v a => v a -> a -> v a
 {-# INLINE snoc #-}
 snoc v = unstream . Stream.snoc (stream v)
 
 infixr 5 ++
 -- | Concatenate two vectors
-(++) :: IVector v a => v a -> v a -> v a
+(++) :: Vector v a => v a -> v a -> v a
 {-# INLINE (++) #-}
 v ++ w = unstream (stream v Stream.++ stream w)
 
 -- | Create a copy of a vector. Useful when dealing with slices.
-copy :: IVector v a => v a -> v a
+copy :: Vector v a => v a -> v a
 {-# INLINE_STREAM copy #-}
 copy = unstream . stream
 
 {-# RULES
 
-"copy/unstream [IVector]" forall v s.
+"copy/unstream [Vector]" forall v s.
   copy (new' v (New.unstream s)) = new' v (New.unstream s)
 
  #-}
@@ -277,58 +277,58 @@ copy = unstream . stream
 -- -----------------------------
 
 -- | Indexing
-(!) :: IVector v a => v a -> Int -> a
+(!) :: Vector v a => v a -> Int -> a
 {-# INLINE_STREAM (!) #-}
 v ! i = assert (i >= 0 && i < length v)
       $ unId (unsafeIndexM v i)
 
 -- | First element
-head :: IVector v a => v a -> a
+head :: Vector v a => v a -> a
 {-# INLINE_STREAM head #-}
 head v = v ! 0
 
 -- | Last element
-last :: IVector v a => v a -> a
+last :: Vector v a => v a -> a
 {-# INLINE_STREAM last #-}
 last v = v ! (length v - 1)
 
 {-# RULES
 
-"(!)/unstream [IVector]" forall v i s.
+"(!)/unstream [Vector]" forall v i s.
   new' v (New.unstream s) ! i = s Stream.!! i
 
-"head/unstream [IVector]" forall v s.
+"head/unstream [Vector]" forall v s.
   head (new' v (New.unstream s)) = Stream.head s
 
-"last/unstream [IVector]" forall v s.
+"last/unstream [Vector]" forall v s.
   last (new' v (New.unstream s)) = Stream.last s
 
  #-}
 
 -- | Monadic indexing which can be strict in the vector while remaining lazy in
 -- the element.
-indexM :: (IVector v a, Monad m) => v a -> Int -> m a
+indexM :: (Vector v a, Monad m) => v a -> Int -> m a
 {-# INLINE_STREAM indexM #-}
 indexM v i = assert (i >= 0 && i < length v)
            $ unsafeIndexM v i
 
-headM :: (IVector v a, Monad m) => v a -> m a
+headM :: (Vector v a, Monad m) => v a -> m a
 {-# INLINE_STREAM headM #-}
 headM v = indexM v 0
 
-lastM :: (IVector v a, Monad m) => v a -> m a
+lastM :: (Vector v a, Monad m) => v a -> m a
 {-# INLINE_STREAM lastM #-}
 lastM v = indexM v (length v - 1)
 
 {-# RULES
 
-"indexM/unstream [IVector]" forall v i s.
+"indexM/unstream [Vector]" forall v i s.
   indexM (new' v (New.unstream s)) i = return (s Stream.!! i)
 
-"headM/unstream [IVector]" forall v s.
+"headM/unstream [Vector]" forall v s.
   headM (new' v (New.unstream s)) = return (Stream.head s)
 
-"lastM/unstream [IVector]" forall v s.
+"lastM/unstream [Vector]" forall v s.
   lastM (new' v (New.unstream s)) = return (Stream.last s)
 
  #-}
@@ -340,7 +340,7 @@ lastM v = indexM v (length v - 1)
 
 -- | Yield a part of the vector without copying it. Safer version of
 -- 'unsafeSlice'.
-slice :: IVector v a => v a -> Int   -- ^ starting index
+slice :: Vector v a => v a -> Int   -- ^ starting index
                             -> Int   -- ^ length
                             -> v a
 {-# INLINE_STREAM slice #-}
@@ -348,23 +348,23 @@ slice v i n = assert (i >= 0 && n >= 0  && i+n <= length v)
             $ unsafeSlice v i n
 
 -- | Yield all but the last element without copying.
-init :: IVector v a => v a -> v a
+init :: Vector v a => v a -> v a
 {-# INLINE_STREAM init #-}
 init v = slice v 0 (length v - 1)
 
 -- | All but the first element (without copying).
-tail :: IVector v a => v a -> v a
+tail :: Vector v a => v a -> v a
 {-# INLINE_STREAM tail #-}
 tail v = slice v 1 (length v - 1)
 
 -- | Yield the first @n@ elements without copying.
-take :: IVector v a => Int -> v a -> v a
+take :: Vector v a => Int -> v a -> v a
 {-# INLINE_STREAM take #-}
 take n v = slice v 0 (min n' (length v))
   where n' = max n 0
 
 -- | Yield all but the first @n@ elements without copying.
-drop :: IVector v a => Int -> v a -> v a
+drop :: Vector v a => Int -> v a -> v a
 {-# INLINE_STREAM drop #-}
 drop n v = slice v (min n' len) (max 0 (len - n'))
   where n' = max n 0
@@ -372,19 +372,19 @@ drop n v = slice v (min n' len) (max 0 (len - n'))
 
 {-# RULES
 
-"slice/new [IVector]" forall v p i n.
+"slice/new [Vector]" forall v p i n.
   slice (new' v p) i n = new' v (New.slice p i n)
 
-"init/new [IVector]" forall v p.
+"init/new [Vector]" forall v p.
   init (new' v p) = new' v (New.init p)
 
-"tail/new [IVector]" forall v p.
+"tail/new [Vector]" forall v p.
   tail (new' v p) = new' v (New.tail p)
 
-"take/new [IVector]" forall n v p.
+"take/new [Vector]" forall n v p.
   take n (new' v p) = new' v (New.take n p)
 
-"drop/new [IVector]" forall n v p.
+"drop/new [Vector]" forall n v p.
   drop n (new' v p) = new' v (New.drop n p)
 
   #-}
@@ -392,17 +392,17 @@ drop n v = slice v (min n' len) (max 0 (len - n'))
 -- Permutations
 -- ------------
 
-accum :: IVector v a => (a -> b -> a) -> v a -> [(Int,b)] -> v a
+accum :: Vector v a => (a -> b -> a) -> v a -> [(Int,b)] -> v a
 {-# INLINE accum #-}
 accum f v us = new (New.accum f (New.unstream (stream v))
                                 (Stream.fromList us))
 
-(//) :: IVector v a => v a -> [(Int, a)] -> v a
+(//) :: Vector v a => v a -> [(Int, a)] -> v a
 {-# INLINE (//) #-}
 v // us = new (New.update (New.unstream (stream v))
                           (Stream.fromList us))
 
-update :: (IVector v a, IVector v (Int, a)) => v a -> v (Int, a) -> v a
+update :: (Vector v a, Vector v (Int, a)) => v a -> v (Int, a) -> v a
 {-# INLINE update #-}
 update v w = new (New.update (New.unstream (stream v)) (stream w))
 
@@ -411,7 +411,7 @@ update v w = new (New.update (New.unstream (stream v)) (stream w))
 -- elements. This would not be the case if we simply used
 --
 -- backpermute v is = map (v!) is
-backpermute :: (IVector v a, IVector v Int) => v a -> v Int -> v a
+backpermute :: (Vector v a, Vector v Int) => v a -> v Int -> v a
 {-# INLINE backpermute #-}
 backpermute v is = unstream
                  . MStream.trans (Id . unBox)
@@ -419,7 +419,7 @@ backpermute v is = unstream
                  . MStream.trans (Box . unId)
                  $ stream is
 
-reverse :: (IVector v a) => v a -> v a
+reverse :: (Vector v a) => v a -> v a
 {-# INLINE reverse #-}
 reverse = new . New.reverse . New.unstream . stream
 
@@ -427,21 +427,21 @@ reverse = new . New.reverse . New.unstream . stream
 -- -------
 
 -- | Map a function over a vector
-map :: (IVector v a, IVector v b) => (a -> b) -> v a -> v b
+map :: (Vector v a, Vector v b) => (a -> b) -> v a -> v b
 {-# INLINE map #-}
 map f = unstream . Stream.map f . stream
 
-inplace_map :: IVector v a => (a -> a) -> v a -> v a
+inplace_map :: Vector v a => (a -> a) -> v a -> v a
 {-# INLINE inplace_map #-}
 inplace_map f = unstream . inplace (MStream.map f) . stream
 
 {-# RULES
 
-"map->inplace_map [IVector]" map = inplace_map
+"map->inplace_map [Vector]" map = inplace_map
 
  #-}
 
-concatMap :: (IVector v a, IVector v b) => (a -> v b) -> v a -> v b
+concatMap :: (Vector v a, Vector v b) => (a -> v b) -> v a -> v b
 {-# INLINE concatMap #-}
 concatMap f = unstream . Stream.concatMap (stream . f) . stream
 
@@ -449,39 +449,39 @@ concatMap f = unstream . Stream.concatMap (stream . f) . stream
 -- -----------------
 
 -- | Zip two vectors with the given function.
-zipWith :: (IVector v a, IVector v b, IVector v c) => (a -> b -> c) -> v a -> v b -> v c
+zipWith :: (Vector v a, Vector v b, Vector v c) => (a -> b -> c) -> v a -> v b -> v c
 {-# INLINE zipWith #-}
 zipWith f xs ys = unstream (Stream.zipWith f (stream xs) (stream ys))
 
 -- | Zip three vectors with the given function.
-zipWith3 :: (IVector v a, IVector v b, IVector v c, IVector v d) => (a -> b -> c -> d) -> v a -> v b -> v c -> v d
+zipWith3 :: (Vector v a, Vector v b, Vector v c, Vector v d) => (a -> b -> c -> d) -> v a -> v b -> v c -> v d
 {-# INLINE zipWith3 #-}
 zipWith3 f xs ys zs = unstream (Stream.zipWith3 f (stream xs) (stream ys) (stream zs))
 
-zip :: (IVector v a, IVector v b, IVector v (a,b)) => v a -> v b -> v (a, b)
+zip :: (Vector v a, Vector v b, Vector v (a,b)) => v a -> v b -> v (a, b)
 {-# INLINE zip #-}
 zip = zipWith (,)
 
-zip3 :: (IVector v a, IVector v b, IVector v c, IVector v (a, b, c)) => v a -> v b -> v c -> v (a, b, c)
+zip3 :: (Vector v a, Vector v b, Vector v c, Vector v (a, b, c)) => v a -> v b -> v c -> v (a, b, c)
 {-# INLINE zip3 #-}
 zip3 = zipWith3 (,,)
 
-unzip :: (IVector v a, IVector v b, IVector v (a,b)) => v (a, b) -> (v a, v b)
+unzip :: (Vector v a, Vector v b, Vector v (a,b)) => v (a, b) -> (v a, v b)
 {-# INLINE unzip #-}
 unzip xs = (map fst xs, map snd xs)
 
-unzip3 :: (IVector v a, IVector v b, IVector v c, IVector v (a, b, c)) => v (a, b, c) -> (v a, v b, v c)
+unzip3 :: (Vector v a, Vector v b, Vector v c, Vector v (a, b, c)) => v (a, b, c) -> (v a, v b, v c)
 {-# INLINE unzip3 #-}
 unzip3 xs = (map (\(a, b, c) -> a) xs, map (\(a, b, c) -> b) xs, map (\(a, b, c) -> c) xs)
 
 -- Comparisons
 -- -----------
 
-eq :: (IVector v a, Eq a) => v a -> v a -> Bool
+eq :: (Vector v a, Eq a) => v a -> v a -> Bool
 {-# INLINE eq #-}
 xs `eq` ys = stream xs == stream ys
 
-cmp :: (IVector v a, Ord a) => v a -> v a -> Ordering
+cmp :: (Vector v a, Ord a) => v a -> v a -> Ordering
 {-# INLINE cmp #-}
 cmp xs ys = compare (stream xs) (stream ys)
 
@@ -489,17 +489,17 @@ cmp xs ys = compare (stream xs) (stream ys)
 -- ---------
 
 -- | Drop elements which do not satisfy the predicate
-filter :: IVector v a => (a -> Bool) -> v a -> v a
+filter :: Vector v a => (a -> Bool) -> v a -> v a
 {-# INLINE filter #-}
 filter f = unstream . inplace (MStream.filter f) . stream
 
 -- | Yield the longest prefix of elements satisfying the predicate.
-takeWhile :: IVector v a => (a -> Bool) -> v a -> v a
+takeWhile :: Vector v a => (a -> Bool) -> v a -> v a
 {-# INLINE takeWhile #-}
 takeWhile f = unstream . Stream.takeWhile f . stream
 
 -- | Drop the longest prefix of elements that satisfy the predicate.
-dropWhile :: IVector v a => (a -> Bool) -> v a -> v a
+dropWhile :: Vector v a => (a -> Bool) -> v a -> v a
 {-# INLINE dropWhile #-}
 dropWhile f = unstream . Stream.dropWhile f . stream
 
@@ -508,25 +508,25 @@ dropWhile f = unstream . Stream.dropWhile f . stream
 
 infix 4 `elem`
 -- | Check whether the vector contains an element
-elem :: (IVector v a, Eq a) => a -> v a -> Bool
+elem :: (Vector v a, Eq a) => a -> v a -> Bool
 {-# INLINE elem #-}
 elem x = Stream.elem x . stream
 
 infix 4 `notElem`
 -- | Inverse of `elem`
-notElem :: (IVector v a, Eq a) => a -> v a -> Bool
+notElem :: (Vector v a, Eq a) => a -> v a -> Bool
 {-# INLINE notElem #-}
 notElem x = Stream.notElem x . stream
 
 -- | Yield 'Just' the first element matching the predicate or 'Nothing' if no
 -- such element exists.
-find :: IVector v a => (a -> Bool) -> v a -> Maybe a
+find :: Vector v a => (a -> Bool) -> v a -> Maybe a
 {-# INLINE find #-}
 find f = Stream.find f . stream
 
 -- | Yield 'Just' the index of the first element matching the predicate or
 -- 'Nothing' if no such element exists.
-findIndex :: IVector v a => (a -> Bool) -> v a -> Maybe Int
+findIndex :: Vector v a => (a -> Bool) -> v a -> Maybe Int
 {-# INLINE findIndex #-}
 findIndex f = Stream.findIndex f . stream
 
@@ -534,66 +534,66 @@ findIndex f = Stream.findIndex f . stream
 -- -------
 
 -- | Left fold
-foldl :: IVector v b => (a -> b -> a) -> a -> v b -> a
+foldl :: Vector v b => (a -> b -> a) -> a -> v b -> a
 {-# INLINE foldl #-}
 foldl f z = Stream.foldl f z . stream
 
 -- | Lefgt fold on non-empty vectors
-foldl1 :: IVector v a => (a -> a -> a) -> v a -> a
+foldl1 :: Vector v a => (a -> a -> a) -> v a -> a
 {-# INLINE foldl1 #-}
 foldl1 f = Stream.foldl1 f . stream
 
 -- | Left fold with strict accumulator
-foldl' :: IVector v b => (a -> b -> a) -> a -> v b -> a
+foldl' :: Vector v b => (a -> b -> a) -> a -> v b -> a
 {-# INLINE foldl' #-}
 foldl' f z = Stream.foldl' f z . stream
 
 -- | Left fold on non-empty vectors with strict accumulator
-foldl1' :: IVector v a => (a -> a -> a) -> v a -> a
+foldl1' :: Vector v a => (a -> a -> a) -> v a -> a
 {-# INLINE foldl1' #-}
 foldl1' f = Stream.foldl1' f . stream
 
 -- | Right fold
-foldr :: IVector v a => (a -> b -> b) -> b -> v a -> b
+foldr :: Vector v a => (a -> b -> b) -> b -> v a -> b
 {-# INLINE foldr #-}
 foldr f z = Stream.foldr f z . stream
 
 -- | Right fold on non-empty vectors
-foldr1 :: IVector v a => (a -> a -> a) -> v a -> a
+foldr1 :: Vector v a => (a -> a -> a) -> v a -> a
 {-# INLINE foldr1 #-}
 foldr1 f = Stream.foldr1 f . stream
 
 -- Specialised folds
 -- -----------------
 
-and :: IVector v Bool => v Bool -> Bool
+and :: Vector v Bool => v Bool -> Bool
 {-# INLINE and #-}
 and = Stream.and . stream
 
-or :: IVector v Bool => v Bool -> Bool
+or :: Vector v Bool => v Bool -> Bool
 {-# INLINE or #-}
 or = Stream.or . stream
 
-sum :: (IVector v a, Num a) => v a -> a
+sum :: (Vector v a, Num a) => v a -> a
 {-# INLINE sum #-}
 sum = Stream.foldl' (+) 0 . stream
 
-product :: (IVector v a, Num a) => v a -> a
+product :: (Vector v a, Num a) => v a -> a
 {-# INLINE product #-}
 product = Stream.foldl' (*) 1 . stream
 
-maximum :: (IVector v a, Ord a) => v a -> a
+maximum :: (Vector v a, Ord a) => v a -> a
 {-# INLINE maximum #-}
 maximum = Stream.foldl1' max . stream
 
-minimum :: (IVector v a, Ord a) => v a -> a
+minimum :: (Vector v a, Ord a) => v a -> a
 {-# INLINE minimum #-}
 minimum = Stream.foldl1' min . stream
 
 -- Unfolding
 -- ---------
 
-unfoldr :: IVector v a => (b -> Maybe (a, b)) -> b -> v a
+unfoldr :: Vector v a => (b -> Maybe (a, b)) -> b -> v a
 {-# INLINE unfoldr #-}
 unfoldr f = unstream . Stream.unfoldr f
 
@@ -601,89 +601,89 @@ unfoldr f = unstream . Stream.unfoldr f
 -- -----
 
 -- | Prefix scan
-prescanl :: (IVector v a, IVector v b) => (a -> b -> a) -> a -> v b -> v a
+prescanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
 {-# INLINE prescanl #-}
 prescanl f z = unstream . Stream.prescanl f z . stream
 
-inplace_prescanl :: IVector v a => (a -> a -> a) -> a -> v a -> v a
+inplace_prescanl :: Vector v a => (a -> a -> a) -> a -> v a -> v a
 {-# INLINE inplace_prescanl #-}
 inplace_prescanl f z = unstream . inplace (MStream.prescanl f z) . stream
 
 {-# RULES
 
-"prescanl -> inplace_prescanl [IVector]" prescanl = inplace_prescanl
+"prescanl -> inplace_prescanl [Vector]" prescanl = inplace_prescanl
 
  #-}
 
 -- | Prefix scan with strict accumulator
-prescanl' :: (IVector v a, IVector v b) => (a -> b -> a) -> a -> v b -> v a
+prescanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
 {-# INLINE prescanl' #-}
 prescanl' f z = unstream . Stream.prescanl' f z . stream
 
-inplace_prescanl' :: IVector v a => (a -> a -> a) -> a -> v a -> v a
+inplace_prescanl' :: Vector v a => (a -> a -> a) -> a -> v a -> v a
 {-# INLINE inplace_prescanl' #-}
 inplace_prescanl' f z = unstream . inplace (MStream.prescanl' f z) . stream
 
 {-# RULES
 
-"prescanl' -> inplace_prescanl' [IVector]" prescanl' = inplace_prescanl'
+"prescanl' -> inplace_prescanl' [Vector]" prescanl' = inplace_prescanl'
 
  #-}
 
 -- | Suffix scan
-postscanl :: (IVector v a, IVector v b) => (a -> b -> a) -> a -> v b -> v a
+postscanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
 {-# INLINE postscanl #-}
 postscanl f z = unstream . Stream.postscanl f z . stream
 
-inplace_postscanl :: IVector v a => (a -> a -> a) -> a -> v a -> v a
+inplace_postscanl :: Vector v a => (a -> a -> a) -> a -> v a -> v a
 {-# INLINE inplace_postscanl #-}
 inplace_postscanl f z = unstream . inplace (MStream.postscanl f z) . stream
 
 {-# RULES
 
-"postscanl -> inplace_postscanl [IVector]" postscanl = inplace_postscanl
+"postscanl -> inplace_postscanl [Vector]" postscanl = inplace_postscanl
 
  #-}
 
 -- | Suffix scan with strict accumulator
-postscanl' :: (IVector v a, IVector v b) => (a -> b -> a) -> a -> v b -> v a
+postscanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
 {-# INLINE postscanl' #-}
 postscanl' f z = unstream . Stream.postscanl' f z . stream
 
-inplace_postscanl' :: IVector v a => (a -> a -> a) -> a -> v a -> v a
+inplace_postscanl' :: Vector v a => (a -> a -> a) -> a -> v a -> v a
 {-# INLINE inplace_postscanl' #-}
 inplace_postscanl' f z = unstream . inplace (MStream.postscanl' f z) . stream
 
 {-# RULES
 
-"postscanl' -> inplace_postscanl' [IVector]" postscanl' = inplace_postscanl'
+"postscanl' -> inplace_postscanl' [Vector]" postscanl' = inplace_postscanl'
 
  #-}
 
 -- | Haskell-style scan
-scanl :: (IVector v a, IVector v b) => (a -> b -> a) -> a -> v b -> v a
+scanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
 {-# INLINE scanl #-}
 scanl f z = unstream . Stream.scanl f z . stream
 
 -- | Haskell-style scan with strict accumulator
-scanl' :: (IVector v a, IVector v b) => (a -> b -> a) -> a -> v b -> v a
+scanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
 {-# INLINE scanl' #-}
 scanl' f z = unstream . Stream.scanl' f z . stream
 
 -- | Scan over a non-empty vector
-scanl1 :: IVector v a => (a -> a -> a) -> v a -> v a
+scanl1 :: Vector v a => (a -> a -> a) -> v a -> v a
 {-# INLINE scanl1 #-}
 scanl1 f = unstream . inplace (MStream.scanl1 f) . stream
 
 -- | Scan over a non-empty vector with a strict accumulator
-scanl1' :: IVector v a => (a -> a -> a) -> v a -> v a
+scanl1' :: Vector v a => (a -> a -> a) -> v a -> v a
 {-# INLINE scanl1' #-}
 scanl1' f = unstream . inplace (MStream.scanl1' f) . stream
 
 -- Enumeration
 -- -----------
 
-enumFromTo :: (IVector v a, Enum a) => a -> a -> v a
+enumFromTo :: (Vector v a, Enum a) => a -> a -> v a
 {-# INLINE enumFromTo #-}
 enumFromTo from to = from `seq` to `seq` unfoldr enumFromTo_go (fromEnum from)
   where
@@ -691,7 +691,7 @@ enumFromTo from to = from `seq` to `seq` unfoldr enumFromTo_go (fromEnum from)
     enumFromTo_go i | i <= to_i = Just (toEnum i, i + 1)
                     | otherwise = Nothing
 
-enumFromThenTo :: (IVector v a, Enum a) => a -> a -> a -> v a
+enumFromThenTo :: (Vector v a, Enum a) => a -> a -> a -> v a
 {-# INLINE enumFromThenTo #-}
 enumFromThenTo from next to = from `seq` next `seq` to `seq` unfoldr enumFromThenTo_go from_i
   where
@@ -702,12 +702,12 @@ enumFromThenTo from next to = from `seq` next `seq` to `seq` unfoldr enumFromThe
                         | otherwise = Nothing
 
 -- | Convert a vector to a list
-toList :: IVector v a => v a -> [a]
+toList :: Vector v a => v a -> [a]
 {-# INLINE toList #-}
 toList = Stream.toList . stream
 
 -- | Convert a list to a vector
-fromList :: IVector v a => [a] -> v a
+fromList :: Vector v a => [a] -> v a
 {-# INLINE fromList #-}
 fromList = unstream . Stream.fromList
 
similarity index 98%
rename from Data/Vector/MVector.hs
rename to Data/Vector/Generic/Mutable.hs
index 8291486..f8856fc 100644 (file)
@@ -1,6 +1,6 @@
 {-# LANGUAGE MultiParamTypeClasses #-}
 -- |
--- Module      : Data.Vector.MVector
+-- Module      : Data.Vector.Generic.Mutable
 -- Copyright   : (c) Roman Leshchinskiy 2008
 -- License     : BSD-style
 --
@@ -13,7 +13,7 @@
 
 #include "phases.h"
 
-module Data.Vector.MVector (
+module Data.Vector.Generic.Mutable (
   MVectorPure(..), MVector(..),
 
   slice, new, newWith, read, write, copy, grow,
similarity index 94%
rename from Data/Vector/MVector/New.hs
rename to Data/Vector/Generic/New.hs
index 787dadc..6d5ceef 100644 (file)
@@ -2,13 +2,13 @@
 
 #include "phases.h"
 
-module Data.Vector.MVector.New (
+module Data.Vector.Generic.New (
   New(..), run, unstream, transform, accum, update, reverse,
   slice, init, tail, take, drop
 ) where
 
-import qualified Data.Vector.MVector as MVector
-import           Data.Vector.MVector ( MVector, MVectorPure )
+import qualified Data.Vector.Generic.Mutable as MVector
+import           Data.Vector.Generic.Mutable ( MVector, MVectorPure )
 
 import           Data.Vector.Fusion.Stream ( Stream, MStream )
 import qualified Data.Vector.Fusion.Stream as Stream
index cf69961..6acaad0 100644 (file)
@@ -15,8 +15,8 @@
 module Data.Vector.Mutable ( Vector(..), IOVector, STVector )
 where
 
-import qualified Data.Vector.MVector as MVector
-import           Data.Vector.MVector ( MVector, MVectorPure )
+import qualified Data.Vector.Generic.Mutable as G
+import           Data.Vector.Generic.Mutable ( MVector(..), MVectorPure(..) )
 import           Data.Primitive.Array
 import           Control.Monad.Primitive ( PrimMonad )
 import           Control.Monad.ST ( ST )
@@ -59,7 +59,7 @@ instance PrimMonad m => MVector (Vector m) m a where
   unsafeWrite (Vector i _ arr) j x = writeArray arr (i+j) x
 
   {-# INLINE clear #-}
-  clear v = MVector.set v uninitialised
+  clear v = G.set v uninitialised
 
 uninitialised :: a
 uninitialised = error "Data.Vector.Mutable: uninitialised element"
index 82a932e..2803884 100644 (file)
@@ -63,8 +63,7 @@ module Data.Vector.Primitive (
   toList, fromList
 ) where
 
-import           Data.Vector.IVector ( IVector(..) )
-import qualified Data.Vector.IVector           as IV
+import qualified Data.Vector.Generic           as G
 import qualified Data.Vector.Primitive.Mutable as Mut
 import           Data.Primitive.ByteArray
 import           Data.Primitive ( Prim )
@@ -98,7 +97,7 @@ data Vector a = Vector {-# UNPACK #-} !Int
 instance (Show a, Prim a) => Show (Vector a) where
     show = (Prelude.++ " :: Data.Vector.Primitive.Vector") . ("fromList " Prelude.++) . show . toList
 
-instance Prim a => IVector Vector a where
+instance Prim a => G.Vector Vector a where
   {-# INLINE vnew #-}
   vnew init = runST (do
                        Mut.Vector i n marr <- init
@@ -116,22 +115,22 @@ instance Prim a => IVector Vector a where
 
 instance (Prim a, Eq a) => Eq (Vector a) where
   {-# INLINE (==) #-}
-  (==) = IV.eq
+  (==) = G.eq
 
 instance (Prim a, Ord a) => Ord (Vector a) where
   {-# INLINE compare #-}
-  compare = IV.cmp
+  compare = G.cmp
 
 -- Length
 -- ------
 
 length :: Prim a => Vector a -> Int
 {-# INLINE length #-}
-length = IV.length
+length = G.length
 
 null :: Prim a => Vector a -> Bool
 {-# INLINE null #-}
-null = IV.null
+null = G.null
 
 -- Construction
 -- ------------
@@ -139,38 +138,38 @@ null = IV.null
 -- | Empty vector
 empty :: Prim a => Vector a
 {-# INLINE empty #-}
-empty = IV.empty
+empty = G.empty
 
 -- | Vector with exaclty one element
 singleton :: Prim a => a -> Vector a
 {-# INLINE singleton #-}
-singleton = IV.singleton
+singleton = G.singleton
 
 -- | Vector of the given length with the given value in each position
 replicate :: Prim a => Int -> a -> Vector a
 {-# INLINE replicate #-}
-replicate = IV.replicate
+replicate = G.replicate
 
 -- | Prepend an element
 cons :: Prim a => a -> Vector a -> Vector a
 {-# INLINE cons #-}
-cons = IV.cons
+cons = G.cons
 
 -- | Append an element
 snoc :: Prim a => Vector a -> a -> Vector a
 {-# INLINE snoc #-}
-snoc = IV.snoc
+snoc = G.snoc
 
 infixr 5 ++
 -- | Concatenate two vectors
 (++) :: Prim a => Vector a -> Vector a -> Vector a
 {-# INLINE (++) #-}
-(++) = (IV.++)
+(++) = (G.++)
 
 -- | Create a copy of a vector. Useful when dealing with slices.
 copy :: Prim a => Vector a -> Vector a
 {-# INLINE copy #-}
-copy = IV.copy
+copy = G.copy
 
 -- Accessing individual elements
 -- -----------------------------
@@ -178,17 +177,17 @@ copy = IV.copy
 -- | Indexing
 (!) :: Prim a => Vector a -> Int -> a
 {-# INLINE (!) #-}
-(!) = (IV.!)
+(!) = (G.!)
 
 -- | First element
 head :: Prim a => Vector a -> a
 {-# INLINE head #-}
-head = IV.head
+head = G.head
 
 -- | Last element
 last :: Prim a => Vector a -> a
 {-# INLINE last #-}
-last = IV.last
+last = G.last
 
 -- Subarrays
 -- ---------
@@ -199,46 +198,46 @@ slice :: Prim a => Vector a -> Int   -- ^ starting index
                              -> Int   -- ^ length
                              -> Vector a
 {-# INLINE slice #-}
-slice = IV.slice
+slice = G.slice
 
 -- | Yield all but the last element without copying.
 init :: Prim a => Vector a -> Vector a
 {-# INLINE init #-}
-init = IV.init
+init = G.init
 
 -- | All but the first element (without copying).
 tail :: Prim a => Vector a -> Vector a
 {-# INLINE tail #-}
-tail = IV.tail
+tail = G.tail
 
 -- | Yield the first @n@ elements without copying.
 take :: Prim a => Int -> Vector a -> Vector a
 {-# INLINE take #-}
-take = IV.take
+take = G.take
 
 -- | Yield all but the first @n@ elements without copying.
 drop :: Prim a => Int -> Vector a -> Vector a
 {-# INLINE drop #-}
-drop = IV.drop
+drop = G.drop
 
 -- Permutations
 -- ------------
 
 accum :: Prim a => (a -> b -> a) -> Vector a -> [(Int,b)] -> Vector a
 {-# INLINE accum #-}
-accum = IV.accum
+accum = G.accum
 
 (//) :: Prim a => Vector a -> [(Int, a)] -> Vector a
 {-# INLINE (//) #-}
-(//) = (IV.//)
+(//) = (G.//)
 
 backpermute :: Prim a => Vector a -> Vector Int -> Vector a
 {-# INLINE backpermute #-}
-backpermute = IV.backpermute
+backpermute = G.backpermute
 
 reverse :: Prim a => Vector a -> Vector a
 {-# INLINE reverse #-}
-reverse = IV.reverse
+reverse = G.reverse
 
 -- Mapping
 -- -------
@@ -246,11 +245,11 @@ reverse = IV.reverse
 -- | Map a function over a vector
 map :: (Prim a, Prim b) => (a -> b) -> Vector a -> Vector b
 {-# INLINE map #-}
-map = IV.map
+map = G.map
 
 concatMap :: (Prim a, Prim b) => (a -> Vector b) -> Vector a -> Vector b
 {-# INLINE concatMap #-}
-concatMap = IV.concatMap
+concatMap = G.concatMap
 
 -- Zipping/unzipping
 -- -----------------
@@ -259,13 +258,13 @@ concatMap = IV.concatMap
 zipWith :: (Prim a, Prim b, Prim c)
         => (a -> b -> c) -> Vector a -> Vector b -> Vector c
 {-# INLINE zipWith #-}
-zipWith = IV.zipWith
+zipWith = G.zipWith
 
 -- | Zip three vectors with the given function.
 zipWith3 :: (Prim a, Prim b, Prim c, Prim d)
          => (a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
 {-# INLINE zipWith3 #-}
-zipWith3 = IV.zipWith3
+zipWith3 = G.zipWith3
 
 -- Filtering
 -- ---------
@@ -273,17 +272,17 @@ zipWith3 = IV.zipWith3
 -- | Drop elements which do not satisfy the predicate
 filter :: Prim a => (a -> Bool) -> Vector a -> Vector a
 {-# INLINE filter #-}
-filter = IV.filter
+filter = G.filter
 
 -- | Yield the longest prefix of elements satisfying the predicate.
 takeWhile :: Prim a => (a -> Bool) -> Vector a -> Vector a
 {-# INLINE takeWhile #-}
-takeWhile = IV.takeWhile
+takeWhile = G.takeWhile
 
 -- | Drop the longest prefix of elements that satisfy the predicate.
 dropWhile :: Prim a => (a -> Bool) -> Vector a -> Vector a
 {-# INLINE dropWhile #-}
-dropWhile = IV.dropWhile
+dropWhile = G.dropWhile
 
 -- Searching
 -- ---------
@@ -292,25 +291,25 @@ infix 4 `elem`
 -- | Check whether the vector contains an element
 elem :: (Prim a, Eq a) => a -> Vector a -> Bool
 {-# INLINE elem #-}
-elem = IV.elem
+elem = G.elem
 
 infix 4 `notElem`
 -- | Inverse of `elem`
 notElem :: (Prim a, Eq a) => a -> Vector a -> Bool
 {-# INLINE notElem #-}
-notElem = IV.notElem
+notElem = G.notElem
 
 -- | Yield 'Just' the first element matching the predicate or 'Nothing' if no
 -- such element exists.
 find :: Prim a => (a -> Bool) -> Vector a -> Maybe a
 {-# INLINE find #-}
-find = IV.find
+find = G.find
 
 -- | Yield 'Just' the index of the first element matching the predicate or
 -- 'Nothing' if no such element exists.
 findIndex :: Prim a => (a -> Bool) -> Vector a -> Maybe Int
 {-# INLINE findIndex #-}
-findIndex = IV.findIndex
+findIndex = G.findIndex
 
 -- Folding
 -- -------
@@ -318,32 +317,32 @@ findIndex = IV.findIndex
 -- | Left fold
 foldl :: Prim b => (a -> b -> a) -> a -> Vector b -> a
 {-# INLINE foldl #-}
-foldl = IV.foldl
+foldl = G.foldl
 
 -- | Lefgt fold on non-empty vectors
 foldl1 :: Prim a => (a -> a -> a) -> Vector a -> a
 {-# INLINE foldl1 #-}
-foldl1 = IV.foldl1
+foldl1 = G.foldl1
 
 -- | Left fold with strict accumulator
 foldl' :: Prim b => (a -> b -> a) -> a -> Vector b -> a
 {-# INLINE foldl' #-}
-foldl' = IV.foldl'
+foldl' = G.foldl'
 
 -- | Left fold on non-empty vectors with strict accumulator
 foldl1' :: Prim a => (a -> a -> a) -> Vector a -> a
 {-# INLINE foldl1' #-}
-foldl1' = IV.foldl1'
+foldl1' = G.foldl1'
 
 -- | Right fold
 foldr :: Prim a => (a -> b -> b) -> b -> Vector a -> b
 {-# INLINE foldr #-}
-foldr = IV.foldr
+foldr = G.foldr
 
 -- | Right fold on non-empty vectors
 foldr1 :: Prim a => (a -> a -> a) -> Vector a -> a
 {-# INLINE foldr1 #-}
-foldr1 = IV.foldr1
+foldr1 = G.foldr1
 
 -- Specialised folds
 -- -----------------
@@ -351,35 +350,35 @@ foldr1 = IV.foldr1
 {-
 and :: Vector Bool -> Bool
 {-# INLINE and #-}
-and = IV.and
+and = G.and
 
 or :: Vector Bool -> Bool
 {-# INLINE or #-}
-or = IV.or
+or = G.or
 -}
 
 sum :: (Prim a, Num a) => Vector a -> a
 {-# INLINE sum #-}
-sum = IV.sum
+sum = G.sum
 
 product :: (Prim a, Num a) => Vector a -> a
 {-# INLINE product #-}
-product = IV.product
+product = G.product
 
 maximum :: (Prim a, Ord a) => Vector a -> a
 {-# INLINE maximum #-}
-maximum = IV.maximum
+maximum = G.maximum
 
 minimum :: (Prim a, Ord a) => Vector a -> a
 {-# INLINE minimum #-}
-minimum = IV.minimum
+minimum = G.minimum
 
 -- Unfolding
 -- ---------
 
 unfoldr :: Prim a => (b -> Maybe (a, b)) -> b -> Vector a
 {-# INLINE unfoldr #-}
-unfoldr = IV.unfoldr
+unfoldr = G.unfoldr
 
 -- Scans
 -- -----
@@ -387,53 +386,53 @@ unfoldr = IV.unfoldr
 -- | Prefix scan
 prescanl :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE prescanl #-}
-prescanl = IV.prescanl
+prescanl = G.prescanl
 
 -- | Prefix scan with strict accumulator
 prescanl' :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE prescanl' #-}
-prescanl' = IV.prescanl'
+prescanl' = G.prescanl'
 
 -- | Suffix scan
 postscanl :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE postscanl #-}
-postscanl = IV.postscanl
+postscanl = G.postscanl
 
 -- | Suffix scan with strict accumulator
 postscanl' :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE postscanl' #-}
-postscanl' = IV.postscanl'
+postscanl' = G.postscanl'
 
 -- | Haskell-style scan
 scanl :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE scanl #-}
-scanl = IV.scanl
+scanl = G.scanl
 
 -- | Haskell-style scan with strict accumulator
 scanl' :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE scanl' #-}
-scanl' = IV.scanl'
+scanl' = G.scanl'
 
 -- | Scan over a non-empty 'Vector'
 scanl1 :: Prim a => (a -> a -> a) -> Vector a -> Vector a
 {-# INLINE scanl1 #-}
-scanl1 = IV.scanl1
+scanl1 = G.scanl1
 
 -- | Scan over a non-empty 'Vector' with a strict accumulator
 scanl1' :: Prim a => (a -> a -> a) -> Vector a -> Vector a
 {-# INLINE scanl1' #-}
-scanl1' = IV.scanl1'
+scanl1' = G.scanl1'
 
 -- Enumeration
 -- -----------
 
 enumFromTo :: (Prim a, Enum a) => a -> a -> Vector a
 {-# INLINE enumFromTo #-}
-enumFromTo = IV.enumFromTo
+enumFromTo = G.enumFromTo
 
 enumFromThenTo :: (Prim a, Enum a) => a -> a -> a -> Vector a
 {-# INLINE enumFromThenTo #-}
-enumFromThenTo = IV.enumFromThenTo
+enumFromThenTo = G.enumFromThenTo
 
 -- Conversion to/from lists
 -- ------------------------
@@ -441,10 +440,10 @@ enumFromThenTo = IV.enumFromThenTo
 -- | Convert a vector to a list
 toList :: Prim a => Vector a -> [a]
 {-# INLINE toList #-}
-toList = IV.toList
+toList = G.toList
 
 -- | Convert a list to a vector
 fromList :: Prim a => [a] -> Vector a
 {-# INLINE fromList #-}
-fromList = IV.fromList
+fromList = G.fromList
 
index aaac669..2b1d166 100644 (file)
@@ -12,8 +12,7 @@
 module Data.Vector.Primitive.Mutable ( Vector(..) )
 where
 
-import qualified Data.Vector.MVector as MVector
-import           Data.Vector.MVector ( MVector, MVectorPure )
+import           Data.Vector.Generic.Mutable ( MVector(..), MVectorPure(..) )
 import           Data.Primitive.ByteArray
 import           Data.Primitive ( Prim, sizeOf )
 import           Control.Monad.Primitive
index c0c8791..c97c217 100644 (file)
@@ -63,8 +63,7 @@ module Data.Vector.Storable (
   toList, fromList
 ) where
 
-import Data.Vector.IVector ( IVector(..) )
-import qualified Data.Vector.IVector          as IV
+import qualified Data.Vector.Generic          as G
 import qualified Data.Vector.Storable.Mutable as Mut
 import Data.Vector.Storable.Internal
 
@@ -99,7 +98,7 @@ instance (Show a, Storable a) => Show (Vector a) where
        . show
        . toList
 
-instance Storable a => IVector Vector a where
+instance Storable a => G.Vector Vector a where
   {-# INLINE vnew #-}
   vnew init = unsafePerformIO (do
                                  Mut.Vector i n p <- init
@@ -118,22 +117,22 @@ instance Storable a => IVector Vector a where
 
 instance (Storable a, Eq a) => Eq (Vector a) where
   {-# INLINE (==) #-}
-  (==) = IV.eq
+  (==) = G.eq
 
 instance (Storable a, Ord a) => Ord (Vector a) where
   {-# INLINE compare #-}
-  compare = IV.cmp
+  compare = G.cmp
 
 -- Length
 -- ------
 
 length :: Storable a => Vector a -> Int
 {-# INLINE length #-}
-length = IV.length
+length = G.length
 
 null :: Storable a => Vector a -> Bool
 {-# INLINE null #-}
-null = IV.null
+null = G.null
 
 -- Construction
 -- ------------
@@ -141,38 +140,38 @@ null = IV.null
 -- | Empty vector
 empty :: Storable a => Vector a
 {-# INLINE empty #-}
-empty = IV.empty
+empty = G.empty
 
 -- | Vector with exaclty one element
 singleton :: Storable a => a -> Vector a
 {-# INLINE singleton #-}
-singleton = IV.singleton
+singleton = G.singleton
 
 -- | Vector of the given length with the given value in each position
 replicate :: Storable a => Int -> a -> Vector a
 {-# INLINE replicate #-}
-replicate = IV.replicate
+replicate = G.replicate
 
 -- | Prepend an element
 cons :: Storable a => a -> Vector a -> Vector a
 {-# INLINE cons #-}
-cons = IV.cons
+cons = G.cons
 
 -- | Append an element
 snoc :: Storable a => Vector a -> a -> Vector a
 {-# INLINE snoc #-}
-snoc = IV.snoc
+snoc = G.snoc
 
 infixr 5 ++
 -- | Concatenate two vectors
 (++) :: Storable a => Vector a -> Vector a -> Vector a
 {-# INLINE (++) #-}
-(++) = (IV.++)
+(++) = (G.++)
 
 -- | Create a copy of a vector. Useful when dealing with slices.
 copy :: Storable a => Vector a -> Vector a
 {-# INLINE copy #-}
-copy = IV.copy
+copy = G.copy
 
 -- Accessing individual elements
 -- -----------------------------
@@ -180,17 +179,17 @@ copy = IV.copy
 -- | Indexing
 (!) :: Storable a => Vector a -> Int -> a
 {-# INLINE (!) #-}
-(!) = (IV.!)
+(!) = (G.!)
 
 -- | First element
 head :: Storable a => Vector a -> a
 {-# INLINE head #-}
-head = IV.head
+head = G.head
 
 -- | Last element
 last :: Storable a => Vector a -> a
 {-# INLINE last #-}
-last = IV.last
+last = G.last
 
 -- Subarrays
 -- ---------
@@ -201,46 +200,46 @@ slice :: Storable a => Vector a -> Int   -- ^ starting index
                              -> Int   -- ^ length
                              -> Vector a
 {-# INLINE slice #-}
-slice = IV.slice
+slice = G.slice
 
 -- | Yield all but the last element without copying.
 init :: Storable a => Vector a -> Vector a
 {-# INLINE init #-}
-init = IV.init
+init = G.init
 
 -- | All but the first element (without copying).
 tail :: Storable a => Vector a -> Vector a
 {-# INLINE tail #-}
-tail = IV.tail
+tail = G.tail
 
 -- | Yield the first @n@ elements without copying.
 take :: Storable a => Int -> Vector a -> Vector a
 {-# INLINE take #-}
-take = IV.take
+take = G.take
 
 -- | Yield all but the first @n@ elements without copying.
 drop :: Storable a => Int -> Vector a -> Vector a
 {-# INLINE drop #-}
-drop = IV.drop
+drop = G.drop
 
 -- Permutations
 -- ------------
 
 accum :: Storable a => (a -> b -> a) -> Vector a -> [(Int,b)] -> Vector a
 {-# INLINE accum #-}
-accum = IV.accum
+accum = G.accum
 
 (//) :: Storable a => Vector a -> [(Int, a)] -> Vector a
 {-# INLINE (//) #-}
-(//) = (IV.//)
+(//) = (G.//)
 
 backpermute :: Storable a => Vector a -> Vector Int -> Vector a
 {-# INLINE backpermute #-}
-backpermute = IV.backpermute
+backpermute = G.backpermute
 
 reverse :: Storable a => Vector a -> Vector a
 {-# INLINE reverse #-}
-reverse = IV.reverse
+reverse = G.reverse
 
 -- Mapping
 -- -------
@@ -248,11 +247,11 @@ reverse = IV.reverse
 -- | Map a function over a vector
 map :: (Storable a, Storable b) => (a -> b) -> Vector a -> Vector b
 {-# INLINE map #-}
-map = IV.map
+map = G.map
 
 concatMap :: (Storable a, Storable b) => (a -> Vector b) -> Vector a -> Vector b
 {-# INLINE concatMap #-}
-concatMap = IV.concatMap
+concatMap = G.concatMap
 
 -- Zipping/unzipping
 -- -----------------
@@ -261,13 +260,13 @@ concatMap = IV.concatMap
 zipWith :: (Storable a, Storable b, Storable c)
         => (a -> b -> c) -> Vector a -> Vector b -> Vector c
 {-# INLINE zipWith #-}
-zipWith = IV.zipWith
+zipWith = G.zipWith
 
 -- | Zip three vectors with the given function.
 zipWith3 :: (Storable a, Storable b, Storable c, Storable d)
          => (a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
 {-# INLINE zipWith3 #-}
-zipWith3 = IV.zipWith3
+zipWith3 = G.zipWith3
 
 -- Filtering
 -- ---------
@@ -275,17 +274,17 @@ zipWith3 = IV.zipWith3
 -- | Drop elements which do not satisfy the predicate
 filter :: Storable a => (a -> Bool) -> Vector a -> Vector a
 {-# INLINE filter #-}
-filter = IV.filter
+filter = G.filter
 
 -- | Yield the longest prefix of elements satisfying the predicate.
 takeWhile :: Storable a => (a -> Bool) -> Vector a -> Vector a
 {-# INLINE takeWhile #-}
-takeWhile = IV.takeWhile
+takeWhile = G.takeWhile
 
 -- | Drop the longest prefix of elements that satisfy the predicate.
 dropWhile :: Storable a => (a -> Bool) -> Vector a -> Vector a
 {-# INLINE dropWhile #-}
-dropWhile = IV.dropWhile
+dropWhile = G.dropWhile
 
 -- Searching
 -- ---------
@@ -294,25 +293,25 @@ infix 4 `elem`
 -- | Check whether the vector contains an element
 elem :: (Storable a, Eq a) => a -> Vector a -> Bool
 {-# INLINE elem #-}
-elem = IV.elem
+elem = G.elem
 
 infix 4 `notElem`
 -- | Inverse of `elem`
 notElem :: (Storable a, Eq a) => a -> Vector a -> Bool
 {-# INLINE notElem #-}
-notElem = IV.notElem
+notElem = G.notElem
 
 -- | Yield 'Just' the first element matching the predicate or 'Nothing' if no
 -- such element exists.
 find :: Storable a => (a -> Bool) -> Vector a -> Maybe a
 {-# INLINE find #-}
-find = IV.find
+find = G.find
 
 -- | Yield 'Just' the index of the first element matching the predicate or
 -- 'Nothing' if no such element exists.
 findIndex :: Storable a => (a -> Bool) -> Vector a -> Maybe Int
 {-# INLINE findIndex #-}
-findIndex = IV.findIndex
+findIndex = G.findIndex
 
 -- Folding
 -- -------
@@ -320,66 +319,66 @@ findIndex = IV.findIndex
 -- | Left fold
 foldl :: Storable b => (a -> b -> a) -> a -> Vector b -> a
 {-# INLINE foldl #-}
-foldl = IV.foldl
+foldl = G.foldl
 
 -- | Lefgt fold on non-empty vectors
 foldl1 :: Storable a => (a -> a -> a) -> Vector a -> a
 {-# INLINE foldl1 #-}
-foldl1 = IV.foldl1
+foldl1 = G.foldl1
 
 -- | Left fold with strict accumulator
 foldl' :: Storable b => (a -> b -> a) -> a -> Vector b -> a
 {-# INLINE foldl' #-}
-foldl' = IV.foldl'
+foldl' = G.foldl'
 
 -- | Left fold on non-empty vectors with strict accumulator
 foldl1' :: Storable a => (a -> a -> a) -> Vector a -> a
 {-# INLINE foldl1' #-}
-foldl1' = IV.foldl1'
+foldl1' = G.foldl1'
 
 -- | Right fold
 foldr :: Storable a => (a -> b -> b) -> b -> Vector a -> b
 {-# INLINE foldr #-}
-foldr = IV.foldr
+foldr = G.foldr
 
 -- | Right fold on non-empty vectors
 foldr1 :: Storable a => (a -> a -> a) -> Vector a -> a
 {-# INLINE foldr1 #-}
-foldr1 = IV.foldr1
+foldr1 = G.foldr1
 
 -- Specialised folds
 -- -----------------
 
 and :: Vector Bool -> Bool
 {-# INLINE and #-}
-and = IV.and
+and = G.and
 
 or :: Vector Bool -> Bool
 {-# INLINE or #-}
-or = IV.or
+or = G.or
 
 sum :: (Storable a, Num a) => Vector a -> a
 {-# INLINE sum #-}
-sum = IV.sum
+sum = G.sum
 
 product :: (Storable a, Num a) => Vector a -> a
 {-# INLINE product #-}
-product = IV.product
+product = G.product
 
 maximum :: (Storable a, Ord a) => Vector a -> a
 {-# INLINE maximum #-}
-maximum = IV.maximum
+maximum = G.maximum
 
 minimum :: (Storable a, Ord a) => Vector a -> a
 {-# INLINE minimum #-}
-minimum = IV.minimum
+minimum = G.minimum
 
 -- Unfolding
 -- ---------
 
 unfoldr :: Storable a => (b -> Maybe (a, b)) -> b -> Vector a
 {-# INLINE unfoldr #-}
-unfoldr = IV.unfoldr
+unfoldr = G.unfoldr
 
 -- Scans
 -- -----
@@ -387,53 +386,53 @@ unfoldr = IV.unfoldr
 -- | Prefix scan
 prescanl :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE prescanl #-}
-prescanl = IV.prescanl
+prescanl = G.prescanl
 
 -- | Prefix scan with strict accumulator
 prescanl' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE prescanl' #-}
-prescanl' = IV.prescanl'
+prescanl' = G.prescanl'
 
 -- | Suffix scan
 postscanl :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE postscanl #-}
-postscanl = IV.postscanl
+postscanl = G.postscanl
 
 -- | Suffix scan with strict accumulator
 postscanl' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE postscanl' #-}
-postscanl' = IV.postscanl'
+postscanl' = G.postscanl'
 
 -- | Haskell-style scan
 scanl :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE scanl #-}
-scanl = IV.scanl
+scanl = G.scanl
 
 -- | Haskell-style scan with strict accumulator
 scanl' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE scanl' #-}
-scanl' = IV.scanl'
+scanl' = G.scanl'
 
 -- | Scan over a non-empty 'Vector'
 scanl1 :: Storable a => (a -> a -> a) -> Vector a -> Vector a
 {-# INLINE scanl1 #-}
-scanl1 = IV.scanl1
+scanl1 = G.scanl1
 
 -- | Scan over a non-empty 'Vector' with a strict accumulator
 scanl1' :: Storable a => (a -> a -> a) -> Vector a -> Vector a
 {-# INLINE scanl1' #-}
-scanl1' = IV.scanl1'
+scanl1' = G.scanl1'
 
 -- Enumeration
 -- -----------
 
 enumFromTo :: (Storable a, Enum a) => a -> a -> Vector a
 {-# INLINE enumFromTo #-}
-enumFromTo = IV.enumFromTo
+enumFromTo = G.enumFromTo
 
 enumFromThenTo :: (Storable a, Enum a) => a -> a -> a -> Vector a
 {-# INLINE enumFromThenTo #-}
-enumFromThenTo = IV.enumFromThenTo
+enumFromThenTo = G.enumFromThenTo
 
 -- Conversion to/from lists
 -- ------------------------
@@ -441,10 +440,10 @@ enumFromThenTo = IV.enumFromThenTo
 -- | Convert a vector to a list
 toList :: Storable a => Vector a -> [a]
 {-# INLINE toList #-}
-toList = IV.toList
+toList = G.toList
 
 -- | Convert a list to a vector
 fromList :: Storable a => [a] -> Vector a
 {-# INLINE fromList #-}
-fromList = IV.fromList
+fromList = G.fromList
 
index 643bd29..7d134e9 100644 (file)
@@ -15,8 +15,7 @@
 module Data.Vector.Storable.Mutable( Vector(..) )
 where
 
-import qualified Data.Vector.MVector as MVector
-import           Data.Vector.MVector ( MVector, MVectorPure )
+import Data.Vector.Generic.Mutable ( MVector(..), MVectorPure(..) )
 
 import Foreign.Storable
 import Foreign.ForeignPtr
index 593217a..90d8bca 100644 (file)
@@ -40,9 +40,9 @@ Library
         Data.Vector.Fusion.Stream.Monadic
         Data.Vector.Fusion.Stream
 
-        Data.Vector.MVector
-        Data.Vector.MVector.New
-        Data.Vector.IVector
+        Data.Vector.Generic.Mutable
+        Data.Vector.Generic.New
+        Data.Vector.Generic
 
         Data.Vector.Primitive.Mutable
         Data.Vector.Primitive