diff --git a/Changelog b/Changelog
new file mode 100644
--- /dev/null
+++ b/Changelog
@@ -0,0 +1,30 @@
+Changes 0.6 - 0.6.0.1
+
+  * Improved documentation
+
+Changes 0.5 - 0.6
+
+  * More efficient representation of Storable vectors
+
+  * Block copy operations used when possible
+
+  * Typeable and Data instances
+
+  * Monadic combinators (replicateM, mapM etc.)
+
+  * Better support for recycling (see create and modify)
+
+  * Performance improvements
+
+Changes 0.4.2 - 0.5
+
+  * Unboxed vectors of primitive types and tuples.
+
+  * Redesigned interface between mutable and immutable vectors. It now
+  includes the popular unsafeFreeze primitive.
+
+  * Many new combinators.
+
+  * Significant performance improvements. Unboxed vectors are usually faster
+  than primitive unboxed DPH arrays.
+
diff --git a/Data/Vector.hs b/Data/Vector.hs
--- a/Data/Vector.hs
+++ b/Data/Vector.hs
@@ -23,1084 +23,1268 @@
 --
 
 module Data.Vector (
-
-  -- * The pure and mutable array types
-  Vector, MVector,
-
-  -- * Constructing vectors
-  empty,
-  singleton,
-  cons,
-  snoc,
-  (++),
-  replicate,
-  generate,
-  force,
-
-  -- * Operations based on length information
-  length,
-  null,
-
-  -- * Accessing individual elements
-  (!),
-  head,
-  last,
-
-  -- ** Accessors in a monad
-  indexM,
-  headM,
-  lastM,
-
-  -- ** Accessor functions with no bounds checking
-  unsafeIndex, unsafeHead, unsafeLast,
-  unsafeIndexM, unsafeHeadM, unsafeLastM,
-
-  -- * Subvectors
-  init,
-  tail,
-  take,
-  drop,
-  slice,
-
-  -- * Subvector construction without bounds checks
-  unsafeSlice, unsafeInit, unsafeTail, unsafeTake, unsafeDrop,
-
-  -- * Permutations
-  accum, accumulate, accumulate_,
-  (//), update, update_,
-  backpermute, reverse,
-  unsafeAccum, unsafeAccumulate, unsafeAccumulate_,
-  unsafeUpd, unsafeUpdate, unsafeUpdate_,
-  unsafeBackpermute,
-
-  -- * Mapping
-  map, imap, concatMap,
-
-  -- * Zipping and unzipping
-  zipWith, zipWith3, zipWith4, zipWith5, zipWith6,
-  izipWith, izipWith3, izipWith4, izipWith5, izipWith6,
-  zip, zip3, zip4, zip5, zip6,
-  unzip, unzip3, unzip4, unzip5, unzip6,
-
-  -- * Filtering
-  filter, ifilter, takeWhile, dropWhile,
-  partition, unstablePartition, span, break,
-
-  -- * Searching
-  elem, notElem, find, findIndex, findIndices, elemIndex, elemIndices,
-
-  -- * Folding
-  foldl, foldl1, foldl', foldl1', foldr, foldr1, foldr', foldr1',
-  ifoldl, ifoldl', ifoldr, ifoldr',
-
-  -- * Specialised folds
-  all, any, and, or,
-  sum, product,
-  maximum, maximumBy, minimum, minimumBy,
-  minIndex, minIndexBy, maxIndex, maxIndexBy,
-
-  -- * Unfolding
-  unfoldr, unfoldrN,
-
-  -- * Scans
-  prescanl, prescanl',
-  postscanl, postscanl',
-  scanl, scanl', scanl1, scanl1',
-  prescanr, prescanr',
-  postscanr, postscanr',
-  scanr, scanr', scanr1, scanr1',
-
-  -- * Enumeration
-  enumFromN, enumFromStepN, enumFromTo, enumFromThenTo,
-
-  -- * Conversion to/from lists
-  toList, fromList, fromListN,
-
-  -- * Monadic operations
-  replicateM, mapM, mapM_, forM, forM_, zipWithM, zipWithM_, filterM,
-  foldM, foldM', fold1M, fold1M',
-
-  -- * Destructive operations
-  create, modify, copy, unsafeCopy
-) where
-
-import qualified Data.Vector.Generic as G
-import           Data.Vector.Mutable  ( MVector(..) )
-import           Data.Primitive.Array
-import qualified Data.Vector.Fusion.Stream as Stream
-
-import Control.Monad ( liftM )
-import Control.Monad.ST ( ST )
-import Control.Monad.Primitive
-
-import Prelude hiding ( length, null,
-                        replicate, (++),
-                        head, last,
-                        init, tail, take, drop, reverse,
-                        map, concatMap,
-                        zipWith, zipWith3, zip, zip3, unzip, unzip3,
-                        filter, takeWhile, dropWhile, span, break,
-                        elem, notElem,
-                        foldl, foldl1, foldr, foldr1,
-                        all, any, and, or, sum, product, minimum, maximum,
-                        scanl, scanl1, scanr, scanr1,
-                        enumFromTo, enumFromThenTo,
-                        mapM, mapM_ )
-
-import qualified Prelude
-
-import Data.Typeable ( Typeable )
-import Data.Data     ( Data(..) )
-
--- | Boxed vectors, supporting efficient slicing.
-data Vector a = Vector {-# UNPACK #-} !Int
-                       {-# UNPACK #-} !Int
-                       {-# UNPACK #-} !(Array a)
-        deriving ( Typeable )
-
-instance Show a => Show (Vector a) where
-    show = (Prelude.++ " :: Data.Vector.Vector") . ("fromList " Prelude.++) . show . toList
-
-instance Data a => Data (Vector a) where
-  gfoldl       = G.gfoldl
-  toConstr _   = error "toConstr"
-  gunfold _ _  = error "gunfold"
-  dataTypeOf _ = G.mkType "Data.Vector.Vector"
-  dataCast1    = G.dataCast
-
-type instance G.Mutable Vector = MVector
-
-instance G.Vector Vector a where
-  {-# INLINE unsafeFreeze #-}
-  unsafeFreeze (MVector i n marr)
-    = Vector i n `liftM` unsafeFreezeArray marr
-
-  {-# INLINE basicLength #-}
-  basicLength (Vector _ n _) = n
-
-  {-# INLINE basicUnsafeSlice #-}
-  basicUnsafeSlice j n (Vector i _ arr) = Vector (i+j) n arr
-
-  {-# INLINE basicUnsafeIndexM #-}
-  basicUnsafeIndexM (Vector i _ arr) j = indexArrayM arr (i+j)
-
--- See http://trac.haskell.org/vector/ticket/12
-instance Eq a => Eq (Vector a) where
-  {-# INLINE (==) #-}
-  xs == ys = Stream.eq (G.stream xs) (G.stream ys)
-
-  {-# INLINE (/=) #-}
-  xs /= ys = not (Stream.eq (G.stream xs) (G.stream ys))
-
--- See http://trac.haskell.org/vector/ticket/12
-instance Ord a => Ord (Vector a) where
-  {-# INLINE compare #-}
-  compare xs ys = Stream.cmp (G.stream xs) (G.stream ys)
-
-  {-# INLINE (<) #-}
-  xs < ys = Stream.cmp (G.stream xs) (G.stream ys) == LT
-
-  {-# INLINE (<=) #-}
-  xs <= ys = Stream.cmp (G.stream xs) (G.stream ys) /= GT
-
-  {-# INLINE (>) #-}
-  xs > ys = Stream.cmp (G.stream xs) (G.stream ys) == GT
-
-  {-# INLINE (>=) #-}
-  xs >= ys = Stream.cmp (G.stream xs) (G.stream ys) /= LT
-
--- Length
--- ------
-
--- |/O(1)/. Yield the length of a vector as an 'Int'
-length :: Vector a -> Int
-{-# INLINE length #-}
-length = G.length
-
--- |/O(1)/. 'null' tests whether the given array is empty.
-null :: Vector a -> Bool
-{-# INLINE null #-}
-null = G.null
-
--- Construction
--- ------------
-
--- |/O(1)/. 'empty' builds a vector of size zero.
-empty :: Vector a
-{-# INLINE empty #-}
-empty = G.empty
-
--- |/O(1)/, Vector with exactly one element
-singleton :: a -> Vector a
-{-# INLINE singleton #-}
-singleton = G.singleton
-
--- |/O(n)/. @'replicate' n e@ yields a vector of length @n@ storing @e@ at each position
-replicate :: Int -> a -> Vector a
-{-# INLINE replicate #-}
-replicate = G.replicate
-
--- |/O(n)/, Generate a vector of the given length by applying a (pure)
--- generator function to each index
-generate :: Int -> (Int -> a) -> Vector a
-{-# INLINE generate #-}
-generate = G.generate
-
--- |/O(n)/, Prepend an element to an array.
-cons :: a -> Vector a -> Vector a
-{-# INLINE cons #-}
-cons = G.cons
-
--- |/O(n)/, Append an element to an array.
-snoc :: Vector a -> a -> Vector a
-{-# INLINE snoc #-}
-snoc = G.snoc
-
-infixr 5 ++
-
--- |/O(n)/, Concatenate two vectors
-(++) :: Vector a -> Vector a -> Vector a
-{-# INLINE (++) #-}
-(++) = (G.++)
-
--- |/O(n)/, Create a copy of a vector.
--- @force@ is useful when dealing with slices, as the garbage collector
--- may be able to free the original vector if no further references are held.
---
-force :: Vector a -> Vector a
-{-# INLINE force #-}
-force = G.force
-
--- Accessing individual elements
--- -----------------------------
-
--- |/O(1)/. Read the element in the vector at the given index.
-(!) :: Vector a -> Int -> a
-{-# INLINE (!) #-}
-(!) = (G.!)
-
--- |/O(1)/. 'head' returns the first element of the vector
-head :: Vector a -> a
-{-# INLINE head #-}
-head = G.head
-
--- |/O(n)/. 'last' yields the last element of an array.
-last :: Vector a -> a
-{-# INLINE last #-}
-last = G.last
-
--- |/O(1)/, Unsafe indexing without bounds checking
---
--- By not performing bounds checks, this function may be faster when
--- this function is used in an inner loop)
---
-unsafeIndex :: Vector a -> Int -> a
-{-# INLINE unsafeIndex #-}
-unsafeIndex = G.unsafeIndex
-
--- |/O(1)/, Yield the first element of a vector without checking if the vector is empty
---
--- By not performing bounds checks, this function may be faster when
--- this function is used in an inner loop)
-unsafeHead :: Vector a -> a
-{-# INLINE unsafeHead #-}
-unsafeHead = G.unsafeHead
-
--- | Yield the last element of a vector without checking if the vector is empty
---
--- By not performing bounds checks, this function may be faster when
--- this function is used in an inner loop)
-unsafeLast :: Vector a -> a
-{-# INLINE unsafeLast #-}
-unsafeLast = G.unsafeLast
-
--- | 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 = G.indexM
-
--- | Monadic head which can be strict in the vector while remaining lazy in the element
-headM :: Monad m => Vector a -> m a
-{-# INLINE headM #-}
-headM = G.headM
-
--- | Monadic last which can be strict in the vector while remaining lazy in the element
-lastM :: Monad m => Vector a -> m a
-{-# INLINE lastM #-}
-lastM = G.lastM
-
--- | Unsafe monadic indexing without bounds checks
-unsafeIndexM :: Monad m => Vector a -> Int -> m a
-{-# INLINE unsafeIndexM #-}
-unsafeIndexM = G.unsafeIndexM
-
--- | Unsafe monadic head (access the first element) without bounds checks
-unsafeHeadM :: Monad m => Vector a -> m a
-{-# INLINE unsafeHeadM #-}
-unsafeHeadM = G.unsafeHeadM
-
--- | Unsafe monadic last (access the last element) without bounds checks
-unsafeLastM :: Monad m => Vector a -> m a
-{-# INLINE unsafeLastM #-}
-unsafeLastM = G.unsafeLastM
-
--- Subarrays
--- ---------
-
--- | /O(1)/, Yield a part of the vector without copying it.
---
-slice :: Int   -- ^ starting index
-      -> Int   -- ^ length
-      -> Vector a
-      -> Vector a
-{-# INLINE slice #-}
-slice = G.slice
-
--- |/O(1)/, Yield all but the last element without copying.
-init :: Vector a -> Vector a
-{-# INLINE init #-}
-init = G.init
-
--- |/O(1), Yield all but the first element (without copying).
-tail :: Vector a -> Vector a
-{-# INLINE tail #-}
-tail = G.tail
-
--- |/O(1)/, Yield the first @n@ elements without copying.
-take :: Int -> Vector a -> Vector a
-{-# INLINE take #-}
-take = G.take
-
--- |/O(1)/, Yield all but the first @n@ elements without copying.
-drop :: Int -> Vector a -> Vector a
-{-# INLINE drop #-}
-drop = G.drop
-
--- |/O(1)/, Unsafely yield a part of the vector without copying it and without
--- performing bounds checks.
-unsafeSlice :: Int   -- ^ starting index
-            -> Int   -- ^ length
-            -> Vector a
-            -> Vector a
-{-# INLINE unsafeSlice #-}
-unsafeSlice = G.unsafeSlice
-
--- |/O(1)/, Zero-copying 'init' without bounds checks.
-unsafeInit :: Vector a -> Vector a
-{-# INLINE unsafeInit #-}
-unsafeInit = G.unsafeInit
-
--- |/O(1)/, Zero-copying 'tail' without bounds checks.
-unsafeTail :: Vector a -> Vector a
-{-# INLINE unsafeTail #-}
-unsafeTail = G.unsafeTail
-
--- |/O(1)/, Zero-copying 'take' without bounds checks.
-unsafeTake :: Int -> Vector a -> Vector a
-{-# INLINE unsafeTake #-}
-unsafeTake = G.unsafeTake
-
--- |/O(1)/, Zero-copying 'drop' without bounds checks.
-unsafeDrop :: Int -> Vector a -> Vector a
-{-# INLINE unsafeDrop #-}
-unsafeDrop = G.unsafeDrop
-
--- Permutations
--- ------------
-
--- TODO there is no documentation for the accum* family of functions
-
--- | TODO unsafeAccum.
-unsafeAccum :: (a -> b -> a) -> Vector a -> [(Int,b)] -> Vector a
-{-# INLINE unsafeAccum #-}
-unsafeAccum = G.unsafeAccum
-
--- | TODO unsafeAccumulate
-unsafeAccumulate :: (a -> b -> a) -> Vector a -> Vector (Int,b) -> Vector a
-{-# INLINE unsafeAccumulate #-}
-unsafeAccumulate = G.unsafeAccumulate
-
--- | TODO unsafeAccumulate_
-unsafeAccumulate_
-  :: (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
-{-# INLINE unsafeAccumulate_ #-}
-unsafeAccumulate_ = G.unsafeAccumulate_
-
--- | TODO accum
-accum :: (a -> b -> a) -> Vector a -> [(Int,b)] -> Vector a
-{-# INLINE accum #-}
-accum = G.accum
-
--- | TODO accumulate
-accumulate :: (a -> b -> a) -> Vector a -> Vector (Int,b) -> Vector a
-{-# INLINE accumulate #-}
-accumulate = G.accumulate
-
--- | TODO accumulate_
-accumulate_ :: (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
-{-# INLINE accumulate_ #-}
-accumulate_ = G.accumulate_
-
--- | TODO unsafeUpd
-unsafeUpd :: Vector a -> [(Int, a)] -> Vector a
-{-# INLINE unsafeUpd #-}
-unsafeUpd = G.unsafeUpd
-
--- | TODO unsafeUpdate
-unsafeUpdate :: Vector a -> Vector (Int, a) -> Vector a
-{-# INLINE unsafeUpdate #-}
-unsafeUpdate = G.unsafeUpdate
-
--- | TODO unsafeUpdate_
-unsafeUpdate_ :: Vector a -> Vector Int -> Vector a -> Vector a
-{-# INLINE unsafeUpdate_ #-}
-unsafeUpdate_ = G.unsafeUpdate_
-
--- | TODO (//)
-(//) :: Vector a -> [(Int, a)] -> Vector a
-{-# INLINE (//) #-}
-(//) = (G.//)
-
--- | TODO update
-update :: Vector a -> Vector (Int, a) -> Vector a
-{-# INLINE update #-}
-update = G.update
-
--- | TODO update_
-update_ :: Vector a -> Vector Int -> Vector a -> Vector a
-{-# INLINE update_ #-}
-update_ = G.update_
-
--- | backpermute, courtesy Blelloch. The back-permute is a gather\/get operation.
-backpermute :: Vector a -> Vector Int -> Vector a
-{-# INLINE backpermute #-}
-backpermute = G.backpermute
-
--- | TODO unsafeBackpermute
-unsafeBackpermute :: Vector a -> Vector Int -> Vector a
-{-# INLINE unsafeBackpermute #-}
-unsafeBackpermute = G.unsafeBackpermute
-
--- | /O(n)/, reverse the elements of the given vector.
-reverse :: Vector a -> Vector a
-{-# INLINE reverse #-}
-reverse = G.reverse
-
--- Mapping
--- -------
-
--- | /O(n)/, Map a function over a vector
-map :: (a -> b) -> Vector a -> Vector b
-{-# INLINE map #-}
-map = G.map
-
--- | /O(n)/, Apply a function to every index/value pair yielding a new vector
-imap :: (Int -> a -> b) -> Vector a -> Vector b
-{-# INLINE imap #-}
-imap = G.imap
-
--- | /O(n)/, generate a vector from each element of the input vector, then join the results.
-concatMap :: (a -> Vector b) -> Vector a -> Vector b
-{-# INLINE concatMap #-}
-concatMap = G.concatMap
-
--- Zipping/unzipping
--- -----------------
-
--- |/O(n)/, Zip two vectors with the given function.
-zipWith :: (a -> b -> c) -> Vector a -> Vector b -> Vector c
-{-# INLINE zipWith #-}
-zipWith = G.zipWith
-
--- |/O(n)/, Zip three vectors with the given function.
-zipWith3 :: (a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
-{-# INLINE zipWith3 #-}
-zipWith3 = G.zipWith3
-
--- |/O(n)/, Zip four vectors with the given function.
-zipWith4 :: (a -> b -> c -> d -> e)
-          -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
-{-# INLINE zipWith4 #-}
-zipWith4 = G.zipWith4
-
--- |/O(n)/, Zip five vectors with the given function.
-zipWith5 :: (a -> b -> c -> d -> e -> f)
-          -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
-          -> Vector f
-{-# INLINE zipWith5 #-}
-zipWith5 = G.zipWith5
-
--- |/O(n)/, Zip six vectors with the given function.
-zipWith6 :: (a -> b -> c -> d -> e -> f -> g)
-          -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
-          -> Vector f -> Vector g
-{-# INLINE zipWith6 #-}
-zipWith6 = G.zipWith6
-
--- |/O(n)/, Zip two vectors and their indices with the given function.
-izipWith :: (Int -> a -> b -> c) -> Vector a -> Vector b -> Vector c
-{-# INLINE izipWith #-}
-izipWith = G.izipWith
-
--- |/O(n)/, Zip three vectors and their indices with the given function.
-izipWith3 :: (Int -> a -> b -> c -> d)
-          -> Vector a -> Vector b -> Vector c -> Vector d
-{-# INLINE izipWith3 #-}
-izipWith3 = G.izipWith3
-
--- |/O(n)/, Zip four vectors and their indices with the given function.
-izipWith4 :: (Int -> a -> b -> c -> d -> e)
-          -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
-{-# INLINE izipWith4 #-}
-izipWith4 = G.izipWith4
-
--- |/O(n)/, Zip five vectors and their indices with the given function.
-izipWith5 :: (Int -> a -> b -> c -> d -> e -> f)
-          -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
-          -> Vector f
-{-# INLINE izipWith5 #-}
-izipWith5 = G.izipWith5
-
--- |/O(n)/, Zip six vectors and their indices with the given function.
-izipWith6 :: (Int -> a -> b -> c -> d -> e -> f -> g)
-          -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
-          -> Vector f -> Vector g
-{-# INLINE izipWith6 #-}
-izipWith6 = G.izipWith6
-
--- | Elementwise pairing of array elements. 
-zip :: Vector a -> Vector b -> Vector (a, b)
-{-# INLINE zip #-}
-zip = G.zip
-
--- | zip together three vectors into a vector of triples
-zip3 :: Vector a -> Vector b -> Vector c -> Vector (a, b, c)
-{-# INLINE zip3 #-}
-zip3 = G.zip3
-
-zip4 :: Vector a -> Vector b -> Vector c -> Vector d
-     -> Vector (a, b, c, d)
-{-# INLINE zip4 #-}
-zip4 = G.zip4
-
-zip5 :: Vector a -> Vector b -> Vector c -> Vector d -> Vector e
-     -> Vector (a, b, c, d, e)
-{-# INLINE zip5 #-}
-zip5 = G.zip5
-
-zip6 :: Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f
-     -> Vector (a, b, c, d, e, f)
-{-# INLINE zip6 #-}
-zip6 = G.zip6
-
--- | Elementwise unpairing of array elements.
-unzip :: Vector (a, b) -> (Vector a, Vector b)
-{-# INLINE unzip #-}
-unzip = G.unzip
-
-unzip3 :: Vector (a, b, c) -> (Vector a, Vector b, Vector c)
-{-# INLINE unzip3 #-}
-unzip3 = G.unzip3
-
-unzip4 :: Vector (a, b, c, d) -> (Vector a, Vector b, Vector c, Vector d)
-{-# INLINE unzip4 #-}
-unzip4 = G.unzip4
-
-unzip5 :: Vector (a, b, c, d, e)
-       -> (Vector a, Vector b, Vector c, Vector d, Vector e)
-{-# INLINE unzip5 #-}
-unzip5 = G.unzip5
-
-unzip6 :: Vector (a, b, c, d, e, f)
-       -> (Vector a, Vector b, Vector c, Vector d, Vector e, Vector f)
-{-# INLINE unzip6 #-}
-unzip6 = G.unzip6
-
--- Filtering
--- ---------
-
--- |/O(n)/, Remove elements from the vector which do not satisfy the predicate
-filter :: (a -> Bool) -> Vector a -> Vector a
-{-# INLINE filter #-}
-filter = G.filter
-
--- |/O(n)/, Drop elements that do not satisfy the predicate (applied to values and
--- their indices)
-ifilter :: (Int -> a -> Bool) -> Vector a -> Vector a
-{-# INLINE ifilter #-}
-ifilter = G.ifilter
-
--- |/O(n)/, Yield the longest prefix of elements satisfying the predicate.
-takeWhile :: (a -> Bool) -> Vector a -> Vector a
-{-# INLINE takeWhile #-}
-takeWhile = G.takeWhile
-
--- |/O(n)/, Drop the longest prefix of elements that satisfy the predicate.
-dropWhile :: (a -> Bool) -> Vector a -> Vector a
-{-# INLINE dropWhile #-}
-dropWhile = G.dropWhile
-
--- | Split the vector in two parts, the first one containing those elements
--- that satisfy the predicate and the second one those that don't. The
--- relative order of the elements is preserved at the cost of a (sometimes)
--- reduced performance compared to 'unstablePartition'.
-partition :: (a -> Bool) -> Vector a -> (Vector a, Vector a)
-{-# INLINE partition #-}
-partition = G.partition
-
--- |/O(n)/, Split the vector in two parts, the first one containing those elements
--- that satisfy the predicate and the second one those that don't. The order
--- of the elements is not preserved.
-unstablePartition :: (a -> Bool) -> Vector a -> (Vector a, Vector a)
-{-# INLINE unstablePartition #-}
-unstablePartition = G.unstablePartition
-
--- |/O(n)/, Split the vector into the longest prefix of elements that satisfy the
--- predicate and the rest.
-span :: (a -> Bool) -> Vector a -> (Vector a, Vector a)
-{-# INLINE span #-}
-span = G.span
-
--- | Split the vector into the longest prefix of elements that do not satisfy
--- the predicate and the rest.
-break :: (a -> Bool) -> Vector a -> (Vector a, Vector a)
-{-# INLINE break #-}
-break = G.break
-
--- Searching
--- ---------
-
-infix 4 `elem`
--- | Check whether the vector contains an element
-elem :: Eq a => a -> Vector a -> Bool
-{-# INLINE elem #-}
-elem = G.elem
-
-infix 4 `notElem`
--- | Inverse of `elem`
-notElem :: Eq a => a -> Vector a -> Bool
-{-# INLINE 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 = 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 = G.findIndex
-
--- | Yield the indices of elements satisfying the predicate
-findIndices :: (a -> Bool) -> Vector a -> Vector Int
-{-# INLINE findIndices #-}
-findIndices = G.findIndices
-
--- | Yield 'Just' the index of the first occurence of the given element or
--- 'Nothing' if the vector does not contain the element
-elemIndex :: Eq a => a -> Vector a -> Maybe Int
-{-# INLINE elemIndex #-}
-elemIndex = G.elemIndex
-
--- | Yield the indices of all occurences of the given element
-elemIndices :: Eq a => a -> Vector a -> Vector Int
-{-# INLINE elemIndices #-}
-elemIndices = G.elemIndices
-
--- Folding
--- -------
-
--- | Left fold
-foldl :: (a -> b -> a) -> a -> Vector b -> a
-{-# INLINE foldl #-}
-foldl = G.foldl
-
--- | Left fold on non-empty vectors
-foldl1 :: (a -> a -> a) -> Vector a -> a
-{-# INLINE foldl1 #-}
-foldl1 = G.foldl1
-
--- | Left fold with strict accumulator
-foldl' :: (a -> b -> a) -> a -> Vector b -> a
-{-# INLINE foldl' #-}
-foldl' = G.foldl'
-
--- | Left fold on non-empty vectors with strict accumulator
-foldl1' :: (a -> a -> a) -> Vector a -> a
-{-# INLINE foldl1' #-}
-foldl1' = G.foldl1'
-
--- | Right fold
-foldr :: (a -> b -> b) -> b -> Vector a -> b
-{-# INLINE foldr #-}
-foldr = G.foldr
-
--- | Right fold on non-empty vectors
-foldr1 :: (a -> a -> a) -> Vector a -> a
-{-# INLINE foldr1 #-}
-foldr1 = G.foldr1
-
--- | Right fold with a strict accumulator
-foldr' :: (a -> b -> b) -> b -> Vector a -> b
-{-# INLINE foldr' #-}
-foldr' = G.foldr'
-
--- | Right fold on non-empty vectors with strict accumulator
-foldr1' :: (a -> a -> a) -> Vector a -> a
-{-# INLINE foldr1' #-}
-foldr1' = G.foldr1'
-
--- | Left fold (function applied to each element and its index)
-ifoldl :: (a -> Int -> b -> a) -> a -> Vector b -> a
-{-# INLINE ifoldl #-}
-ifoldl = G.ifoldl
-
--- | Left fold with strict accumulator (function applied to each element and
--- its index)
-ifoldl' :: (a -> Int -> b -> a) -> a -> Vector b -> a
-{-# INLINE ifoldl' #-}
-ifoldl' = G.ifoldl'
-
--- | Right fold (function applied to each element and its index)
-ifoldr :: (Int -> a -> b -> b) -> b -> Vector a -> b
-{-# INLINE ifoldr #-}
-ifoldr = G.ifoldr
-
--- | Right fold with strict accumulator (function applied to each element and
--- its index)
-ifoldr' :: (Int -> a -> b -> b) -> b -> Vector a -> b
-{-# INLINE ifoldr' #-}
-ifoldr' = G.ifoldr'
-
--- Specialised folds
--- -----------------
-
--- |/O(n)/. @'all' p u@ determines whether all elements in array @u@ satisfy 
--- predicate @p@.
-all :: (a -> Bool) -> Vector a -> Bool
-{-# INLINE all #-}
-all = G.all
-
--- |/O(n)/. @'any' p u@ determines whether any element in array @u@ satisfies
--- predicate @p@.
-any :: (a -> Bool) -> Vector a -> Bool
-{-# INLINE any #-}
-any = G.any
-
--- |/O(n)/. 'and' yields the conjunction of a boolean array.
-and :: Vector Bool -> Bool
-{-# INLINE and #-}
-and = G.and
-
--- |/O(n)/. 'or' yields the disjunction of a boolean array.
-or :: Vector Bool -> Bool
-{-# INLINE or #-}
-or = G.or
-
--- |/O(n)/. 'sum' computes the sum (with @(+)@) of an array of elements.
-sum :: Num a => Vector a -> a
-{-# INLINE sum #-}
-sum = G.sum
-
--- |/O(n)/. 'sum' computes the product (with @(*)@) of an array of elements.
-product :: Num a => Vector a -> a
-{-# INLINE product #-}
-product = G.product
-
--- |/O(n)/. 'maximum' finds the maximum element in an array of orderable elements.
-maximum :: Ord a => Vector a -> a
-{-# INLINE maximum #-}
-maximum = G.maximum
-
--- |/O(n)/. 'maximumBy' finds the maximum element in an array under the given ordering.
-maximumBy :: (a -> a -> Ordering) -> Vector a -> a
-{-# INLINE maximumBy #-}
-maximumBy = G.maximumBy
-
--- |/O(n)/. 'minimum' finds the minimum element in an array of orderable elements.
-minimum :: Ord a => Vector a -> a
-{-# INLINE minimum #-}
-minimum = G.minimum
-
--- |/O(n)/. 'minimumBy' finds the minimum element in an array under the given ordering.
-minimumBy :: (a -> a -> Ordering) -> Vector a -> a
-{-# INLINE minimumBy #-}
-minimumBy = G.minimumBy
-
--- | TODO maxIndex
-maxIndex :: Ord a => Vector a -> Int
-{-# INLINE maxIndex #-}
-maxIndex = G.maxIndex
-
--- | TODO maxIndexBy
-maxIndexBy :: (a -> a -> Ordering) -> Vector a -> Int
-{-# INLINE maxIndexBy #-}
-maxIndexBy = G.maxIndexBy
-
--- | TODO minIndex
-minIndex :: Ord a => Vector a -> Int
-{-# INLINE minIndex #-}
-minIndex = G.minIndex
-
--- | TODO minIndexBy
-minIndexBy :: (a -> a -> Ordering) -> Vector a -> Int
-{-# INLINE minIndexBy #-}
-minIndexBy = G.minIndexBy
-
--- Unfolding
--- ---------
-
--- | The 'unfoldr' function is a \`dual\' to 'foldr': while 'foldr'
--- reduces a vector to a summary value, 'unfoldr' builds a list from
--- a seed value.  The function takes the element and returns 'Nothing'
--- if it is done generating the vector or returns 'Just' @(a,b)@, in which
--- case, @a@ is a prepended to the vector and @b@ is used as the next
--- element in a recursive call.
---
--- A simple use of unfoldr:
---
--- > unfoldr (\b -> if b == 0 then Nothing else Just (b, b-1)) 10
--- >  [10,9,8,7,6,5,4,3,2,1]
---
-unfoldr :: (b -> Maybe (a, b)) -> b -> Vector a
-{-# INLINE unfoldr #-}
-unfoldr = G.unfoldr
-
--- | Unfold at most @n@ elements
-unfoldrN :: Int -> (b -> Maybe (a, b)) -> b -> Vector a
-{-# INLINE unfoldrN #-}
-unfoldrN = G.unfoldrN
-
--- Scans
--- -----
-
--- | Prefix scan
-prescanl :: (a -> b -> a) -> a -> Vector b -> Vector a
-{-# INLINE prescanl #-}
-prescanl = G.prescanl
-
--- | Prefix scan with strict accumulator
-prescanl' :: (a -> b -> a) -> a -> Vector b -> Vector a
-{-# INLINE prescanl' #-}
-prescanl' = G.prescanl'
-
--- | Suffix scan
-postscanl :: (a -> b -> a) -> a -> Vector b -> Vector a
-{-# INLINE postscanl #-}
-postscanl = G.postscanl
-
--- | Suffix scan with strict accumulator
-postscanl' :: (a -> b -> a) -> a -> Vector b -> Vector a
-{-# INLINE postscanl' #-}
-postscanl' = G.postscanl'
-
--- | Haskell-style scan function.
-scanl :: (a -> b -> a) -> a -> Vector b -> Vector a
-{-# INLINE scanl #-}
-scanl = G.scanl
-
--- | Haskell-style scan with strict accumulator
-scanl' :: (a -> b -> a) -> a -> Vector b -> Vector a
-{-# INLINE scanl' #-}
-scanl' = G.scanl'
-
--- | Scan over a non-empty 'Vector'
-scanl1 :: (a -> a -> a) -> Vector a -> Vector a
-{-# INLINE 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' = G.scanl1'
-
--- | Prefix right-to-left scan
-prescanr :: (a -> b -> b) -> b -> Vector a -> Vector b
-{-# INLINE prescanr #-}
-prescanr = G.prescanr
-
--- | Prefix right-to-left scan with strict accumulator
-prescanr' :: (a -> b -> b) -> b -> Vector a -> Vector b
-{-# INLINE prescanr' #-}
-prescanr' = G.prescanr'
-
--- | Suffix right-to-left scan
-postscanr :: (a -> b -> b) -> b -> Vector a -> Vector b
-{-# INLINE postscanr #-}
-postscanr = G.postscanr
-
--- | Suffix right-to-left scan with strict accumulator
-postscanr' :: (a -> b -> b) -> b -> Vector a -> Vector b
-{-# INLINE postscanr' #-}
-postscanr' = G.postscanr'
-
--- | Haskell-style right-to-left scan
-scanr :: (a -> b -> b) -> b -> Vector a -> Vector b
-{-# INLINE scanr #-}
-scanr = G.scanr
-
--- | Haskell-style right-to-left scan with strict accumulator
-scanr' :: (a -> b -> b) -> b -> Vector a -> Vector b
-{-# INLINE scanr' #-}
-scanr' = G.scanr'
-
--- | Right-to-left scan over a non-empty vector
-scanr1 :: (a -> a -> a) -> Vector a -> Vector a
-{-# INLINE scanr1 #-}
-scanr1 = G.scanr1
-
--- | Right-to-left scan over a non-empty vector with a strict accumulator
-scanr1' :: (a -> a -> a) -> Vector a -> Vector a
-{-# INLINE scanr1' #-}
-scanr1' = G.scanr1'
-
--- Enumeration
--- -----------
-
--- | Yield a vector of the given length containing the values @x@, @x+1@ etc.
--- This operation is usually more efficient than 'enumFromTo'.
-enumFromN :: Num a => a -> Int -> Vector a
-{-# INLINE enumFromN #-}
-enumFromN = G.enumFromN
-
--- | Yield a vector of the given length containing the values @x@, @x+y@,
--- @x+y+y@ etc. This operations is usually more efficient than
--- 'enumFromThenTo'.
-enumFromStepN :: Num a => a -> a -> Int -> Vector a
-{-# INLINE enumFromStepN #-}
-enumFromStepN = G.enumFromStepN
-
--- | Enumerate values from @x@ to @y@.
---
--- /WARNING:/ This operation can be very inefficient. If at all possible, use
--- 'enumFromN' instead.
-enumFromTo :: Enum a => a -> a -> Vector a
-{-# INLINE enumFromTo #-}
-enumFromTo = G.enumFromTo
-
--- | Enumerate values from @x@ to @y@ with a specific step @z@.
---
--- /WARNING:/ This operation can be very inefficient. If at all possible, use
--- 'enumFromStepN' instead.
-enumFromThenTo :: Enum a => a -> a -> a -> Vector a
-{-# INLINE enumFromThenTo #-}
-enumFromThenTo = G.enumFromThenTo
-
--- Conversion to/from lists
--- ------------------------
-
--- | Convert a vector to a list
-toList :: Vector a -> [a]
-{-# INLINE toList #-}
-toList = G.toList
-
--- | Convert a list to a vector
-fromList :: [a] -> Vector a
-{-# INLINE fromList #-}
-fromList = G.fromList
-
--- | Convert the first @n@ elements of a list to a vector
---
--- > fromListN n xs = fromList (take n xs)
-fromListN :: Int -> [a] -> Vector a
-{-# INLINE fromListN #-}
-fromListN = G.fromListN
-
--- Monadic operations
--- ------------------
-
--- | Perform the monadic action the given number of times and store the
--- results in a vector.
-replicateM :: Monad m => Int -> m a -> m (Vector a)
-{-# INLINE replicateM #-}
-replicateM = G.replicateM
-
--- | Apply the monadic action to all elements of the vector, yielding a vector
--- of results
-mapM :: Monad m => (a -> m b) -> Vector a -> m (Vector b)
-{-# INLINE mapM #-}
-mapM = G.mapM
-
--- | Apply the monadic action to all elements of a vector and ignore the
--- results
-mapM_ :: Monad m => (a -> m b) -> Vector a -> m ()
-{-# INLINE mapM_ #-}
-mapM_ = G.mapM_
-
--- | Apply the monadic action to all elements of the vector, yielding a vector
--- of results
-forM :: Monad m => Vector a -> (a -> m b) -> m (Vector b)
-{-# INLINE forM #-}
-forM = G.forM
-
--- | Apply the monadic action to all elements of a vector and ignore the
--- results
-forM_ :: Monad m => Vector a -> (a -> m b) -> m ()
-{-# INLINE forM_ #-}
-forM_ = G.forM_
-
--- | Zip the two vectors with the monadic action and yield a vector of results
-zipWithM :: Monad m
-         => (a -> b -> m c) -> Vector a -> Vector b -> m (Vector c)
-{-# INLINE zipWithM #-}
-zipWithM = G.zipWithM
-
--- | Zip the two vectors with the monadic action and ignore the results
-zipWithM_ :: Monad m
-          => (a -> b -> m c) -> Vector a -> Vector b -> m ()
-{-# INLINE zipWithM_ #-}
-zipWithM_ = G.zipWithM_
-
--- | Drop elements that do not satisfy the monadic predicate
-filterM :: Monad m => (a -> m Bool) -> Vector a -> m (Vector a)
-{-# INLINE filterM #-}
-filterM = G.filterM
-
--- | Monadic fold
-foldM :: Monad m => (a -> b -> m a) -> a -> Vector b -> m a
-{-# INLINE foldM #-}
-foldM = G.foldM
-
--- | Monadic fold over non-empty vectors
-fold1M :: Monad m => (a -> a -> m a) -> Vector a -> m a
-{-# INLINE fold1M #-}
-fold1M = G.fold1M
-
--- | Monadic fold with strict accumulator
-foldM' :: Monad m => (a -> b -> m a) -> a -> Vector b -> m a
-{-# INLINE foldM' #-}
-foldM' = G.foldM'
-
--- | Monad fold over non-empty vectors with strict accumulator
-fold1M' :: Monad m => (a -> a -> m a) -> Vector a -> m a
-{-# INLINE fold1M' #-}
-fold1M' = G.fold1M'
-
--- Destructive operations
--- ----------------------
-
--- | Destructively initialise a vector.
-create :: (forall s. ST s (MVector s a)) -> Vector a
-{-# INLINE create #-}
-create = G.create
-
--- | Apply a destructive operation to a vector. The operation is applied to a
--- copy of the vector unless it can be safely performed in place.
-modify :: (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a
-{-# INLINE modify #-}
-modify = G.modify
-
--- | Copy an immutable vector into a mutable one. The two vectors must have
--- the same length. This is not checked.
-unsafeCopy :: PrimMonad m => MVector (PrimState m) a -> Vector a -> m ()
-{-# INLINE unsafeCopy #-}
-unsafeCopy = G.unsafeCopy
-           
--- | Copy an immutable vector into a mutable one. The two vectors must have the
--- same length.
+  -- * Boxed vectors
+  Vector, MVector,
+
+  -- * Accessors
+
+  -- ** Length information
+  length, null,
+
+  -- ** Indexing
+  (!), head, last,
+  unsafeIndex, unsafeHead, unsafeLast,
+
+  -- ** Monadic indexing
+  indexM, headM, lastM,
+  unsafeIndexM, unsafeHeadM, unsafeLastM,
+
+  -- ** Extracting subvectors (slicing)
+  slice, init, tail, take, drop,
+  unsafeSlice, unsafeInit, unsafeTail, unsafeTake, unsafeDrop,
+
+  -- * Construction
+
+  -- ** Initialisation
+  empty, singleton, replicate, generate,
+
+  -- ** Monadic initialisation
+  replicateM, create,
+
+  -- ** Unfolding
+  unfoldr, unfoldrN,
+
+  -- ** Enumeration
+  enumFromN, enumFromStepN, enumFromTo, enumFromThenTo,
+
+  -- ** Concatenation
+  cons, snoc, (++),
+
+  -- ** Restricting memory usage
+  force,
+
+  -- * Modifying vectors
+
+  -- ** Bulk updates
+  (//), update, update_,
+  unsafeUpd, unsafeUpdate, unsafeUpdate_,
+
+  -- ** Accumulations
+  accum, accumulate, accumulate_,
+  unsafeAccum, unsafeAccumulate, unsafeAccumulate_,
+
+  -- ** Permutations 
+  reverse, backpermute, unsafeBackpermute,
+
+  -- ** Safe destructive updates
+  modify,
+
+  -- * Elementwise operations
+
+  -- ** Mapping
+  map, imap, concatMap,
+
+  -- ** Monadic mapping
+  mapM, mapM_, forM, forM_,
+
+  -- ** Zipping
+  zipWith, zipWith3, zipWith4, zipWith5, zipWith6,
+  izipWith, izipWith3, izipWith4, izipWith5, izipWith6,
+  zip, zip3, zip4, zip5, zip6,
+
+  -- ** Monadic zipping
+  zipWithM, zipWithM_,
+
+  -- ** Unzipping
+  unzip, unzip3, unzip4, unzip5, unzip6,
+
+  -- * Working with predicates
+
+  -- ** Filtering
+  filter, ifilter, filterM,
+  takeWhile, dropWhile,
+
+  -- ** Partitioning
+  partition, unstablePartition, span, break,
+
+  -- ** Searching
+  elem, notElem, find, findIndex, findIndices, elemIndex, elemIndices,
+
+  -- * Folding
+  foldl, foldl1, foldl', foldl1', foldr, foldr1, foldr', foldr1',
+  ifoldl, ifoldl', ifoldr, ifoldr',
+
+  -- ** Specialised folds
+  all, any, and, or,
+  sum, product,
+  maximum, maximumBy, minimum, minimumBy,
+  minIndex, minIndexBy, maxIndex, maxIndexBy,
+
+  -- ** Monadic folds
+  foldM, foldM', fold1M, fold1M',
+
+  -- * Prefix sums (scans)
+  prescanl, prescanl',
+  postscanl, postscanl',
+  scanl, scanl', scanl1, scanl1',
+  prescanr, prescanr',
+  postscanr, postscanr',
+  scanr, scanr', scanr1, scanr1',
+
+  -- * Conversions
+
+  -- ** Lists
+  toList, fromList, fromListN,
+
+  -- ** Mutable vectors
+  copy, unsafeCopy
+) where
+
+import qualified Data.Vector.Generic as G
+import           Data.Vector.Mutable  ( MVector(..) )
+import           Data.Primitive.Array
+import qualified Data.Vector.Fusion.Stream as Stream
+
+import Control.Monad ( liftM )
+import Control.Monad.ST ( ST )
+import Control.Monad.Primitive
+
+import Prelude hiding ( length, null,
+                        replicate, (++),
+                        head, last,
+                        init, tail, take, drop, reverse,
+                        map, concatMap,
+                        zipWith, zipWith3, zip, zip3, unzip, unzip3,
+                        filter, takeWhile, dropWhile, span, break,
+                        elem, notElem,
+                        foldl, foldl1, foldr, foldr1,
+                        all, any, and, or, sum, product, minimum, maximum,
+                        scanl, scanl1, scanr, scanr1,
+                        enumFromTo, enumFromThenTo,
+                        mapM, mapM_ )
+
+import qualified Prelude
+
+import Data.Typeable ( Typeable )
+import Data.Data     ( Data(..) )
+
+-- | Boxed vectors, supporting efficient slicing.
+data Vector a = Vector {-# UNPACK #-} !Int
+                       {-# UNPACK #-} !Int
+                       {-# UNPACK #-} !(Array a)
+        deriving ( Typeable )
+
+instance Show a => Show (Vector a) where
+    show = (Prelude.++ " :: Data.Vector.Vector") . ("fromList " Prelude.++) . show . toList
+
+instance Data a => Data (Vector a) where
+  gfoldl       = G.gfoldl
+  toConstr _   = error "toConstr"
+  gunfold _ _  = error "gunfold"
+  dataTypeOf _ = G.mkType "Data.Vector.Vector"
+  dataCast1    = G.dataCast
+
+type instance G.Mutable Vector = MVector
+
+instance G.Vector Vector a where
+  {-# INLINE unsafeFreeze #-}
+  unsafeFreeze (MVector i n marr)
+    = Vector i n `liftM` unsafeFreezeArray marr
+
+  {-# INLINE basicLength #-}
+  basicLength (Vector _ n _) = n
+
+  {-# INLINE basicUnsafeSlice #-}
+  basicUnsafeSlice j n (Vector i _ arr) = Vector (i+j) n arr
+
+  {-# INLINE basicUnsafeIndexM #-}
+  basicUnsafeIndexM (Vector i _ arr) j = indexArrayM arr (i+j)
+
+-- See http://trac.haskell.org/vector/ticket/12
+instance Eq a => Eq (Vector a) where
+  {-# INLINE (==) #-}
+  xs == ys = Stream.eq (G.stream xs) (G.stream ys)
+
+  {-# INLINE (/=) #-}
+  xs /= ys = not (Stream.eq (G.stream xs) (G.stream ys))
+
+-- See http://trac.haskell.org/vector/ticket/12
+instance Ord a => Ord (Vector a) where
+  {-# INLINE compare #-}
+  compare xs ys = Stream.cmp (G.stream xs) (G.stream ys)
+
+  {-# INLINE (<) #-}
+  xs < ys = Stream.cmp (G.stream xs) (G.stream ys) == LT
+
+  {-# INLINE (<=) #-}
+  xs <= ys = Stream.cmp (G.stream xs) (G.stream ys) /= GT
+
+  {-# INLINE (>) #-}
+  xs > ys = Stream.cmp (G.stream xs) (G.stream ys) == GT
+
+  {-# INLINE (>=) #-}
+  xs >= ys = Stream.cmp (G.stream xs) (G.stream ys) /= LT
+
+-- Length information
+-- ------------------
+
+-- | /O(1)/ Yield the length of the vector.
+length :: Vector a -> Int
+{-# INLINE length #-}
+length = G.length
+
+-- | /O(1)/ Test whether a vector if empty
+null :: Vector a -> Bool
+{-# INLINE null #-}
+null = G.null
+
+-- Indexing
+-- --------
+
+-- | O(1) Indexing
+(!) :: Vector a -> Int -> a
+{-# INLINE (!) #-}
+(!) = (G.!)
+
+-- | /O(1)/ First element
+head :: Vector a -> a
+{-# INLINE head #-}
+head = G.head
+
+-- | /O(1)/ Last element
+last :: Vector a -> a
+{-# INLINE last #-}
+last = G.last
+
+-- | /O(1)/ Unsafe indexing without bounds checking
+unsafeIndex :: Vector a -> Int -> a
+{-# INLINE unsafeIndex #-}
+unsafeIndex = G.unsafeIndex
+
+-- | /O(1)/ First element without checking if the vector is empty
+unsafeHead :: Vector a -> a
+{-# INLINE unsafeHead #-}
+unsafeHead = G.unsafeHead
+
+-- | /O(1)/ Last element without checking if the vector is empty
+unsafeLast :: Vector a -> a
+{-# INLINE unsafeLast #-}
+unsafeLast = G.unsafeLast
+
+-- Monadic indexing
+-- ----------------
+
+-- | /O(1)/ Indexing in a monad.
+--
+-- The monad allows operations to be strict in the vector when necessary.
+-- Suppose vector copying is implemented like this:
+--
+-- > copy mv v = ... write mv i (v ! i) ...
+--
+-- For lazy vectors, @v ! i@ would not be evaluated which means that @mv@
+-- would unnecessarily retain a reference to @v@ in each element written.
+--
+-- With 'indexM', copying can be implemented like this instead:
+--
+-- > copy mv v = ... do
+-- >                   x <- indexM v i
+-- >                   write mv i x
+--
+-- Here, no references to @v@ are retained because indexing (but /not/ the
+-- elements) is evaluated eagerly.
+--
+indexM :: Monad m => Vector a -> Int -> m a
+{-# INLINE indexM #-}
+indexM = G.indexM
+
+-- | /O(1)/ First element of a vector in a monad. See 'indexM' for an
+-- explanation of why this is useful.
+headM :: Monad m => Vector a -> m a
+{-# INLINE headM #-}
+headM = G.headM
+
+-- | /O(1)/ Last element of a vector in a monad. See 'indexM' for an
+-- explanation of why this is useful.
+lastM :: Monad m => Vector a -> m a
+{-# INLINE lastM #-}
+lastM = G.lastM
+
+-- | /O(1)/ Indexing in a monad without bounds checks. See 'indexM' for an
+-- explanation of why this is useful.
+unsafeIndexM :: Monad m => Vector a -> Int -> m a
+{-# INLINE unsafeIndexM #-}
+unsafeIndexM = G.unsafeIndexM
+
+-- | /O(1)/ First element in a monad without checking for empty vectors.
+-- See 'indexM' for an explanation of why this is useful.
+unsafeHeadM :: Monad m => Vector a -> m a
+{-# INLINE unsafeHeadM #-}
+unsafeHeadM = G.unsafeHeadM
+
+-- | /O(1)/ Last element in a monad without checking for empty vectors.
+-- See 'indexM' for an explanation of why this is useful.
+unsafeLastM :: Monad m => Vector a -> m a
+{-# INLINE unsafeLastM #-}
+unsafeLastM = G.unsafeLastM
+
+-- Extracting subvectors (slicing)
+-- -------------------------------
+
+-- | /O(1)/ Yield a slice of the vector without copying it. The vector must
+-- contain at least @i+n@ elements.
+slice :: Int   -- ^ @i@ starting index
+                 -> Int   -- ^ @n@ length
+                 -> Vector a
+                 -> Vector a
+{-# INLINE slice #-}
+slice = G.slice
+
+-- | /O(1)/ Yield all but the last element without copying. The vector may not
+-- be empty.
+init :: Vector a -> Vector a
+{-# INLINE init #-}
+init = G.init
+
+-- | /O(1)/ Yield all but the first element without copying. The vector may not
+-- be empty.
+tail :: Vector a -> Vector a
+{-# INLINE tail #-}
+tail = G.tail
+
+-- | /O(1)/ Yield at the first @n@ elements without copying. The vector may
+-- contain less than @n@ elements in which case it is returned unchanged.
+take :: Int -> Vector a -> Vector a
+{-# INLINE take #-}
+take = G.take
+
+-- | /O(1)/ Yield all but the first @n@ elements without copying. The vector may
+-- contain less than @n@ elements in which case an empty vector is returned.
+drop :: Int -> Vector a -> Vector a
+{-# INLINE drop #-}
+drop = G.drop
+
+-- | /O(1)/ Yield a slice of the vector without copying. The vector must
+-- contain at least @i+n@ elements but this is not checked.
+unsafeSlice :: Int   -- ^ @i@ starting index
+                       -> Int   -- ^ @n@ length
+                       -> Vector a
+                       -> Vector a
+{-# INLINE unsafeSlice #-}
+unsafeSlice = G.unsafeSlice
+
+-- | /O(1)/ Yield all but the last element without copying. The vector may not
+-- be empty but this is not checked.
+unsafeInit :: Vector a -> Vector a
+{-# INLINE unsafeInit #-}
+unsafeInit = G.unsafeInit
+
+-- | /O(1)/ Yield all but the first element without copying. The vector may not
+-- be empty but this is not checked.
+unsafeTail :: Vector a -> Vector a
+{-# INLINE unsafeTail #-}
+unsafeTail = G.unsafeTail
+
+-- | /O(1)/ Yield the first @n@ elements without copying. The vector must
+-- contain at least @n@ elements but this is not checked.
+unsafeTake :: Int -> Vector a -> Vector a
+{-# INLINE unsafeTake #-}
+unsafeTake = G.unsafeTake
+
+-- | /O(1)/ Yield all but the first @n@ elements without copying. The vector
+-- must contain at least @n@ elements but this is not checked.
+unsafeDrop :: Int -> Vector a -> Vector a
+{-# INLINE unsafeDrop #-}
+unsafeDrop = G.unsafeDrop
+
+-- Initialisation
+-- --------------
+
+-- | /O(1)/ Empty vector
+empty :: Vector a
+{-# INLINE empty #-}
+empty = G.empty
+
+-- | /O(1)/ Vector with exactly one element
+singleton :: a -> Vector a
+{-# INLINE singleton #-}
+singleton = G.singleton
+
+-- | /O(n)/ Vector of the given length with the same value in each position
+replicate :: Int -> a -> Vector a
+{-# INLINE replicate #-}
+replicate = G.replicate
+
+-- | /O(n)/ Construct a vector of the given length by applying the function to
+-- each index
+generate :: Int -> (Int -> a) -> Vector a
+{-# INLINE generate #-}
+generate = G.generate
+
+-- Unfolding
+-- ---------
+
+-- | /O(n)/ Construct a vector by repeatedly applying the generator function
+-- to a seed. The generator function yields 'Just' the next element and the
+-- new seed or 'Nothing' if there are no more elements.
+--
+-- > unfoldr (\n -> if n == 0 then Nothing else Just (n,n-1)) 10
+-- >  = <10,9,8,7,6,5,4,3,2,1>
+unfoldr :: (b -> Maybe (a, b)) -> b -> Vector a
+{-# INLINE unfoldr #-}
+unfoldr = G.unfoldr
+
+-- | /O(n)/ Construct a vector with at most @n@ by repeatedly applying the
+-- generator function to the a seed. The generator function yields 'Just' the
+-- next element and the new seed or 'Nothing' if there are no more elements.
+--
+-- > unfoldrN 3 (\n -> Just (n,n-1)) 10 = <10,9,8>
+unfoldrN :: Int -> (b -> Maybe (a, b)) -> b -> Vector a
+{-# INLINE unfoldrN #-}
+unfoldrN = G.unfoldrN
+
+-- Enumeration
+-- -----------
+
+-- | /O(n)/ Yield a vector of the given length containing the values @x@, @x+1@
+-- etc. This operation is usually more efficient than 'enumFromTo'.
+--
+-- > enumFromN 5 3 = <5,6,7>
+enumFromN :: Num a => a -> Int -> Vector a
+{-# INLINE enumFromN #-}
+enumFromN = G.enumFromN
+
+-- | /O(n)/ Yield a vector of the given length containing the values @x@, @x+y@,
+-- @x+y+y@ etc. This operations is usually more efficient than 'enumFromThenTo'.
+--
+-- > enumFromStepN 1 0.1 5 = <1,1.1,1.2,1.3,1.4>
+enumFromStepN :: Num a => a -> a -> Int -> Vector a
+{-# INLINE enumFromStepN #-}
+enumFromStepN = G.enumFromStepN
+
+-- | /O(n)/ Enumerate values from @x@ to @y@.
+--
+-- /WARNING:/ This operation can be very inefficient. If at all possible, use
+-- 'enumFromN' instead.
+enumFromTo :: Enum a => a -> a -> Vector a
+{-# INLINE enumFromTo #-}
+enumFromTo = G.enumFromTo
+
+-- | /O(n)/ Enumerate values from @x@ to @y@ with a specific step @z@.
+--
+-- /WARNING:/ This operation can be very inefficient. If at all possible, use
+-- 'enumFromStepN' instead.
+enumFromThenTo :: Enum a => a -> a -> a -> Vector a
+{-# INLINE enumFromThenTo #-}
+enumFromThenTo = G.enumFromThenTo
+
+-- Concatenation
+-- -------------
+
+-- | /O(n)/ Prepend an element
+cons :: a -> Vector a -> Vector a
+{-# INLINE cons #-}
+cons = G.cons
+
+-- | /O(n)/ Append an element
+snoc :: Vector a -> a -> Vector a
+{-# INLINE snoc #-}
+snoc = G.snoc
+
+infixr 5 ++
+-- | /O(m+n)/ Concatenate two vectors
+(++) :: Vector a -> Vector a -> Vector a
+{-# INLINE (++) #-}
+(++) = (G.++)
+
+-- Monadic initialisation
+-- ----------------------
+
+-- | /O(n)/ Execute the monadic action the given number of times and store the
+-- results in a vector.
+replicateM :: Monad m => Int -> m a -> m (Vector a)
+{-# INLINE replicateM #-}
+replicateM = G.replicateM
+
+-- | Execute the monadic action and freeze the resulting vector.
+--
+-- @
+-- create (do { v \<- new 2; write v 0 \'a\'; write v 1 \'b\' }) = \<'a','b'\>
+-- @
+create :: (forall s. ST s (MVector s a)) -> Vector a
+{-# INLINE create #-}
+create = G.create
+
+
+
+-- Restricting memory usage
+-- ------------------------
+
+-- | /O(n)/ Yield the argument but force it not to retain any extra memory,
+-- possibly by copying it.
+--
+-- This is especially useful when dealing with slices. For example:
+--
+-- > force (slice 0 2 <huge vector>)
+--
+-- Here, the slice retains a reference to the huge vector. Forcing it creates
+-- a copy of just the elements that belong to the slice and allows the huge
+-- vector to be garbage collected.
+force :: Vector a -> Vector a
+{-# INLINE force #-}
+force = G.force
+
+-- Bulk updates
+-- ------------
+
+-- | /O(m+n)/ For each pair @(i,a)@ from the list, replace the vector
+-- element at position @i@ by @a@.
+--
+-- > <5,9,2,7> // [(2,1),(0,3),(2,8)] = <3,9,8,7>
+--
+(//) :: Vector a   -- ^ initial vector (of length @m@)
+                -> [(Int, a)] -- ^ list of index/value pairs (of length @n@) 
+                -> Vector a
+{-# INLINE (//) #-}
+(//) = (G.//)
+
+-- | /O(m+n)/ For each pair @(i,a)@ from the vector of index/value pairs,
+-- replace the vector element at position @i@ by @a@.
+--
+-- > update <5,9,2,7> <(2,1),(0,3),(2,8)> = <3,9,8,7>
+--
+update :: Vector a        -- ^ initial vector (of length @m@)
+       -> Vector (Int, a) -- ^ vector of index/value pairs (of length @n@)
+       -> Vector a
+{-# INLINE update #-}
+update = G.update
+
+-- | /O(m+min(n1,n2))/ For each index @i@ from the index vector and the
+-- corresponding value @a@ from the value vector, replace the element of the
+-- initial vector at position @i@ by @a@.
+--
+-- > update_ <5,9,2,7>  <2,0,2> <1,3,8> = <3,9,8,7>
+--
+-- The function 'update' provides the same functionality and is usually more
+-- convenient.
+--
+-- @
+-- update_ xs is ys = 'update' xs ('zip' is ys)
+-- @
+update_ :: Vector a   -- ^ initial vector (of length @m@)
+        -> Vector Int -- ^ index vector (of length @n1@)
+        -> Vector a   -- ^ value vector (of length @n2@)
+        -> Vector a
+{-# INLINE update_ #-}
+update_ = G.update_
+
+-- | Same as ('//') but without bounds checking.
+unsafeUpd :: Vector a -> [(Int, a)] -> Vector a
+{-# INLINE unsafeUpd #-}
+unsafeUpd = G.unsafeUpd
+
+-- | Same as 'update' but without bounds checking.
+unsafeUpdate :: Vector a -> Vector (Int, a) -> Vector a
+{-# INLINE unsafeUpdate #-}
+unsafeUpdate = G.unsafeUpdate
+
+-- | Same as 'update_' but without bounds checking.
+unsafeUpdate_ :: Vector a -> Vector Int -> Vector a -> Vector a
+{-# INLINE unsafeUpdate_ #-}
+unsafeUpdate_ = G.unsafeUpdate_
+
+-- Accumulations
+-- -------------
+
+-- | /O(m+n)/ For each pair @(i,b)@ from the list, replace the vector element
+-- @a@ at position @i@ by @f a b@.
+--
+-- > accum (+) <5,9,2> [(2,4),(1,6),(0,3),(1,7)] = <5+3, 9+6+7, 2+4>
+accum :: (a -> b -> a) -- ^ accumulating function @f@
+      -> Vector a      -- ^ initial vector (of length @m@)
+      -> [(Int,b)]     -- ^ list of index/value pairs (of length @n@)
+      -> Vector a
+{-# INLINE accum #-}
+accum = G.accum
+
+-- | /O(m+n)/ For each pair @(i,b)@ from the vector of pairs, replace the vector
+-- element @a@ at position @i@ by @f a b@.
+--
+-- > accumulate (+) <5,9,2> <(2,4),(1,6),(0,3),(1,7)> = <5+3, 9+6+7, 2+4>
+accumulate :: (a -> b -> a)  -- ^ accumulating function @f@
+            -> Vector a       -- ^ initial vector (of length @m@)
+            -> Vector (Int,b) -- ^ vector of index/value pairs (of length @n@)
+            -> Vector a
+{-# INLINE accumulate #-}
+accumulate = G.accumulate
+
+-- | /O(m+min(n1,n2))/ For each index @i@ from the index vector and the
+-- corresponding value @b@ from the the value vector,
+-- replace the element of the initial vector at
+-- position @i@ by @f a b@.
+--
+-- > accumulate_ (+) <5,9,2> <2,1,0,1> <4,6,3,7> = <5+3, 9+6+7, 2+4>
+--
+-- The function 'accumulate' provides the same functionality and is usually more
+-- convenient.
+--
+-- @
+-- accumulate_ f as is bs = 'accumulate' f as ('zip' is bs)
+-- @
+accumulate_ :: (a -> b -> a) -- ^ accumulating function @f@
+            -> Vector a      -- ^ initial vector (of length @m@)
+            -> Vector Int    -- ^ index vector (of length @n1@)
+            -> Vector b      -- ^ value vector (of length @n2@)
+            -> Vector a
+{-# INLINE accumulate_ #-}
+accumulate_ = G.accumulate_
+
+-- | Same as 'accum' but without bounds checking.
+unsafeAccum :: (a -> b -> a) -> Vector a -> [(Int,b)] -> Vector a
+{-# INLINE unsafeAccum #-}
+unsafeAccum = G.unsafeAccum
+
+-- | Same as 'accumulate' but without bounds checking.
+unsafeAccumulate :: (a -> b -> a) -> Vector a -> Vector (Int,b) -> Vector a
+{-# INLINE unsafeAccumulate #-}
+unsafeAccumulate = G.unsafeAccumulate
+
+-- | Same as 'accumulate_' but without bounds checking.
+unsafeAccumulate_
+  :: (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
+{-# INLINE unsafeAccumulate_ #-}
+unsafeAccumulate_ = G.unsafeAccumulate_
+
+-- Permutations
+-- ------------
+
+-- | /O(n)/ Reverse a vector
+reverse :: Vector a -> Vector a
+{-# INLINE reverse #-}
+reverse = G.reverse
+
+-- | /O(n)/ Yield the vector obtained by replacing each element @i@ of the
+-- index vector by @xs'!'i@. This is equivalent to @'map' (xs'!') is@ but is
+-- often much more efficient.
+--
+-- > backpermute <a,b,c,d> <0,3,2,3,1,0> = <a,d,c,d,b,a>
+backpermute :: Vector a -> Vector Int -> Vector a
+{-# INLINE backpermute #-}
+backpermute = G.backpermute
+
+-- | Same as 'backpermute' but without bounds checking.
+unsafeBackpermute :: Vector a -> Vector Int -> Vector a
+{-# INLINE unsafeBackpermute #-}
+unsafeBackpermute = G.unsafeBackpermute
+
+-- Safe destructive updates
+-- ------------------------
+
+-- | Apply a destructive operation to a vector. The operation will be
+-- performed in place if it is safe to do so and will modify a copy of the
+-- vector otherwise.
+--
+-- @
+-- modify (\\v -> write v 0 \'x\') ('replicate' 3 \'a\') = \<\'x\',\'a\',\'a\'\>
+-- @
+modify :: (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a
+{-# INLINE modify #-}
+modify = G.modify
+
+-- Mapping
+-- -------
+
+-- | /O(n)/ Map a function over a vector
+map :: (a -> b) -> Vector a -> Vector b
+{-# INLINE map #-}
+map = G.map
+
+-- | /O(n)/ Apply a function to every element of a vector and its index
+imap :: (Int -> a -> b) -> Vector a -> Vector b
+{-# INLINE imap #-}
+imap = G.imap
+
+-- | Map a function over a vector and concatenate the results.
+concatMap :: (a -> Vector b) -> Vector a -> Vector b
+{-# INLINE concatMap #-}
+concatMap = G.concatMap
+
+-- Monadic mapping
+-- ---------------
+
+-- | /O(n)/ Apply the monadic action to all elements of the vector, yielding a
+-- vector of results
+mapM :: Monad m => (a -> m b) -> Vector a -> m (Vector b)
+{-# INLINE mapM #-}
+mapM = G.mapM
+
+-- | /O(n)/ Apply the monadic action to all elements of a vector and ignore the
+-- results
+mapM_ :: Monad m => (a -> m b) -> Vector a -> m ()
+{-# INLINE mapM_ #-}
+mapM_ = G.mapM_
+
+-- | /O(n)/ Apply the monadic action to all elements of the vector, yielding a
+-- vector of results. Equvalent to @flip 'mapM'@.
+forM :: Monad m => Vector a -> (a -> m b) -> m (Vector b)
+{-# INLINE forM #-}
+forM = G.forM
+
+-- | /O(n)/ Apply the monadic action to all elements of a vector and ignore the
+-- results. Equivalent to @flip 'mapM_'@.
+forM_ :: Monad m => Vector a -> (a -> m b) -> m ()
+{-# INLINE forM_ #-}
+forM_ = G.forM_
+
+-- Zipping
+-- -------
+
+-- | /O(min(m,n))/ Zip two vectors with the given function.
+zipWith :: (a -> b -> c) -> Vector a -> Vector b -> Vector c
+{-# INLINE 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 = G.zipWith3
+
+zipWith4 :: (a -> b -> c -> d -> e)
+         -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
+{-# INLINE zipWith4 #-}
+zipWith4 = G.zipWith4
+
+zipWith5 :: (a -> b -> c -> d -> e -> f)
+         -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
+         -> Vector f
+{-# INLINE zipWith5 #-}
+zipWith5 = G.zipWith5
+
+zipWith6 :: (a -> b -> c -> d -> e -> f -> g)
+         -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
+         -> Vector f -> Vector g
+{-# INLINE zipWith6 #-}
+zipWith6 = G.zipWith6
+
+-- | /O(min(m,n))/ Zip two vectors with a function that also takes the
+-- elements' indices.
+izipWith :: (Int -> a -> b -> c) -> Vector a -> Vector b -> Vector c
+{-# INLINE izipWith #-}
+izipWith = G.izipWith
+
+-- | Zip three vectors and their indices with the given function.
+izipWith3 :: (Int -> a -> b -> c -> d)
+          -> Vector a -> Vector b -> Vector c -> Vector d
+{-# INLINE izipWith3 #-}
+izipWith3 = G.izipWith3
+
+izipWith4 :: (Int -> a -> b -> c -> d -> e)
+          -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
+{-# INLINE izipWith4 #-}
+izipWith4 = G.izipWith4
+
+izipWith5 :: (Int -> a -> b -> c -> d -> e -> f)
+          -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
+          -> Vector f
+{-# INLINE izipWith5 #-}
+izipWith5 = G.izipWith5
+
+izipWith6 :: (Int -> a -> b -> c -> d -> e -> f -> g)
+          -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
+          -> Vector f -> Vector g
+{-# INLINE izipWith6 #-}
+izipWith6 = G.izipWith6
+
+-- | Elementwise pairing of array elements. 
+zip :: Vector a -> Vector b -> Vector (a, b)
+{-# INLINE zip #-}
+zip = G.zip
+
+-- | zip together three vectors into a vector of triples
+zip3 :: Vector a -> Vector b -> Vector c -> Vector (a, b, c)
+{-# INLINE zip3 #-}
+zip3 = G.zip3
+
+zip4 :: Vector a -> Vector b -> Vector c -> Vector d
+     -> Vector (a, b, c, d)
+{-# INLINE zip4 #-}
+zip4 = G.zip4
+
+zip5 :: Vector a -> Vector b -> Vector c -> Vector d -> Vector e
+     -> Vector (a, b, c, d, e)
+{-# INLINE zip5 #-}
+zip5 = G.zip5
+
+zip6 :: Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f
+     -> Vector (a, b, c, d, e, f)
+{-# INLINE zip6 #-}
+zip6 = G.zip6
+
+-- Unzipping
+-- ---------
+
+-- | /O(min(m,n))/ Unzip a vector of pairs.
+unzip :: Vector (a, b) -> (Vector a, Vector b)
+{-# INLINE unzip #-}
+unzip = G.unzip
+
+unzip3 :: Vector (a, b, c) -> (Vector a, Vector b, Vector c)
+{-# INLINE unzip3 #-}
+unzip3 = G.unzip3
+
+unzip4 :: Vector (a, b, c, d) -> (Vector a, Vector b, Vector c, Vector d)
+{-# INLINE unzip4 #-}
+unzip4 = G.unzip4
+
+unzip5 :: Vector (a, b, c, d, e)
+       -> (Vector a, Vector b, Vector c, Vector d, Vector e)
+{-# INLINE unzip5 #-}
+unzip5 = G.unzip5
+
+unzip6 :: Vector (a, b, c, d, e, f)
+       -> (Vector a, Vector b, Vector c, Vector d, Vector e, Vector f)
+{-# INLINE unzip6 #-}
+unzip6 = G.unzip6
+
+-- Monadic zipping
+-- ---------------
+
+-- | /O(min(m,n))/ Zip the two vectors with the monadic action and yield a
+-- vector of results
+zipWithM :: Monad m => (a -> b -> m c) -> Vector a -> Vector b -> m (Vector c)
+{-# INLINE zipWithM #-}
+zipWithM = G.zipWithM
+
+-- | /O(min(m,n))/ Zip the two vectors with the monadic action and ignore the
+-- results
+zipWithM_ :: Monad m => (a -> b -> m c) -> Vector a -> Vector b -> m ()
+{-# INLINE zipWithM_ #-}
+zipWithM_ = G.zipWithM_
+
+-- Filtering
+-- ---------
+
+-- | /O(n)/ Drop elements that do not satisfy the predicate
+filter :: (a -> Bool) -> Vector a -> Vector a
+{-# INLINE filter #-}
+filter = G.filter
+
+-- | /O(n)/ Drop elements that do not satisfy the predicate which is applied to
+-- values and their indices
+ifilter :: (Int -> a -> Bool) -> Vector a -> Vector a
+{-# INLINE ifilter #-}
+ifilter = G.ifilter
+
+-- | /O(n)/ Drop elements that do not satisfy the monadic predicate
+filterM :: Monad m => (a -> m Bool) -> Vector a -> m (Vector a)
+{-# INLINE filterM #-}
+filterM = G.filterM
+
+-- | /O(n)/ Yield the longest prefix of elements satisfying the predicate
+-- without copying.
+takeWhile :: (a -> Bool) -> Vector a -> Vector a
+{-# INLINE takeWhile #-}
+takeWhile = G.takeWhile
+
+-- | /O(n)/ Drop the longest prefix of elements that satisfy the predicate
+-- without copying.
+dropWhile :: (a -> Bool) -> Vector a -> Vector a
+{-# INLINE dropWhile #-}
+dropWhile = G.dropWhile
+
+-- Parititioning
+-- -------------
+
+-- | /O(n)/ Split the vector in two parts, the first one containing those
+-- elements that satisfy the predicate and the second one those that don't. The
+-- relative order of the elements is preserved at the cost of a sometimes
+-- reduced performance compared to 'unstablePartition'.
+partition :: (a -> Bool) -> Vector a -> (Vector a, Vector a)
+{-# INLINE partition #-}
+partition = G.partition
+
+-- | /O(n)/ Split the vector in two parts, the first one containing those
+-- elements that satisfy the predicate and the second one those that don't.
+-- The order of the elements is not preserved but the operation is often
+-- faster than 'partition'.
+unstablePartition :: (a -> Bool) -> Vector a -> (Vector a, Vector a)
+{-# INLINE unstablePartition #-}
+unstablePartition = G.unstablePartition
+
+-- | /O(n)/ Split the vector into the longest prefix of elements that satisfy
+-- the predicate and the rest without copying.
+span :: (a -> Bool) -> Vector a -> (Vector a, Vector a)
+{-# INLINE span #-}
+span = G.span
+
+-- | /O(n)/ Split the vector into the longest prefix of elements that do not
+-- satisfy the predicate and the rest without copying.
+break :: (a -> Bool) -> Vector a -> (Vector a, Vector a)
+{-# INLINE break #-}
+break = G.break
+
+-- Searching
+-- ---------
+
+infix 4 `elem`
+-- | /O(n)/ Check if the vector contains an element
+elem :: Eq a => a -> Vector a -> Bool
+{-# INLINE elem #-}
+elem = G.elem
+
+infix 4 `notElem`
+-- | /O(n)/ Check if the vector does not contain an element (inverse of 'elem')
+notElem :: Eq a => a -> Vector a -> Bool
+{-# INLINE notElem #-}
+notElem = G.notElem
+
+-- | /O(n)/ 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 = G.find
+
+-- | /O(n)/ 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 = G.findIndex
+
+-- | /O(n)/ Yield the indices of elements satisfying the predicate in ascending
+-- order.
+findIndices :: (a -> Bool) -> Vector a -> Vector Int
+{-# INLINE findIndices #-}
+findIndices = G.findIndices
+
+-- | /O(n)/ Yield 'Just' the index of the first occurence of the given element or
+-- 'Nothing' if the vector does not contain the element. This is a specialised
+-- version of 'findIndex'.
+elemIndex :: Eq a => a -> Vector a -> Maybe Int
+{-# INLINE elemIndex #-}
+elemIndex = G.elemIndex
+
+-- | /O(n)/ Yield the indices of all occurences of the given element in
+-- ascending order. This is a specialised version of 'findIndices'.
+elemIndices :: Eq a => a -> Vector a -> Vector Int
+{-# INLINE elemIndices #-}
+elemIndices = G.elemIndices
+
+-- Folding
+-- -------
+
+-- | /O(n)/ Left fold
+foldl :: (a -> b -> a) -> a -> Vector b -> a
+{-# INLINE foldl #-}
+foldl = G.foldl
+
+-- | /O(n)/ Left fold on non-empty vectors
+foldl1 :: (a -> a -> a) -> Vector a -> a
+{-# INLINE foldl1 #-}
+foldl1 = G.foldl1
+
+-- | /O(n)/ Left fold with strict accumulator
+foldl' :: (a -> b -> a) -> a -> Vector b -> a
+{-# INLINE foldl' #-}
+foldl' = G.foldl'
+
+-- | /O(n)/ Left fold on non-empty vectors with strict accumulator
+foldl1' :: (a -> a -> a) -> Vector a -> a
+{-# INLINE foldl1' #-}
+foldl1' = G.foldl1'
+
+-- | /O(n)/ Right fold
+foldr :: (a -> b -> b) -> b -> Vector a -> b
+{-# INLINE foldr #-}
+foldr = G.foldr
+
+-- | /O(n)/ Right fold on non-empty vectors
+foldr1 :: (a -> a -> a) -> Vector a -> a
+{-# INLINE foldr1 #-}
+foldr1 = G.foldr1
+
+-- | /O(n)/ Right fold with a strict accumulator
+foldr' :: (a -> b -> b) -> b -> Vector a -> b
+{-# INLINE foldr' #-}
+foldr' = G.foldr'
+
+-- | /O(n)/ Right fold on non-empty vectors with strict accumulator
+foldr1' :: (a -> a -> a) -> Vector a -> a
+{-# INLINE foldr1' #-}
+foldr1' = G.foldr1'
+
+-- | /O(n)/ Left fold (function applied to each element and its index)
+ifoldl :: (a -> Int -> b -> a) -> a -> Vector b -> a
+{-# INLINE ifoldl #-}
+ifoldl = G.ifoldl
+
+-- | /O(n)/ Left fold with strict accumulator (function applied to each element
+-- and its index)
+ifoldl' :: (a -> Int -> b -> a) -> a -> Vector b -> a
+{-# INLINE ifoldl' #-}
+ifoldl' = G.ifoldl'
+
+-- | /O(n)/ Right fold (function applied to each element and its index)
+ifoldr :: (Int -> a -> b -> b) -> b -> Vector a -> b
+{-# INLINE ifoldr #-}
+ifoldr = G.ifoldr
+
+-- | /O(n)/ Right fold with strict accumulator (function applied to each
+-- element and its index)
+ifoldr' :: (Int -> a -> b -> b) -> b -> Vector a -> b
+{-# INLINE ifoldr' #-}
+ifoldr' = G.ifoldr'
+
+-- Specialised folds
+-- -----------------
+
+-- | /O(n)/ Check if all elements satisfy the predicate.
+all :: (a -> Bool) -> Vector a -> Bool
+{-# INLINE all #-}
+all = G.all
+
+-- | /O(n)/ Check if any element satisfies the predicate.
+any :: (a -> Bool) -> Vector a -> Bool
+{-# INLINE any #-}
+any = G.any
+
+-- | /O(n)/ Check if all elements are 'True'
+and :: Vector Bool -> Bool
+{-# INLINE and #-}
+and = G.and
+
+-- | /O(n)/ Check if any element is 'True'
+or :: Vector Bool -> Bool
+{-# INLINE or #-}
+or = G.or
+
+-- | /O(n)/ Compute the sum of the elements
+sum :: Num a => Vector a -> a
+{-# INLINE sum #-}
+sum = G.sum
+
+-- | /O(n)/ Compute the produce of the elements
+product :: Num a => Vector a -> a
+{-# INLINE product #-}
+product = G.product
+
+-- | /O(n)/ Yield the maximum element of the vector. The vector may not be
+-- empty.
+maximum :: Ord a => Vector a -> a
+{-# INLINE maximum #-}
+maximum = G.maximum
+
+-- | /O(n)/ Yield the maximum element of the vector according to the given
+-- comparison function. The vector may not be empty.
+maximumBy :: (a -> a -> Ordering) -> Vector a -> a
+{-# INLINE maximumBy #-}
+maximumBy = G.maximumBy
+
+-- | /O(n)/ Yield the minimum element of the vector. The vector may not be
+-- empty.
+minimum :: Ord a => Vector a -> a
+{-# INLINE minimum #-}
+minimum = G.minimum
+
+-- | /O(n)/ Yield the minimum element of the vector according to the given
+-- comparison function. The vector may not be empty.
+minimumBy :: (a -> a -> Ordering) -> Vector a -> a
+{-# INLINE minimumBy #-}
+minimumBy = G.minimumBy
+
+-- | /O(n)/ Yield the index of the maximum element of the vector. The vector
+-- may not be empty.
+maxIndex :: Ord a => Vector a -> Int
+{-# INLINE maxIndex #-}
+maxIndex = G.maxIndex
+
+-- | /O(n)/ Yield the index of the maximum element of the vector according to
+-- the given comparison function. The vector may not be empty.
+maxIndexBy :: (a -> a -> Ordering) -> Vector a -> Int
+{-# INLINE maxIndexBy #-}
+maxIndexBy = G.maxIndexBy
+
+-- | /O(n)/ Yield the index of the minimum element of the vector. The vector
+-- may not be empty.
+minIndex :: Ord a => Vector a -> Int
+{-# INLINE minIndex #-}
+minIndex = G.minIndex
+
+-- | /O(n)/ Yield the index of the minimum element of the vector according to
+-- the given comparison function. The vector may not be empty.
+minIndexBy :: (a -> a -> Ordering) -> Vector a -> Int
+{-# INLINE minIndexBy #-}
+minIndexBy = G.minIndexBy
+
+-- Monadic folds
+-- -------------
+
+-- | /O(n)/ Monadic fold
+foldM :: Monad m => (a -> b -> m a) -> a -> Vector b -> m a
+{-# INLINE foldM #-}
+foldM = G.foldM
+
+-- | /O(n)/ Monadic fold over non-empty vectors
+fold1M :: Monad m => (a -> a -> m a) -> Vector a -> m a
+{-# INLINE fold1M #-}
+fold1M = G.fold1M
+
+-- | /O(n)/ Monadic fold with strict accumulator
+foldM' :: Monad m => (a -> b -> m a) -> a -> Vector b -> m a
+{-# INLINE foldM' #-}
+foldM' = G.foldM'
+
+-- | /O(n)/ Monad fold over non-empty vectors with strict accumulator
+fold1M' :: Monad m => (a -> a -> m a) -> Vector a -> m a
+{-# INLINE fold1M' #-}
+fold1M' = G.fold1M'
+
+-- Prefix sums (scans)
+-- -------------------
+
+-- | /O(n)/ Prescan
+--
+-- @
+-- prescanl f z = 'init' . 'scanl' f z
+-- @
+--
+-- Example: @prescanl (+) 0 \<1,2,3,4\> = \<0,1,3,6\>@
+--
+prescanl :: (a -> b -> a) -> a -> Vector b -> Vector a
+{-# INLINE prescanl #-}
+prescanl = G.prescanl
+
+-- | /O(n)/ Prescan with strict accumulator
+prescanl' :: (a -> b -> a) -> a -> Vector b -> Vector a
+{-# INLINE prescanl' #-}
+prescanl' = G.prescanl'
+
+-- | /O(n)/ Scan
+--
+-- @
+-- postscanl f z = 'tail' . 'scanl' f z
+-- @
+--
+-- Example: @postscanl (+) 0 \<1,2,3,4\> = \<1,3,6,10\>@
+--
+postscanl :: (a -> b -> a) -> a -> Vector b -> Vector a
+{-# INLINE postscanl #-}
+postscanl = G.postscanl
+
+-- | /O(n)/ Scan with strict accumulator
+postscanl' :: (a -> b -> a) -> a -> Vector b -> Vector a
+{-# INLINE postscanl' #-}
+postscanl' = G.postscanl'
+
+-- | /O(n)/ Haskell-style scan
+--
+-- > scanl f z <x1,...,xn> = <y1,...,y(n+1)>
+-- >   where y1 = z
+-- >         yi = f y(i-1) x(i-1)
+--
+-- Example: @scanl (+) 0 \<1,2,3,4\> = \<0,1,3,6,10\>@
+-- 
+scanl :: (a -> b -> a) -> a -> Vector b -> Vector a
+{-# INLINE scanl #-}
+scanl = G.scanl
+
+-- | /O(n)/ Haskell-style scan with strict accumulator
+scanl' :: (a -> b -> a) -> a -> Vector b -> Vector a
+{-# INLINE scanl' #-}
+scanl' = G.scanl'
+
+-- | /O(n)/ Scan over a non-empty vector
+--
+-- > scanl f <x1,...,xn> = <y1,...,yn>
+-- >   where y1 = x1
+-- >         yi = f y(i-1) xi
+--
+scanl1 :: (a -> a -> a) -> Vector a -> Vector a
+{-# INLINE scanl1 #-}
+scanl1 = G.scanl1
+
+-- | /O(n)/ Scan over a non-empty vector with a strict accumulator
+scanl1' :: (a -> a -> a) -> Vector a -> Vector a
+{-# INLINE scanl1' #-}
+scanl1' = G.scanl1'
+
+-- | /O(n)/ Right-to-left prescan
+--
+-- @
+-- prescanr f z = 'reverse' . 'prescanl' (flip f) z . 'reverse'
+-- @
+--
+prescanr :: (a -> b -> b) -> b -> Vector a -> Vector b
+{-# INLINE prescanr #-}
+prescanr = G.prescanr
+
+-- | /O(n)/ Right-to-left prescan with strict accumulator
+prescanr' :: (a -> b -> b) -> b -> Vector a -> Vector b
+{-# INLINE prescanr' #-}
+prescanr' = G.prescanr'
+
+-- | /O(n)/ Right-to-left scan
+postscanr :: (a -> b -> b) -> b -> Vector a -> Vector b
+{-# INLINE postscanr #-}
+postscanr = G.postscanr
+
+-- | /O(n)/ Right-to-left scan with strict accumulator
+postscanr' :: (a -> b -> b) -> b -> Vector a -> Vector b
+{-# INLINE postscanr' #-}
+postscanr' = G.postscanr'
+
+-- | /O(n)/ Right-to-left Haskell-style scan
+scanr :: (a -> b -> b) -> b -> Vector a -> Vector b
+{-# INLINE scanr #-}
+scanr = G.scanr
+
+-- | /O(n)/ Right-to-left Haskell-style scan with strict accumulator
+scanr' :: (a -> b -> b) -> b -> Vector a -> Vector b
+{-# INLINE scanr' #-}
+scanr' = G.scanr'
+
+-- | /O(n)/ Right-to-left scan over a non-empty vector
+scanr1 :: (a -> a -> a) -> Vector a -> Vector a
+{-# INLINE scanr1 #-}
+scanr1 = G.scanr1
+
+-- | /O(n)/ Right-to-left scan over a non-empty vector with a strict
+-- accumulator
+scanr1' :: (a -> a -> a) -> Vector a -> Vector a
+{-# INLINE scanr1' #-}
+scanr1' = G.scanr1'
+
+-- Conversions - Lists
+-- ------------------------
+
+-- | /O(n)/ Convert a vector to a list
+toList :: Vector a -> [a]
+{-# INLINE toList #-}
+toList = G.toList
+
+-- | /O(n)/ Convert a list to a vector
+fromList :: [a] -> Vector a
+{-# INLINE fromList #-}
+fromList = G.fromList
+
+-- | /O(n)/ Convert the first @n@ elements of a list to a vector
+--
+-- @
+-- fromListN n xs = 'fromList' ('take' n xs)
+-- @
+fromListN :: Int -> [a] -> Vector a
+{-# INLINE fromListN #-}
+fromListN = G.fromListN
+
+-- Conversions - Mutable vectors
+-- -----------------------------
+
+-- | /O(n)/ Copy an immutable vector into a mutable one. The two vectors must
+-- have the same length.
+unsafeCopy :: PrimMonad m => MVector (PrimState m) a -> Vector a -> m ()
+{-# INLINE unsafeCopy #-}
+unsafeCopy = G.unsafeCopy
+           
+-- | /O(n)/ Copy an immutable vector into a mutable one. The two vectors must
+-- have the same length. This is not checked.
 copy :: PrimMonad m => MVector (PrimState m) a -> Vector a -> m ()
 {-# INLINE copy #-}
 copy = G.copy
diff --git a/Data/Vector/Generic.hs b/Data/Vector/Generic.hs
--- a/Data/Vector/Generic.hs
+++ b/Data/Vector/Generic.hs
@@ -9,1358 +9,1663 @@
 -- Stability   : experimental
 -- Portability : non-portable
 -- 
--- Generic interface to pure vectors
---
-
-module Data.Vector.Generic (
-  -- * Immutable vectors
-  Vector(..), Mutable,
-
-  -- * Length information
-  length, null,
-
-  -- * Construction
-  empty, singleton, cons, snoc, replicate, generate, (++), force,
-
-  -- * Accessing individual elements
-  (!), head, last, indexM, headM, lastM,
-  unsafeIndex, unsafeHead, unsafeLast,
-  unsafeIndexM, unsafeHeadM, unsafeLastM,
-
-  -- * Subvectors
-  slice, init, tail, take, drop,
-  unsafeSlice, unsafeInit, unsafeTail, unsafeTake, unsafeDrop,
-
-  -- * Permutations
-  accum, accumulate, accumulate_,
-  (//), update, update_,
-  backpermute, reverse,
-  unsafeAccum, unsafeAccumulate, unsafeAccumulate_,
-  unsafeUpd, unsafeUpdate, unsafeUpdate_,
-  unsafeBackpermute,
-
-  -- * Mapping
-  map, imap, concatMap,
-
-  -- * Zipping and unzipping
-  zipWith, zipWith3, zipWith4, zipWith5, zipWith6,
-  izipWith, izipWith3, izipWith4, izipWith5, izipWith6,
-  zip, zip3, zip4, zip5, zip6,
-  unzip, unzip3, unzip4, unzip5, unzip6,
-
-  -- * Comparisons
-  eq, cmp,
-
-  -- * Filtering
-  filter, ifilter, takeWhile, dropWhile,
-  partition, unstablePartition, span, break,
-
-  -- * Searching
-  elem, notElem, find, findIndex, findIndices, elemIndex, elemIndices,
-
-  -- * Folding
-  foldl, foldl1, foldl', foldl1', foldr, foldr1, foldr', foldr1',
-  ifoldl, ifoldl', ifoldr, ifoldr',
- 
-  -- * Specialised folds
-  all, any, and, or,
-  sum, product,
-  maximum, maximumBy, minimum, minimumBy,
-  minIndex, minIndexBy, maxIndex, maxIndexBy,
-
-  -- * Unfolding
-  unfoldr, unfoldrN,
-
-  -- * Scans
-  prescanl, prescanl',
-  postscanl, postscanl',
-  scanl, scanl', scanl1, scanl1',
-  prescanr, prescanr',
-  postscanr, postscanr',
-  scanr, scanr', scanr1, scanr1',
-
-  -- * Enumeration
-  enumFromN, enumFromStepN, enumFromTo, enumFromThenTo,
-
-  -- * Conversion to/from lists
-  toList, fromList, fromListN,
-
-  -- * Monadic operations
-  replicateM, mapM, mapM_, forM, forM_, zipWithM, zipWithM_, filterM,
-  foldM, foldM', fold1M, fold1M',
-
-  -- * Destructive operations
-  create, modify, copy, unsafeCopy,
-
-  -- * Conversion to/from Streams
-  stream, unstream, streamR, unstreamR,
-
-  -- * Recycling support
-  new, clone,
-
-  -- * Utilities for defining Data instances
-  gfoldl, dataCast, mkType
-) where
-
-import           Data.Vector.Generic.Base
-
-import           Data.Vector.Generic.Mutable ( MVector )
-import qualified Data.Vector.Generic.Mutable as M
-
-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, inplace )
-import qualified Data.Vector.Fusion.Stream.Monadic as MStream
-import           Data.Vector.Fusion.Stream.Size
-import           Data.Vector.Fusion.Util
-
-import Control.Monad.ST ( ST, runST )
-import Control.Monad.Primitive
-import qualified Control.Monad as Monad
-import Prelude hiding ( length, null,
-                        replicate, (++),
-                        head, last,
-                        init, tail, take, drop, reverse,
-                        map, concatMap,
-                        zipWith, zipWith3, zip, zip3, unzip, unzip3,
-                        filter, takeWhile, dropWhile, span, break,
-                        elem, notElem,
-                        foldl, foldl1, foldr, foldr1,
-                        all, any, and, or, sum, product, maximum, minimum,
-                        scanl, scanl1, scanr, scanr1,
-                        enumFromTo, enumFromThenTo,
-                        mapM, mapM_ )
-
-import Data.Typeable ( Typeable1, gcast1 )
-import Data.Data ( Data, DataType, mkNorepType )
-
-#include "vector.h"
-
--- Fusion
--- ------
-
--- | Construct a pure vector from a monadic initialiser 
-new :: Vector v a => New v a -> v a
-{-# INLINE_STREAM new #-}
-new m = m `seq` runST (unsafeFreeze =<< New.run m)
-
-clone :: Vector v a => v a -> New v a
-{-# INLINE_STREAM clone #-}
-clone v = v `seq` New.create (
-  do
-    mv <- M.new (length v)
-    unsafeCopy mv v
-    return mv)
-
--- | Convert a vector to a 'Stream'
-stream :: Vector v a => v a -> Stream a
-{-# INLINE_STREAM stream #-}
-stream v = v `seq` (Stream.unfoldr get 0 `Stream.sized` Exact n)
-  where
-    n = length v
-
-    -- NOTE: the False case comes first in Core so making it the recursive one
-    -- makes the code easier to read
-    {-# INLINE get #-}
-    get i | i >= n    = Nothing
-          | otherwise = case basicUnsafeIndexM v i of Box x -> Just (x, i+1)
-
--- | Create a vector from a 'Stream'
-unstream :: Vector v a => Stream a -> v a
-{-# INLINE unstream #-}
-unstream s = new (New.unstream s)
-
-{-# RULES
-
-"stream/unstream [Vector]" forall s.
-  stream (new (New.unstream s)) = s
-
-"New.unstream/stream [Vector]" forall v.
-  New.unstream (stream v) = clone v
-
-"clone/new [Vector]" forall p.
-  clone (new p) = p
-
-"inplace [Vector]"
-  forall (f :: forall m. Monad m => MStream m a -> MStream m a) m.
-  New.unstream (inplace f (stream (new m))) = New.transform f m
-
-"uninplace [Vector]"
-  forall (f :: forall m. Monad m => MStream m a -> MStream m a) m.
-  stream (new (New.transform f m)) = inplace f (stream (new m))
-
- #-}
-
--- | Convert a vector to a 'Stream'
-streamR :: Vector v a => v a -> Stream a
-{-# INLINE_STREAM streamR #-}
-streamR v = v `seq` (Stream.unfoldr get n `Stream.sized` Exact n)
-  where
-    n = length v
-
-    {-# INLINE get #-}
-    get 0 = Nothing
-    get i = let i' = i-1
-            in
-            case basicUnsafeIndexM v i' of Box x -> Just (x, i')
-
--- | Create a vector from a 'Stream'
-unstreamR :: Vector v a => Stream a -> v a
-{-# INLINE unstreamR #-}
-unstreamR s = new (New.unstreamR s)
-
-{-# RULES
-
-"streamR/unstreamR [Vector]" forall s.
-  streamR (new (New.unstreamR s)) = s
-
-"New.unstreamR/streamR/new [Vector]" forall p.
-  New.unstreamR (streamR (new p)) = p
-
-"inplace right [Vector]"
-  forall (f :: forall m. Monad m => MStream m a -> MStream m a) m.
-  New.unstreamR (inplace f (streamR (new m))) = New.transformR f m
-
-"uninplace right [Vector]"
-  forall (f :: forall m. Monad m => MStream m a -> MStream m a) m.
-  streamR (new (New.transformR f m)) = inplace f (streamR (new m))
-
- #-}
-
--- Length
--- ------
-
-length :: Vector v a => v a -> Int
-{-# INLINE_STREAM length #-}
-length v = basicLength v
-
-{-# RULES
-
-"length/unstream [Vector]" forall s.
-  length (new (New.unstream s)) = Stream.length s
-
-  #-}
-
-null :: Vector v a => v a -> Bool
-{-# INLINE_STREAM null #-}
-null v = basicLength v == 0
-
-{-# RULES
-
-"null/unstream [Vector]" forall s.
-  null (new (New.unstream s)) = Stream.null s
-
-  #-}
-
--- Construction
--- ------------
-
--- | Empty vector
-empty :: Vector v a => v a
-{-# INLINE empty #-}
-empty = unstream Stream.empty
-
--- | Vector with exaclty one element
-singleton :: forall v a. Vector v a => a -> v a
-{-# INLINE singleton #-}
-singleton x = elemseq (undefined :: v a) x
-            $ unstream (Stream.singleton x)
-
--- | Vector of the given length with the given value in each position
-replicate :: forall v a. Vector v a => Int -> a -> v a
-{-# INLINE replicate #-}
-replicate n x = elemseq (undefined :: v a) x
-              $ unstream
-              $ Stream.replicate n x
-
--- | Generate a vector of the given length by applying the function to each
--- index
-generate :: Vector v a => Int -> (Int -> a) -> v a
-{-# INLINE generate #-}
-generate n f = unstream (Stream.generate n f)
-
--- | Prepend an element
-cons :: forall v a. Vector v a => a -> v a -> v a
-{-# INLINE cons #-}
-cons x v = elemseq (undefined :: v a) x
-         $ unstream
-         $ Stream.cons x
-         $ stream v
-
--- | Append an element
-snoc :: forall v a. Vector v a => v a -> a -> v a
-{-# INLINE snoc #-}
-snoc v x = elemseq (undefined :: v a) x
-         $ unstream
-         $ Stream.snoc (stream v) x
-
-infixr 5 ++
--- | Concatenate two vectors
-(++) :: 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.
-force :: Vector v a => v a -> v a
-{-# INLINE_STREAM force #-}
-force v = new (clone v)
-
--- Accessing individual elements
--- -----------------------------
-
--- | Indexing
-(!) :: Vector v a => v a -> Int -> a
-{-# INLINE_STREAM (!) #-}
-v ! i = BOUNDS_CHECK(checkIndex) "(!)" i (length v)
-      $ unId (basicUnsafeIndexM v i)
-
--- | First element
-head :: Vector v a => v a -> a
-{-# INLINE_STREAM head #-}
-head v = v ! 0
-
--- | Last element
-last :: Vector v a => v a -> a
-{-# INLINE_STREAM last #-}
-last v = v ! (length v - 1)
-
--- | Unsafe indexing without bounds checking
-unsafeIndex :: Vector v a => v a -> Int -> a
-{-# INLINE_STREAM unsafeIndex #-}
-unsafeIndex v i = UNSAFE_CHECK(checkIndex) "unsafeIndex" i (length v)
-                $ unId (basicUnsafeIndexM v i)
-
--- | Yield the first element of a vector without checking if the vector is
--- empty
-unsafeHead :: Vector v a => v a -> a
-{-# INLINE_STREAM unsafeHead #-}
-unsafeHead v = unsafeIndex v 0
-
--- | Yield the last element of a vector without checking if the vector is
--- empty
-unsafeLast :: Vector v a => v a -> a
-{-# INLINE_STREAM unsafeLast #-}
-unsafeLast v = unsafeIndex v (length v - 1)
-
-{-# RULES
-
-"(!)/unstream [Vector]" forall i s.
-  new (New.unstream s) ! i = s Stream.!! i
-
-"head/unstream [Vector]" forall s.
-  head (new (New.unstream s)) = Stream.head s
-
-"last/unstream [Vector]" forall s.
-  last (new (New.unstream s)) = Stream.last s
-
-"unsafeIndex/unstream [Vector]" forall i s.
-  unsafeIndex (new (New.unstream s)) i = s Stream.!! i
-
-"unsafeHead/unstream [Vector]" forall s.
-  unsafeHead (new (New.unstream s)) = Stream.head s
-
-"unsafeLast/unstream [Vector]" forall s.
-  unsafeLast (new (New.unstream s)) = Stream.last s
-
- #-}
-
--- | Monadic indexing which can be strict in the vector while remaining lazy in
--- the element.
-indexM :: (Vector v a, Monad m) => v a -> Int -> m a
-{-# INLINE_STREAM indexM #-}
-indexM v i = BOUNDS_CHECK(checkIndex) "indexM" i (length v)
-           $ basicUnsafeIndexM v i
-
-headM :: (Vector v a, Monad m) => v a -> m a
-{-# INLINE_STREAM headM #-}
-headM v = indexM v 0
-
-lastM :: (Vector v a, Monad m) => v a -> m a
-{-# INLINE_STREAM lastM #-}
-lastM v = indexM v (length v - 1)
-
--- | Unsafe monadic indexing without bounds checks
-unsafeIndexM :: (Vector v a, Monad m) => v a -> Int -> m a
-{-# INLINE_STREAM unsafeIndexM #-}
-unsafeIndexM v i = UNSAFE_CHECK(checkIndex) "unsafeIndexM" i (length v)
-                 $ basicUnsafeIndexM v i
-
-unsafeHeadM :: (Vector v a, Monad m) => v a -> m a
-{-# INLINE_STREAM unsafeHeadM #-}
-unsafeHeadM v = unsafeIndexM v 0
-
-unsafeLastM :: (Vector v a, Monad m) => v a -> m a
-{-# INLINE_STREAM unsafeLastM #-}
-unsafeLastM v = unsafeIndexM v (length v - 1)
-
--- FIXME: the rhs of these rules are lazy in the stream which is WRONG
-{- RULES
-
-"indexM/unstream [Vector]" forall v i s.
-  indexM (new' v (New.unstream s)) i = return (s Stream.!! i)
-
-"headM/unstream [Vector]" forall v s.
-  headM (new' v (New.unstream s)) = return (Stream.head s)
-
-"lastM/unstream [Vector]" forall v s.
-  lastM (new' v (New.unstream s)) = return (Stream.last s)
-
- -}
-
--- Subarrays
--- ---------
-
--- | Yield a part of the vector without copying it.
-slice :: Vector v a => Int   -- ^ starting index
-                    -> Int   -- ^ length
-                    -> v a
-                    -> v a
-{-# INLINE_STREAM slice #-}
-slice i n v = BOUNDS_CHECK(checkSlice) "slice" i n (length v)
-            $ basicUnsafeSlice i n v
-
--- | Yield all but the last element without copying.
-init :: Vector v a => v a -> v a
-{-# INLINE_STREAM init #-}
-init v = slice 0 (length v - 1) v
-
--- | All but the first element (without copying).
-tail :: Vector v a => v a -> v a
-{-# INLINE_STREAM tail #-}
-tail v = slice 1 (length v - 1) v
-
--- | Yield the first @n@ elements without copying.
-take :: Vector v a => Int -> v a -> v a
-{-# INLINE_STREAM take #-}
-take n v = unsafeSlice 0 (delay_inline min n' (length v)) v
-  where n' = max n 0
-
--- | Yield all but the first @n@ elements without copying.
-drop :: Vector v a => Int -> v a -> v a
-{-# INLINE_STREAM drop #-}
-drop n v = unsafeSlice (delay_inline min n' len)
-                       (delay_inline max 0 (len - n')) v
-  where n' = max n 0
-        len = length v
-
--- | Unsafely yield a part of the vector without copying it and without
--- performing bounds checks.
-unsafeSlice :: Vector v a => Int   -- ^ starting index
-                          -> Int   -- ^ length
-                          -> v a
-                          -> v a
-{-# INLINE_STREAM unsafeSlice #-}
-unsafeSlice i n v = UNSAFE_CHECK(checkSlice) "unsafeSlice" i n (length v)
-                  $ basicUnsafeSlice i n v
-
-unsafeInit :: Vector v a => v a -> v a
-{-# INLINE_STREAM unsafeInit #-}
-unsafeInit v = unsafeSlice 0 (length v - 1) v
-
-unsafeTail :: Vector v a => v a -> v a
-{-# INLINE_STREAM unsafeTail #-}
-unsafeTail v = unsafeSlice 1 (length v - 1) v
-
-unsafeTake :: Vector v a => Int -> v a -> v a
-{-# INLINE unsafeTake #-}
-unsafeTake n v = unsafeSlice 0 n v
-
-unsafeDrop :: Vector v a => Int -> v a -> v a
-{-# INLINE unsafeDrop #-}
-unsafeDrop n v = unsafeSlice n (length v - n) v
-
-{-# RULES
-
-"slice/new [Vector]" forall i n p.
-  slice i n (new p) = new (New.slice i n p)
-
-"init/new [Vector]" forall p.
-  init (new p) = new (New.init p)
-
-"tail/new [Vector]" forall p.
-  tail (new p) = new (New.tail p)
-
-"take/new [Vector]" forall n p.
-  take n (new p) = new (New.take n p)
-
-"drop/new [Vector]" forall n p.
-  drop n (new p) = new (New.drop n p)
-
-"unsafeSlice/new [Vector]" forall i n p.
-  unsafeSlice i n (new p) = new (New.unsafeSlice i n p)
-
-"unsafeInit/new [Vector]" forall p.
-  unsafeInit (new p) = new (New.unsafeInit p)
-
-"unsafeTail/new [Vector]" forall p.
-  unsafeTail (new p) = new (New.unsafeTail p)
-
-  #-}
-
--- Permutations
--- ------------
-
-unsafeAccum_stream
-  :: Vector v a => (a -> b -> a) -> v a -> Stream (Int,b) -> v a
-{-# INLINE unsafeAccum_stream #-}
-unsafeAccum_stream f = modifyWithStream (M.unsafeAccum f)
-
-unsafeAccum :: Vector v a => (a -> b -> a) -> v a -> [(Int,b)] -> v a
-{-# INLINE unsafeAccum #-}
-unsafeAccum f v us = unsafeAccum_stream f v (Stream.fromList us)
-
-unsafeAccumulate :: (Vector v a, Vector v (Int, b))
-                => (a -> b -> a) -> v a -> v (Int,b) -> v a
-{-# INLINE unsafeAccumulate #-}
-unsafeAccumulate f v us = unsafeAccum_stream f v (stream us)
-
-unsafeAccumulate_ :: (Vector v a, Vector v Int, Vector v b)
-                => (a -> b -> a) -> v a -> v Int -> v b -> v a
-{-# INLINE unsafeAccumulate_ #-}
-unsafeAccumulate_ f v is xs
-  = unsafeAccum_stream f v (Stream.zipWith (,) (stream is) (stream xs))
-
-accum_stream :: Vector v a => (a -> b -> a) -> v a -> Stream (Int,b) -> v a
-{-# INLINE accum_stream #-}
-accum_stream f = modifyWithStream (M.accum f)
-
-accum :: Vector v a => (a -> b -> a) -> v a -> [(Int,b)] -> v a
-{-# INLINE accum #-}
-accum f v us = accum_stream f v (Stream.fromList us)
-
-accumulate :: (Vector v a, Vector v (Int, b))
-                => (a -> b -> a) -> v a -> v (Int,b) -> v a
-{-# INLINE accumulate #-}
-accumulate f v us = accum_stream f v (stream us)
-
-accumulate_ :: (Vector v a, Vector v Int, Vector v b)
-                => (a -> b -> a) -> v a -> v Int -> v b -> v a
-{-# INLINE accumulate_ #-}
-accumulate_ f v is xs = accum_stream f v (Stream.zipWith (,) (stream is)
-                                                             (stream xs))
-                                        
-
-unsafeUpdate_stream :: Vector v a => v a -> Stream (Int,a) -> v a
-{-# INLINE unsafeUpdate_stream #-}
-unsafeUpdate_stream = modifyWithStream M.unsafeUpdate
-
-unsafeUpd :: Vector v a => v a -> [(Int, a)] -> v a
-{-# INLINE unsafeUpd #-}
-unsafeUpd v us = unsafeUpdate_stream v (Stream.fromList us)
-
-unsafeUpdate :: (Vector v a, Vector v (Int, a)) => v a -> v (Int, a) -> v a
-{-# INLINE unsafeUpdate #-}
-unsafeUpdate v w = unsafeUpdate_stream v (stream w)
-
-unsafeUpdate_ :: (Vector v a, Vector v Int) => v a -> v Int -> v a -> v a
-{-# INLINE unsafeUpdate_ #-}
-unsafeUpdate_ v is w
-  = unsafeUpdate_stream v (Stream.zipWith (,) (stream is) (stream w))
-
-update_stream :: Vector v a => v a -> Stream (Int,a) -> v a
-{-# INLINE update_stream #-}
-update_stream = modifyWithStream M.update
-
-(//) :: Vector v a => v a -> [(Int, a)] -> v a
-{-# INLINE (//) #-}
-v // us = update_stream v (Stream.fromList us)
-
-update :: (Vector v a, Vector v (Int, a)) => v a -> v (Int, a) -> v a
-{-# INLINE update #-}
-update v w = update_stream v (stream w)
-
-update_ :: (Vector v a, Vector v Int) => v a -> v Int -> v a -> v a
-{-# INLINE update_ #-}
-update_ v is w = update_stream v (Stream.zipWith (,) (stream is) (stream w))
-
--- This somewhat non-intuitive definition ensures that the resulting vector
--- does not retain references to the original one even if it is lazy in its
--- elements. This would not be the case if we simply used
---
--- backpermute v is = map (v!) is
-backpermute :: (Vector v a, Vector v Int) => v a -> v Int -> v a
-{-# INLINE backpermute #-}
-backpermute v is = seq v
-                 $ unstream
-                 $ Stream.unbox
-                 $ Stream.map (indexM v)
-                 $ stream is
-
-unsafeBackpermute :: (Vector v a, Vector v Int) => v a -> v Int -> v a
-{-# INLINE unsafeBackpermute #-}
-unsafeBackpermute v is = seq v
-                       $ unstream
-                       $ Stream.unbox
-                       $ Stream.map (unsafeIndexM v)
-                       $ stream is
-
--- FIXME: make this fuse better, add support for recycling
-reverse :: (Vector v a) => v a -> v a
-{-# INLINE reverse #-}
-reverse = unstream . streamR
-
--- Mapping
--- -------
-
--- | Map a function over a vector
-map :: (Vector v a, Vector v b) => (a -> b) -> v a -> v b
-{-# INLINE map #-}
-map f = unstream . inplace (MStream.map f) . stream
-
--- | Apply a function to every index/value pair
-imap :: (Vector v a, Vector v b) => (Int -> a -> b) -> v a -> v b
-{-# INLINE imap #-}
-imap f = unstream . inplace (MStream.map (uncurry f) . MStream.indexed)
-                  . stream
-
-concatMap :: (Vector v a, Vector v b) => (a -> v b) -> v a -> v b
-{-# INLINE concatMap #-}
-concatMap f = unstream . Stream.concatMap (stream . f) . stream
-
--- Zipping/unzipping
--- -----------------
-
--- | Zip two vectors with the given function.
-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 :: (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 as bs cs = unstream (Stream.zipWith3 f (stream as)
-                                                  (stream bs)
-                                                  (stream cs))
-
-zipWith4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e)
-         => (a -> b -> c -> d -> e) -> v a -> v b -> v c -> v d -> v e
-{-# INLINE zipWith4 #-}
-zipWith4 f as bs cs ds
-  = unstream (Stream.zipWith4 f (stream as)
-                                (stream bs)
-                                (stream cs)
-                                (stream ds))
-
-zipWith5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
-             Vector v f)
-         => (a -> b -> c -> d -> e -> f) -> v a -> v b -> v c -> v d -> v e
-                                         -> v f
-{-# INLINE zipWith5 #-}
-zipWith5 f as bs cs ds es
-  = unstream (Stream.zipWith5 f (stream as)
-                                (stream bs)
-                                (stream cs)
-                                (stream ds)
-                                (stream es))
-
-zipWith6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
-             Vector v f, Vector v g)
-         => (a -> b -> c -> d -> e -> f -> g)
-         -> v a -> v b -> v c -> v d -> v e -> v f -> v g
-{-# INLINE zipWith6 #-}
-zipWith6 f as bs cs ds es fs
-  = unstream (Stream.zipWith6 f (stream as)
-                                (stream bs)
-                                (stream cs)
-                                (stream ds)
-                                (stream es)
-                                (stream fs))
-
--- | Zip two vectors and their indices with the given function.
-izipWith :: (Vector v a, Vector v b, Vector v c)
-        => (Int -> a -> b -> c) -> v a -> v b -> v c
-{-# INLINE izipWith #-}
-izipWith f xs ys = unstream
-                  (Stream.zipWith (uncurry f) (Stream.indexed (stream xs))
-                                                              (stream ys))
-
--- | Zip three vectors and their indices with the given function.
-izipWith3 :: (Vector v a, Vector v b, Vector v c, Vector v d)
-         => (Int -> a -> b -> c -> d) -> v a -> v b -> v c -> v d
-{-# INLINE izipWith3 #-}
-izipWith3 f as bs cs
-  = unstream (Stream.zipWith3 (uncurry f) (Stream.indexed (stream as))
-                                                          (stream bs)
-                                                          (stream cs))
-
-izipWith4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e)
-         => (Int -> a -> b -> c -> d -> e) -> v a -> v b -> v c -> v d -> v e
-{-# INLINE izipWith4 #-}
-izipWith4 f as bs cs ds
-  = unstream (Stream.zipWith4 (uncurry f) (Stream.indexed (stream as))
-                                                          (stream bs)
-                                                          (stream cs)
-                                                          (stream ds))
-
-izipWith5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
-             Vector v f)
-         => (Int -> a -> b -> c -> d -> e -> f) -> v a -> v b -> v c -> v d
-                                                -> v e -> v f
-{-# INLINE izipWith5 #-}
-izipWith5 f as bs cs ds es
-  = unstream (Stream.zipWith5 (uncurry f) (Stream.indexed (stream as))
-                                                          (stream bs)
-                                                          (stream cs)
-                                                          (stream ds)
-                                                          (stream es))
-
-izipWith6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
-             Vector v f, Vector v g)
-         => (Int -> a -> b -> c -> d -> e -> f -> g)
-         -> v a -> v b -> v c -> v d -> v e -> v f -> v g
-{-# INLINE izipWith6 #-}
-izipWith6 f as bs cs ds es fs
-  = unstream (Stream.zipWith6 (uncurry f) (Stream.indexed (stream as))
-                                                          (stream bs)
-                                                          (stream cs)
-                                                          (stream ds)
-                                                          (stream es)
-                                                          (stream fs))
-
-zip :: (Vector v a, Vector v b, Vector v (a,b)) => v a -> v b -> v (a, b)
-{-# INLINE zip #-}
-zip = zipWith (,)
-
-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 (,,)
-
-zip4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v (a, b, c, d))
-     => v a -> v b -> v c -> v d -> v (a, b, c, d)
-{-# INLINE zip4 #-}
-zip4 = zipWith4 (,,,)
-
-zip5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
-         Vector v (a, b, c, d, e))
-     => v a -> v b -> v c -> v d -> v e -> v (a, b, c, d, e)
-{-# INLINE zip5 #-}
-zip5 = zipWith5 (,,,,)
-
-zip6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
-         Vector v f, Vector v (a, b, c, d, e, f))
-     => v a -> v b -> v c -> v d -> v e -> v f -> v (a, b, c, d, e, f)
-{-# INLINE zip6 #-}
-zip6 = zipWith6 (,,,,,)
-
-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 :: (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)
-
-unzip4 :: (Vector v a, Vector v b, Vector v c, Vector v d,
-           Vector v (a, b, c, d))
-       => v (a, b, c, d) -> (v a, v b, v c, v d)
-{-# INLINE unzip4 #-}
-unzip4 xs = (map (\(a, b, c, d) -> a) xs,
-             map (\(a, b, c, d) -> b) xs,
-             map (\(a, b, c, d) -> c) xs,
-             map (\(a, b, c, d) -> d) xs)
-
-unzip5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
-           Vector v (a, b, c, d, e))
-       => v (a, b, c, d, e) -> (v a, v b, v c, v d, v e)
-{-# INLINE unzip5 #-}
-unzip5 xs = (map (\(a, b, c, d, e) -> a) xs,
-             map (\(a, b, c, d, e) -> b) xs,
-             map (\(a, b, c, d, e) -> c) xs,
-             map (\(a, b, c, d, e) -> d) xs,
-             map (\(a, b, c, d, e) -> e) xs)
-
-unzip6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
-           Vector v f, Vector v (a, b, c, d, e, f))
-       => v (a, b, c, d, e, f) -> (v a, v b, v c, v d, v e, v f)
-{-# INLINE unzip6 #-}
-unzip6 xs = (map (\(a, b, c, d, e, f) -> a) xs,
-             map (\(a, b, c, d, e, f) -> b) xs,
-             map (\(a, b, c, d, e, f) -> c) xs,
-             map (\(a, b, c, d, e, f) -> d) xs,
-             map (\(a, b, c, d, e, f) -> e) xs,
-             map (\(a, b, c, d, e, f) -> f) xs)
-
--- Comparisons
--- -----------
-
-eq :: (Vector v a, Eq a) => v a -> v a -> Bool
-{-# INLINE eq #-}
-xs `eq` ys = stream xs == stream ys
-
-cmp :: (Vector v a, Ord a) => v a -> v a -> Ordering
-{-# INLINE cmp #-}
-cmp xs ys = compare (stream xs) (stream ys)
-
--- Filtering
--- ---------
-
--- | Drop elements that do not satisfy the predicate
-filter :: Vector v a => (a -> Bool) -> v a -> v a
-{-# INLINE filter #-}
-filter f = unstream . inplace (MStream.filter f) . stream
-
--- | Drop elements that do not satisfy the predicate (applied to values and
--- their indices)
-ifilter :: Vector v a => (Int -> a -> Bool) -> v a -> v a
-{-# INLINE ifilter #-}
-ifilter f = unstream
-          . inplace (MStream.map snd . MStream.filter (uncurry f)
-                                     . MStream.indexed)
-          . stream
-
--- | Yield the longest prefix of elements satisfying the predicate.
-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 :: Vector v a => (a -> Bool) -> v a -> v a
-{-# INLINE dropWhile #-}
-dropWhile f = unstream . Stream.dropWhile f . stream
-
--- | Split the vector in two parts, the first one containing those elements
--- that satisfy the predicate and the second one those that don't. The
--- relative order of the elements is preserved at the cost of a (sometimes)
--- reduced performance compared to 'unstablePartition'.
-partition :: Vector v a => (a -> Bool) -> v a -> (v a, v a)
-{-# INLINE partition #-}
-partition f = partition_stream f . stream
-
--- FIXME: Make this inplace-fusible (look at how stable_partition is
--- implemented in C++)
-
-partition_stream :: Vector v a => (a -> Bool) -> Stream a -> (v a, v a)
-{-# INLINE_STREAM partition_stream #-}
-partition_stream f s = s `seq` runST (
-  do
-    (mv1,mv2) <- M.partitionStream f s
-    v1 <- unsafeFreeze mv1
-    v2 <- unsafeFreeze mv2
-    return (v1,v2))
-
--- | Split the vector in two parts, the first one containing those elements
--- that satisfy the predicate and the second one those that don't. The order
--- of the elements is not preserved but the operation is often faster than
--- 'partition'.
-unstablePartition :: Vector v a => (a -> Bool) -> v a -> (v a, v a)
-{-# INLINE unstablePartition #-}
-unstablePartition f = unstablePartition_stream f . stream
-
-unstablePartition_stream
-  :: Vector v a => (a -> Bool) -> Stream a -> (v a, v a)
-{-# INLINE_STREAM unstablePartition_stream #-}
-unstablePartition_stream f s = s `seq` runST (
-  do
-    (mv1,mv2) <- M.unstablePartitionStream f s
-    v1 <- unsafeFreeze mv1
-    v2 <- unsafeFreeze mv2
-    return (v1,v2))
-
-unstablePartition_new :: Vector v a => (a -> Bool) -> New v a -> (v a, v a)
-{-# INLINE_STREAM unstablePartition_new #-}
-unstablePartition_new f (New.New p) = runST (
-  do
-    mv <- p
-    i <- M.unstablePartition f mv
-    v <- unsafeFreeze mv
-    return (unsafeTake i v, unsafeDrop i v))
-
-{-# RULES
-
-"unstablePartition" forall f p.
-  unstablePartition_stream f (stream (new p))
-    = unstablePartition_new f p
-
-  #-}
-
-
--- FIXME: make span and break fusible
-
--- | Split the vector into the longest prefix of elements that satisfy the
--- predicate and the rest.
-span :: Vector v a => (a -> Bool) -> v a -> (v a, v a)
-{-# INLINE span #-}
-span f = break (not . f)
-
--- | Split the vector into the longest prefix of elements that do not satisfy
--- the predicate and the rest.
-break :: Vector v a => (a -> Bool) -> v a -> (v a, v a)
-{-# INLINE break #-}
-break f xs = case findIndex f xs of
-               Just i  -> (unsafeSlice 0 i xs, unsafeSlice i (length xs - i) xs)
-               Nothing -> (xs, empty)
-    
-
--- Searching
--- ---------
-
-infix 4 `elem`
--- | Check whether the vector contains an element
-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 :: (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 :: 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 :: Vector v a => (a -> Bool) -> v a -> Maybe Int
-{-# INLINE findIndex #-}
-findIndex f = Stream.findIndex f . stream
-
--- | Yield the indices of elements satisfying the predicate
-findIndices :: (Vector v a, Vector v Int) => (a -> Bool) -> v a -> v Int
-{-# INLINE findIndices #-}
-findIndices f = unstream
-              . inplace (MStream.map fst . MStream.filter (f . snd)
-                                         . MStream.indexed)
-              . stream
-
--- | Yield 'Just' the index of the first occurence of the given element or
--- 'Nothing' if the vector does not contain the element
-elemIndex :: (Vector v a, Eq a) => a -> v a -> Maybe Int
-{-# INLINE elemIndex #-}
-elemIndex x = findIndex (x==)
-
--- | Yield the indices of all occurences of the given element
-elemIndices :: (Vector v a, Vector v Int, Eq a) => a -> v a -> v Int
-{-# INLINE elemIndices #-}
-elemIndices x = findIndices (x==)
-
--- Folding
--- -------
-
--- | Left fold
-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
-foldl1 :: Vector v a => (a -> a -> a) -> v a -> a
-{-# INLINE foldl1 #-}
-foldl1 f = Stream.foldl1 f . stream
-
--- | Left fold with strict accumulator
-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' :: Vector v a => (a -> a -> a) -> v a -> a
-{-# INLINE foldl1' #-}
-foldl1' f = Stream.foldl1' f . stream
-
--- | Right fold
-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 :: Vector v a => (a -> a -> a) -> v a -> a
-{-# INLINE foldr1 #-}
-foldr1 f = Stream.foldr1 f . stream
-
--- | Right fold with a strict accumulator
-foldr' :: Vector v a => (a -> b -> b) -> b -> v a -> b
-{-# INLINE foldr' #-}
-foldr' f z = Stream.foldl' (flip f) z . streamR
-
--- | Right fold on non-empty vectors with strict accumulator
-foldr1' :: Vector v a => (a -> a -> a) -> v a -> a
-{-# INLINE foldr1' #-}
-foldr1' f = Stream.foldl1' (flip f) . streamR
-
--- | Left fold (function applied to each element and its index)
-ifoldl :: Vector v b => (a -> Int -> b -> a) -> a -> v b -> a
-{-# INLINE ifoldl #-}
-ifoldl f z = Stream.foldl (uncurry . f) z . Stream.indexed . stream
-
--- | Left fold with strict accumulator (function applied to each element and
--- its index)
-ifoldl' :: Vector v b => (a -> Int -> b -> a) -> a -> v b -> a
-{-# INLINE ifoldl' #-}
-ifoldl' f z = Stream.foldl' (uncurry . f) z . Stream.indexed . stream
-
--- | Right fold (function applied to each element and its index)
-ifoldr :: Vector v a => (Int -> a -> b -> b) -> b -> v a -> b
-{-# INLINE ifoldr #-}
-ifoldr f z = Stream.foldr (uncurry f) z . Stream.indexed . stream
-
--- | Right fold with strict accumulator (function applied to each element and
--- its index)
-ifoldr' :: Vector v a => (Int -> a -> b -> b) -> b -> v a -> b
-{-# INLINE ifoldr' #-}
-ifoldr' f z xs = Stream.foldl' (flip (uncurry f)) z
-               $ Stream.indexedR (length xs) $ streamR xs
-
--- Specialised folds
--- -----------------
-
-all :: Vector v a => (a -> Bool) -> v a -> Bool
-{-# INLINE all #-}
-all f = Stream.and . Stream.map f . stream
-
-any :: Vector v a => (a -> Bool) -> v a -> Bool
-{-# INLINE any #-}
-any f = Stream.or . Stream.map f . stream
-
-and :: Vector v Bool => v Bool -> Bool
-{-# INLINE and #-}
-and = Stream.and . stream
-
-or :: Vector v Bool => v Bool -> Bool
-{-# INLINE or #-}
-or = Stream.or . stream
-
-sum :: (Vector v a, Num a) => v a -> a
-{-# INLINE sum #-}
-sum = Stream.foldl' (+) 0 . stream
-
-product :: (Vector v a, Num a) => v a -> a
-{-# INLINE product #-}
-product = Stream.foldl' (*) 1 . stream
-
-maximum :: (Vector v a, Ord a) => v a -> a
-{-# INLINE maximum #-}
-maximum = Stream.foldl1' max . stream
-
-maximumBy :: Vector v a => (a -> a -> Ordering) -> v a -> a
-{-# INLINE maximumBy #-}
-maximumBy cmp = Stream.foldl1' maxBy . stream
-  where
-    {-# INLINE maxBy #-}
-    maxBy x y = case cmp x y of
-                  LT -> y
-                  _  -> x
-
-minimum :: (Vector v a, Ord a) => v a -> a
-{-# INLINE minimum #-}
-minimum = Stream.foldl1' min . stream
-
-minimumBy :: Vector v a => (a -> a -> Ordering) -> v a -> a
-{-# INLINE minimumBy #-}
-minimumBy cmp = Stream.foldl1' minBy . stream
-  where
-    {-# INLINE minBy #-}
-    minBy x y = case cmp x y of
-                  GT -> y
-                  _  -> x
-
-maxIndex :: (Vector v a, Ord a) => v a -> Int
-{-# INLINE maxIndex #-}
-maxIndex = maxIndexBy compare
-
-maxIndexBy :: Vector v a => (a -> a -> Ordering) -> v a -> Int
-{-# INLINE maxIndexBy #-}
-maxIndexBy cmp = fst . Stream.foldl1' imax . Stream.indexed . stream
-  where
-    imax (i,x) (j,y) = case cmp x y of
-                         LT -> (j,y)
-                         _  -> (i,x)
-
-minIndex :: (Vector v a, Ord a) => v a -> Int
-{-# INLINE minIndex #-}
-minIndex = minIndexBy compare
-
-minIndexBy :: Vector v a => (a -> a -> Ordering) -> v a -> Int
-{-# INLINE minIndexBy #-}
-minIndexBy cmp = fst . Stream.foldl1' imin . Stream.indexed . stream
-  where
-    imin (i,x) (j,y) = case cmp x y of
-                         GT -> (j,y)
-                         _  -> (i,x)
-
-
--- Unfolding
--- ---------
-
--- | Unfold
-unfoldr :: Vector v a => (b -> Maybe (a, b)) -> b -> v a
-{-# INLINE unfoldr #-}
-unfoldr f = unstream . Stream.unfoldr f
-
--- | Unfoldr at most @n@ elements.
-unfoldrN  :: Vector v a => Int -> (b -> Maybe (a, b)) -> b -> v a
-{-# INLINE unfoldrN #-}
-unfoldrN n f = unstream . Stream.unfoldrN n f
-
--- Scans
--- -----
-
--- | Prefix scan
-prescanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
-{-# INLINE prescanl #-}
-prescanl f z = unstream . inplace (MStream.prescanl f z) . stream
-
--- | Prefix scan with strict accumulator
-prescanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
-{-# INLINE prescanl' #-}
-prescanl' f z = unstream . inplace (MStream.prescanl' f z) . stream
-
--- | Suffix scan
-postscanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
-{-# INLINE postscanl #-}
-postscanl f z = unstream . inplace (MStream.postscanl f z) . stream
-
--- | Suffix scan with strict accumulator
-postscanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
-{-# INLINE postscanl' #-}
-postscanl' f z = unstream . inplace (MStream.postscanl' f z) . stream
-
--- | Haskell-style scan
-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' :: (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 :: 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' :: Vector v a => (a -> a -> a) -> v a -> v a
-{-# INLINE scanl1' #-}
-scanl1' f = unstream . inplace (MStream.scanl1' f) . stream
-
-
--- | Prefix right-to-left scan
-prescanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
-{-# INLINE prescanr #-}
-prescanr f z = unstreamR . inplace (MStream.prescanl (flip f) z) . streamR
-
--- | Prefix right-to-left scan with strict accumulator
-prescanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
-{-# INLINE prescanr' #-}
-prescanr' f z = unstreamR . inplace (MStream.prescanl' (flip f) z) . streamR
-
--- | Suffix right-to-left scan
-postscanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
-{-# INLINE postscanr #-}
-postscanr f z = unstreamR . inplace (MStream.postscanl (flip f) z) . streamR
-
--- | Suffix right-to-left scan with strict accumulator
-postscanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
-{-# INLINE postscanr' #-}
-postscanr' f z = unstreamR . inplace (MStream.postscanl' (flip f) z) . streamR
-
--- | Haskell-style right-to-left scan
-scanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
-{-# INLINE scanr #-}
-scanr f z = unstreamR . Stream.scanl (flip f) z . streamR
-
--- | Haskell-style right-to-left scan with strict accumulator
-scanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
-{-# INLINE scanr' #-}
-scanr' f z = unstreamR . Stream.scanl' (flip f) z . streamR
-
--- | Right-to-left scan over a non-empty vector
-scanr1 :: Vector v a => (a -> a -> a) -> v a -> v a
-{-# INLINE scanr1 #-}
-scanr1 f = unstreamR . inplace (MStream.scanl1 (flip f)) . streamR
-
--- | Right-to-left scan over a non-empty vector with a strict accumulator
-scanr1' :: Vector v a => (a -> a -> a) -> v a -> v a
-{-# INLINE scanr1' #-}
-scanr1' f = unstreamR . inplace (MStream.scanl1' (flip f)) . streamR
-
--- Enumeration
--- -----------
-
--- | Yield a vector of the given length containing the values @x@, @x+1@ etc.
--- This operation is usually more efficient than 'enumFromTo'.
-enumFromN :: (Vector v a, Num a) => a -> Int -> v a
-{-# INLINE enumFromN #-}
-enumFromN x n = enumFromStepN x 1 n
-
--- | Yield a vector of the given length containing the values @x@, @x+y@,
--- @x+y+y@ etc. This operations is usually more efficient than
--- 'enumFromThenTo'.
-enumFromStepN :: forall v a. (Vector v a, Num a) => a -> a -> Int -> v a
-{-# INLINE enumFromStepN #-}
-enumFromStepN x y n = elemseq (undefined :: v a) x
-                    $ elemseq (undefined :: v a) y
-                    $ unstream
-                    $ Stream.enumFromStepN  x y n
-
--- | Enumerate values from @x@ to @y@.
---
--- /WARNING:/ This operation can be very inefficient. If at all possible, use
--- 'enumFromN' instead.
-enumFromTo :: (Vector v a, Enum a) => a -> a -> v a
-{-# INLINE enumFromTo #-}
-enumFromTo x y = unstream (Stream.enumFromTo x y)
-
--- | Enumerate values from @x@ to @y@ with a specific step @z@.
---
--- /WARNING:/ This operation can be very inefficient. If at all possible, use
--- 'enumFromStepN' instead.
-enumFromThenTo :: (Vector v a, Enum a) => a -> a -> a -> v a
-{-# INLINE enumFromThenTo #-}
-enumFromThenTo x y z = unstream (Stream.enumFromThenTo x y z)
-
--- Conversion to/from lists
--- ------------------------
-
--- | Convert a vector to a list
-toList :: Vector v a => v a -> [a]
-{-# INLINE toList #-}
-toList = Stream.toList . stream
-
--- | Convert a list to a vector
-fromList :: Vector v a => [a] -> v a
-{-# INLINE fromList #-}
-fromList = unstream . Stream.fromList
-
--- | Convert the first @n@ elements of a list to a vector
---
--- > fromListN n xs = fromList (take n xs)
-fromListN :: Vector v a => Int -> [a] -> v a
-{-# INLINE fromListN #-}
-fromListN n = unstream . Stream.fromListN n
-
-unstreamM :: (Vector v a, Monad m) => MStream m a -> m (v a)
-{-# INLINE_STREAM unstreamM #-}
-unstreamM s = do
-                xs <- MStream.toList s
-                return $ unstream $ Stream.unsafeFromList (MStream.size s) xs
-
--- Monadic operations
--- ------------------
-
--- FIXME: specialise various combinators for ST and IO?
-
--- | Perform the monadic action the given number of times and store the
--- results in a vector.
-replicateM :: (Monad m, Vector v a) => Int -> m a -> m (v a)
-{-# INLINE replicateM #-}
-replicateM n m = fromListN n `Monad.liftM` Monad.replicateM n m
-
--- | Apply the monadic action to all elements of the vector, yielding a vector
--- of results
-mapM :: (Monad m, Vector v a, Vector v b) => (a -> m b) -> v a -> m (v b)
-{-# INLINE mapM #-}
-mapM f = unstreamM . Stream.mapM f . stream
-
--- | Apply the monadic action to all elements of a vector and ignore the
--- results
-mapM_ :: (Monad m, Vector v a) => (a -> m b) -> v a -> m ()
-{-# INLINE mapM_ #-}
-mapM_ f = Stream.mapM_ f . stream
-
--- | Apply the monadic action to all elements of the vector, yielding a vector
--- of results
-forM :: (Monad m, Vector v a, Vector v b) => v a -> (a -> m b) -> m (v b)
-{-# INLINE forM #-}
-forM as f = mapM f as
-
--- | Apply the monadic action to all elements of a vector and ignore the
--- results
-forM_ :: (Monad m, Vector v a) => v a -> (a -> m b) -> m ()
-{-# INLINE forM_ #-}
-forM_ as f = mapM_ f as
-
--- | Zip the two vectors with the monadic action and yield a vector of results
-zipWithM :: (Monad m, Vector v a, Vector v b, Vector v c)
-         => (a -> b -> m c) -> v a -> v b -> m (v c)
-{-# INLINE zipWithM #-}
-zipWithM f as bs = unstreamM $ Stream.zipWithM f (stream as) (stream bs)
-
--- | Zip the two vectors with the monadic action and ignore the results
-zipWithM_ :: (Monad m, Vector v a, Vector v b)
-          => (a -> b -> m c) -> v a -> v b -> m ()
-{-# INLINE zipWithM_ #-}
-zipWithM_ f as bs = Stream.zipWithM_ f (stream as) (stream bs)
-
--- | Drop elements that do not satisfy the monadic predicate
-filterM :: (Monad m, Vector v a) => (a -> m Bool) -> v a -> m (v a)
-{-# INLINE filterM #-}
-filterM f = unstreamM . Stream.filterM f . stream
-
--- | Monadic fold
-foldM :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> v b -> m a
-{-# INLINE foldM #-}
-foldM m z = Stream.foldM m z . stream
-
--- | Monadic fold over non-empty vectors
-fold1M :: (Monad m, Vector v a) => (a -> a -> m a) -> v a -> m a
-{-# INLINE fold1M #-}
-fold1M m = Stream.fold1M m . stream
-
--- | Monadic fold with strict accumulator
-foldM' :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> v b -> m a
-{-# INLINE foldM' #-}
-foldM' m z = Stream.foldM' m z . stream
-
--- | Monad fold over non-empty vectors with strict accumulator
-fold1M' :: (Monad m, Vector v a) => (a -> a -> m a) -> v a -> m a
-{-# INLINE fold1M' #-}
-fold1M' m = Stream.fold1M' m . stream
-
--- Destructive operations
--- ----------------------
-
--- | Destructively initialise a vector.
-create :: Vector v a => (forall s. ST s (Mutable v s a)) -> v a
-{-# INLINE create #-}
-create p = new (New.create p)
-
--- | Apply a destructive operation to a vector. The operation modifies a
--- copy of the vector unless it can be safely performed in place.
-modify :: Vector v a => (forall s. Mutable v s a -> ST s ()) -> v a -> v a
-{-# INLINE modify #-}
-modify p = new . New.modify p . clone
-
--- We have to make sure that this is strict in the stream but we can't seq on
--- it while fusion is happening. Hence this ugliness.
-modifyWithStream :: Vector v a
-                 => (forall s. Mutable v s a -> Stream b -> ST s ())
-                 -> v a -> Stream b -> v a
-{-# INLINE modifyWithStream #-}
-modifyWithStream p v s = new (New.modifyWithStream p (clone v) s)
-
--- | Copy an immutable vector into a mutable one. The two vectors must have
--- the same length. This is not checked.
-unsafeCopy
-  :: (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> v a -> m ()
-{-# INLINE unsafeCopy #-}
-unsafeCopy dst src = UNSAFE_CHECK(check) "unsafeCopy" "length mismatch"
-                                         (M.length dst == length src)
-                   $ (dst `seq` src `seq` basicUnsafeCopy dst src)
-           
--- | Copy an immutable vector into a mutable one. The two vectors must have the
--- same length.
-copy
-  :: (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> v a -> m ()
-{-# INLINE copy #-}
-copy dst src = BOUNDS_CHECK(check) "copy" "length mismatch"
-                                          (M.length dst == length src)
-             $ unsafeCopy dst src
-
--- Utilities for defining Data instances
--- -------------------------------------
+-- Generic interface to pure vectors.
+--
+
+module Data.Vector.Generic (
+  -- * Immutable vectors
+  Vector(..), Mutable,
+
+  -- * Accessors
+
+  -- ** Length information
+  length, null,
+
+  -- ** Indexing
+  (!), head, last,
+  unsafeIndex, unsafeHead, unsafeLast,
+
+  -- ** Monadic indexing
+  indexM, headM, lastM,
+  unsafeIndexM, unsafeHeadM, unsafeLastM,
+
+  -- ** Extracting subvectors (slicing)
+  slice, init, tail, take, drop,
+  unsafeSlice, unsafeInit, unsafeTail, unsafeTake, unsafeDrop,
+
+  -- * Construction
+
+  -- ** Initialisation
+  empty, singleton, replicate, generate,
+
+  -- ** Monadic initialisation
+  replicateM, create,
+
+  -- ** Unfolding
+  unfoldr, unfoldrN,
+
+  -- ** Enumeration
+  enumFromN, enumFromStepN, enumFromTo, enumFromThenTo,
+
+  -- ** Concatenation
+  cons, snoc, (++),
+
+  -- ** Restricting memory usage
+  force,
+
+  -- * Modifying vectors
+
+  -- ** Bulk updates
+  (//), update, update_,
+  unsafeUpd, unsafeUpdate, unsafeUpdate_,
+
+  -- ** Accumulations
+  accum, accumulate, accumulate_,
+  unsafeAccum, unsafeAccumulate, unsafeAccumulate_,
+
+  -- ** Permutations 
+  reverse, backpermute, unsafeBackpermute,
+
+  -- ** Safe destructive updates
+  modify,
+
+  -- * Elementwise operations
+
+  -- ** Mapping
+  map, imap, concatMap,
+
+  -- ** Monadic mapping
+  mapM, mapM_, forM, forM_,
+
+  -- ** Zipping
+  zipWith, zipWith3, zipWith4, zipWith5, zipWith6,
+  izipWith, izipWith3, izipWith4, izipWith5, izipWith6,
+  zip, zip3, zip4, zip5, zip6,
+
+  -- ** Monadic zipping
+  zipWithM, zipWithM_,
+
+  -- ** Unzipping
+  unzip, unzip3, unzip4, unzip5, unzip6,
+
+  -- * Working with predicates
+
+  -- ** Filtering
+  filter, ifilter, filterM,
+  takeWhile, dropWhile,
+
+  -- ** Partitioning
+  partition, unstablePartition, span, break,
+
+  -- ** Searching
+  elem, notElem, find, findIndex, findIndices, elemIndex, elemIndices,
+
+  -- * Folding
+  foldl, foldl1, foldl', foldl1', foldr, foldr1, foldr', foldr1',
+  ifoldl, ifoldl', ifoldr, ifoldr',
+
+  -- ** Specialised folds
+  all, any, and, or,
+  sum, product,
+  maximum, maximumBy, minimum, minimumBy,
+  minIndex, minIndexBy, maxIndex, maxIndexBy,
+
+  -- ** Monadic folds
+  foldM, foldM', fold1M, fold1M',
+
+  -- * Prefix sums (scans)
+  prescanl, prescanl',
+  postscanl, postscanl',
+  scanl, scanl', scanl1, scanl1',
+  prescanr, prescanr',
+  postscanr, postscanr',
+  scanr, scanr', scanr1, scanr1',
+
+  -- * Conversions
+
+  -- ** Lists
+  toList, fromList, fromListN,
+
+  -- ** Mutable vectors
+  copy, unsafeCopy,
+
+  -- * Fusion support
+
+  -- ** Conversion to/from Streams
+  stream, unstream, streamR, unstreamR,
+
+  -- ** Recycling support
+  new, clone,
+
+  -- * Utilities
+
+  -- ** Comparisons
+  eq, cmp,
+
+  -- ** @Data@ and @Typeable@
+  gfoldl, dataCast, mkType
+) where
+
+import           Data.Vector.Generic.Base
+
+import           Data.Vector.Generic.Mutable ( MVector )
+import qualified Data.Vector.Generic.Mutable as M
+
+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, inplace )
+import qualified Data.Vector.Fusion.Stream.Monadic as MStream
+import           Data.Vector.Fusion.Stream.Size
+import           Data.Vector.Fusion.Util
+
+import Control.Monad.ST ( ST, runST )
+import Control.Monad.Primitive
+import qualified Control.Monad as Monad
+import Prelude hiding ( length, null,
+                        replicate, (++),
+                        head, last,
+                        init, tail, take, drop, reverse,
+                        map, concatMap,
+                        zipWith, zipWith3, zip, zip3, unzip, unzip3,
+                        filter, takeWhile, dropWhile, span, break,
+                        elem, notElem,
+                        foldl, foldl1, foldr, foldr1,
+                        all, any, and, or, sum, product, maximum, minimum,
+                        scanl, scanl1, scanr, scanr1,
+                        enumFromTo, enumFromThenTo,
+                        mapM, mapM_ )
+
+import Data.Typeable ( Typeable1, gcast1 )
+import Data.Data ( Data, DataType, mkNorepType )
+
+#include "vector.h"
+
+-- Length information
+-- ------------------
+
+-- | /O(1)/ Yield the length of the vector.
+length :: Vector v a => v a -> Int
+{-# INLINE_STREAM length #-}
+length v = basicLength v
+
+{-# RULES
+
+"length/unstream [Vector]" forall s.
+  length (new (New.unstream s)) = Stream.length s
+
+  #-}
+
+-- | /O(1)/ Test whether a vector if empty
+null :: Vector v a => v a -> Bool
+{-# INLINE_STREAM null #-}
+null v = basicLength v == 0
+
+{-# RULES
+
+"null/unstream [Vector]" forall s.
+  null (new (New.unstream s)) = Stream.null s
+
+  #-}
+
+-- Indexing
+-- --------
+
+-- | O(1) Indexing
+(!) :: Vector v a => v a -> Int -> a
+{-# INLINE_STREAM (!) #-}
+v ! i = BOUNDS_CHECK(checkIndex) "(!)" i (length v)
+      $ unId (basicUnsafeIndexM v i)
+
+-- | /O(1)/ First element
+head :: Vector v a => v a -> a
+{-# INLINE_STREAM head #-}
+head v = v ! 0
+
+-- | /O(1)/ Last element
+last :: Vector v a => v a -> a
+{-# INLINE_STREAM last #-}
+last v = v ! (length v - 1)
+
+-- | /O(1)/ Unsafe indexing without bounds checking
+unsafeIndex :: Vector v a => v a -> Int -> a
+{-# INLINE_STREAM unsafeIndex #-}
+unsafeIndex v i = UNSAFE_CHECK(checkIndex) "unsafeIndex" i (length v)
+                $ unId (basicUnsafeIndexM v i)
+
+-- | /O(1)/ First element without checking if the vector is empty
+unsafeHead :: Vector v a => v a -> a
+{-# INLINE_STREAM unsafeHead #-}
+unsafeHead v = unsafeIndex v 0
+
+-- | /O(1)/ Last element without checking if the vector is empty
+unsafeLast :: Vector v a => v a -> a
+{-# INLINE_STREAM unsafeLast #-}
+unsafeLast v = unsafeIndex v (length v - 1)
+
+{-# RULES
+
+"(!)/unstream [Vector]" forall i s.
+  new (New.unstream s) ! i = s Stream.!! i
+
+"head/unstream [Vector]" forall s.
+  head (new (New.unstream s)) = Stream.head s
+
+"last/unstream [Vector]" forall s.
+  last (new (New.unstream s)) = Stream.last s
+
+"unsafeIndex/unstream [Vector]" forall i s.
+  unsafeIndex (new (New.unstream s)) i = s Stream.!! i
+
+"unsafeHead/unstream [Vector]" forall s.
+  unsafeHead (new (New.unstream s)) = Stream.head s
+
+"unsafeLast/unstream [Vector]" forall s.
+  unsafeLast (new (New.unstream s)) = Stream.last s
+
+ #-}
+
+-- Monadic indexing
+-- ----------------
+
+-- | /O(1)/ Indexing in a monad.
+--
+-- The monad allows operations to be strict in the vector when necessary.
+-- Suppose vector copying is implemented like this:
+--
+-- > copy mv v = ... write mv i (v ! i) ...
+--
+-- For lazy vectors, @v ! i@ would not be evaluated which means that @mv@
+-- would unnecessarily retain a reference to @v@ in each element written.
+--
+-- With 'indexM', copying can be implemented like this instead:
+--
+-- > copy mv v = ... do
+-- >                   x <- indexM v i
+-- >                   write mv i x
+--
+-- Here, no references to @v@ are retained because indexing (but /not/ the
+-- elements) is evaluated eagerly.
+--
+indexM :: (Vector v a, Monad m) => v a -> Int -> m a
+{-# INLINE_STREAM indexM #-}
+indexM v i = BOUNDS_CHECK(checkIndex) "indexM" i (length v)
+           $ basicUnsafeIndexM v i
+
+-- | /O(1)/ First element of a vector in a monad. See 'indexM' for an
+-- explanation of why this is useful.
+headM :: (Vector v a, Monad m) => v a -> m a
+{-# INLINE_STREAM headM #-}
+headM v = indexM v 0
+
+-- | /O(1)/ Last element of a vector in a monad. See 'indexM' for an
+-- explanation of why this is useful.
+lastM :: (Vector v a, Monad m) => v a -> m a
+{-# INLINE_STREAM lastM #-}
+lastM v = indexM v (length v - 1)
+
+-- | /O(1)/ Indexing in a monad without bounds checks. See 'indexM' for an
+-- explanation of why this is useful.
+unsafeIndexM :: (Vector v a, Monad m) => v a -> Int -> m a
+{-# INLINE_STREAM unsafeIndexM #-}
+unsafeIndexM v i = UNSAFE_CHECK(checkIndex) "unsafeIndexM" i (length v)
+                 $ basicUnsafeIndexM v i
+
+-- | /O(1)/ First element in a monad without checking for empty vectors.
+-- See 'indexM' for an explanation of why this is useful.
+unsafeHeadM :: (Vector v a, Monad m) => v a -> m a
+{-# INLINE_STREAM unsafeHeadM #-}
+unsafeHeadM v = unsafeIndexM v 0
+
+-- | /O(1)/ Last element in a monad without checking for empty vectors.
+-- See 'indexM' for an explanation of why this is useful.
+unsafeLastM :: (Vector v a, Monad m) => v a -> m a
+{-# INLINE_STREAM unsafeLastM #-}
+unsafeLastM v = unsafeIndexM v (length v - 1)
+
+-- FIXME: the rhs of these rules are lazy in the stream which is WRONG
+{- RULES
+
+"indexM/unstream [Vector]" forall v i s.
+  indexM (new' v (New.unstream s)) i = return (s Stream.!! i)
+
+"headM/unstream [Vector]" forall v s.
+  headM (new' v (New.unstream s)) = return (Stream.head s)
+
+"lastM/unstream [Vector]" forall v s.
+  lastM (new' v (New.unstream s)) = return (Stream.last s)
+
+ -}
+
+-- Extracting subvectors (slicing)
+-- -------------------------------
+
+-- | /O(1)/ Yield a slice of the vector without copying it. The vector must
+-- contain at least @i+n@ elements.
+slice :: Vector v a => Int   -- ^ @i@ starting index
+                    -> Int   -- ^ @n@ length
+                    -> v a
+                    -> v a
+{-# INLINE_STREAM slice #-}
+slice i n v = BOUNDS_CHECK(checkSlice) "slice" i n (length v)
+            $ basicUnsafeSlice i n v
+
+-- | /O(1)/ Yield all but the last element without copying. The vector may not
+-- be empty.
+init :: Vector v a => v a -> v a
+{-# INLINE_STREAM init #-}
+init v = slice 0 (length v - 1) v
+
+-- | /O(1)/ Yield all but the first element without copying. The vector may not
+-- be empty.
+tail :: Vector v a => v a -> v a
+{-# INLINE_STREAM tail #-}
+tail v = slice 1 (length v - 1) v
+
+-- | /O(1)/ Yield at the first @n@ elements without copying. The vector may
+-- contain less than @n@ elements in which case it is returned unchanged.
+take :: Vector v a => Int -> v a -> v a
+{-# INLINE_STREAM take #-}
+take n v = unsafeSlice 0 (delay_inline min n' (length v)) v
+  where n' = max n 0
+
+-- | /O(1)/ Yield all but the first @n@ elements without copying. The vector may
+-- contain less than @n@ elements in which case an empty vector is returned.
+drop :: Vector v a => Int -> v a -> v a
+{-# INLINE_STREAM drop #-}
+drop n v = unsafeSlice (delay_inline min n' len)
+                       (delay_inline max 0 (len - n')) v
+  where n' = max n 0
+        len = length v
+
+-- | /O(1)/ Yield a slice of the vector without copying. The vector must
+-- contain at least @i+n@ elements but this is not checked.
+unsafeSlice :: Vector v a => Int   -- ^ @i@ starting index
+                          -> Int   -- ^ @n@ length
+                          -> v a
+                          -> v a
+{-# INLINE_STREAM unsafeSlice #-}
+unsafeSlice i n v = UNSAFE_CHECK(checkSlice) "unsafeSlice" i n (length v)
+                  $ basicUnsafeSlice i n v
+
+-- | /O(1)/ Yield all but the last element without copying. The vector may not
+-- be empty but this is not checked.
+unsafeInit :: Vector v a => v a -> v a
+{-# INLINE_STREAM unsafeInit #-}
+unsafeInit v = unsafeSlice 0 (length v - 1) v
+
+-- | /O(1)/ Yield all but the first element without copying. The vector may not
+-- be empty but this is not checked.
+unsafeTail :: Vector v a => v a -> v a
+{-# INLINE_STREAM unsafeTail #-}
+unsafeTail v = unsafeSlice 1 (length v - 1) v
+
+-- | /O(1)/ Yield the first @n@ elements without copying. The vector must
+-- contain at least @n@ elements but this is not checked.
+unsafeTake :: Vector v a => Int -> v a -> v a
+{-# INLINE unsafeTake #-}
+unsafeTake n v = unsafeSlice 0 n v
+
+-- | /O(1)/ Yield all but the first @n@ elements without copying. The vector
+-- must contain at least @n@ elements but this is not checked.
+unsafeDrop :: Vector v a => Int -> v a -> v a
+{-# INLINE unsafeDrop #-}
+unsafeDrop n v = unsafeSlice n (length v - n) v
+
+{-# RULES
+
+"slice/new [Vector]" forall i n p.
+  slice i n (new p) = new (New.slice i n p)
+
+"init/new [Vector]" forall p.
+  init (new p) = new (New.init p)
+
+"tail/new [Vector]" forall p.
+  tail (new p) = new (New.tail p)
+
+"take/new [Vector]" forall n p.
+  take n (new p) = new (New.take n p)
+
+"drop/new [Vector]" forall n p.
+  drop n (new p) = new (New.drop n p)
+
+"unsafeSlice/new [Vector]" forall i n p.
+  unsafeSlice i n (new p) = new (New.unsafeSlice i n p)
+
+"unsafeInit/new [Vector]" forall p.
+  unsafeInit (new p) = new (New.unsafeInit p)
+
+"unsafeTail/new [Vector]" forall p.
+  unsafeTail (new p) = new (New.unsafeTail p)
+
+  #-}
+
+-- Initialisation
+-- --------------
+
+-- | /O(1)/ Empty vector
+empty :: Vector v a => v a
+{-# INLINE empty #-}
+empty = unstream Stream.empty
+
+-- | /O(1)/ Vector with exactly one element
+singleton :: forall v a. Vector v a => a -> v a
+{-# INLINE singleton #-}
+singleton x = elemseq (undefined :: v a) x
+            $ unstream (Stream.singleton x)
+
+-- | /O(n)/ Vector of the given length with the same value in each position
+replicate :: forall v a. Vector v a => Int -> a -> v a
+{-# INLINE replicate #-}
+replicate n x = elemseq (undefined :: v a) x
+              $ unstream
+              $ Stream.replicate n x
+
+-- | /O(n)/ Construct a vector of the given length by applying the function to
+-- each index
+generate :: Vector v a => Int -> (Int -> a) -> v a
+{-# INLINE generate #-}
+generate n f = unstream (Stream.generate n f)
+
+-- Unfolding
+-- ---------
+
+-- | /O(n)/ Construct a vector by repeatedly applying the generator function
+-- to a seed. The generator function yields 'Just' the next element and the
+-- new seed or 'Nothing' if there are no more elements.
+--
+-- > unfoldr (\n -> if n == 0 then Nothing else Just (n,n-1)) 10
+-- >  = <10,9,8,7,6,5,4,3,2,1>
+unfoldr :: Vector v a => (b -> Maybe (a, b)) -> b -> v a
+{-# INLINE unfoldr #-}
+unfoldr f = unstream . Stream.unfoldr f
+
+-- | /O(n)/ Construct a vector with at most @n@ by repeatedly applying the
+-- generator function to the a seed. The generator function yields 'Just' the
+-- next element and the new seed or 'Nothing' if there are no more elements.
+--
+-- > unfoldrN 3 (\n -> Just (n,n-1)) 10 = <10,9,8>
+unfoldrN  :: Vector v a => Int -> (b -> Maybe (a, b)) -> b -> v a
+{-# INLINE unfoldrN #-}
+unfoldrN n f = unstream . Stream.unfoldrN n f
+
+-- Enumeration
+-- -----------
+
+-- | /O(n)/ Yield a vector of the given length containing the values @x@, @x+1@
+-- etc. This operation is usually more efficient than 'enumFromTo'.
+--
+-- > enumFromN 5 3 = <5,6,7>
+enumFromN :: (Vector v a, Num a) => a -> Int -> v a
+{-# INLINE enumFromN #-}
+enumFromN x n = enumFromStepN x 1 n
+
+-- | /O(n)/ Yield a vector of the given length containing the values @x@, @x+y@,
+-- @x+y+y@ etc. This operations is usually more efficient than 'enumFromThenTo'.
+--
+-- > enumFromStepN 1 0.1 5 = <1,1.1,1.2,1.3,1.4>
+enumFromStepN :: forall v a. (Vector v a, Num a) => a -> a -> Int -> v a
+{-# INLINE enumFromStepN #-}
+enumFromStepN x y n = elemseq (undefined :: v a) x
+                    $ elemseq (undefined :: v a) y
+                    $ unstream
+                    $ Stream.enumFromStepN  x y n
+
+-- | /O(n)/ Enumerate values from @x@ to @y@.
+--
+-- /WARNING:/ This operation can be very inefficient. If at all possible, use
+-- 'enumFromN' instead.
+enumFromTo :: (Vector v a, Enum a) => a -> a -> v a
+{-# INLINE enumFromTo #-}
+enumFromTo x y = unstream (Stream.enumFromTo x y)
+
+-- | /O(n)/ Enumerate values from @x@ to @y@ with a specific step @z@.
+--
+-- /WARNING:/ This operation can be very inefficient. If at all possible, use
+-- 'enumFromStepN' instead.
+enumFromThenTo :: (Vector v a, Enum a) => a -> a -> a -> v a
+{-# INLINE enumFromThenTo #-}
+enumFromThenTo x y z = unstream (Stream.enumFromThenTo x y z)
+
+-- Concatenation
+-- -------------
+
+-- | /O(n)/ Prepend an element
+cons :: forall v a. Vector v a => a -> v a -> v a
+{-# INLINE cons #-}
+cons x v = elemseq (undefined :: v a) x
+         $ unstream
+         $ Stream.cons x
+         $ stream v
+
+-- | /O(n)/ Append an element
+snoc :: forall v a. Vector v a => v a -> a -> v a
+{-# INLINE snoc #-}
+snoc v x = elemseq (undefined :: v a) x
+         $ unstream
+         $ Stream.snoc (stream v) x
+
+infixr 5 ++
+-- | /O(m+n)/ Concatenate two vectors
+(++) :: Vector v a => v a -> v a -> v a
+{-# INLINE (++) #-}
+v ++ w = unstream (stream v Stream.++ stream w)
+
+-- Monadic initialisation
+-- ----------------------
+
+-- | /O(n)/ Execute the monadic action the given number of times and store the
+-- results in a vector.
+replicateM :: (Monad m, Vector v a) => Int -> m a -> m (v a)
+-- FIXME: specialise for ST and IO?
+{-# INLINE replicateM #-}
+replicateM n m = fromListN n `Monad.liftM` Monad.replicateM n m
+
+-- | Execute the monadic action and freeze the resulting vector.
+--
+-- @
+-- create (do { v \<- 'M.new' 2; 'M.write' v 0 \'a\'; 'M.write' v 1 \'b\' }) = \<'a','b'\>
+-- @
+create :: Vector v a => (forall s. ST s (Mutable v s a)) -> v a
+{-# INLINE create #-}
+create p = new (New.create p)
+
+-- Restricting memory usage
+-- ------------------------
+
+-- | /O(n)/ Yield the argument but force it not to retain any extra memory,
+-- possibly by copying it.
+--
+-- This is especially useful when dealing with slices. For example:
+--
+-- > force (slice 0 2 <huge vector>)
+--
+-- Here, the slice retains a reference to the huge vector. Forcing it creates
+-- a copy of just the elements that belong to the slice and allows the huge
+-- vector to be garbage collected.
+force :: Vector v a => v a -> v a
+-- FIXME: we probably ought to inline this later as the rules still might fire
+-- otherwise
+{-# INLINE_STREAM force #-}
+force v = new (clone v)
+
+-- Bulk updates
+-- ------------
+
+-- | /O(m+n)/ For each pair @(i,a)@ from the list, replace the vector
+-- element at position @i@ by @a@.
+--
+-- > <5,9,2,7> // [(2,1),(0,3),(2,8)] = <3,9,8,7>
+--
+(//) :: Vector v a => v a        -- ^ initial vector (of length @m@)
+                   -> [(Int, a)] -- ^ list of index/value pairs (of length @n@)
+                   -> v a
+{-# INLINE (//) #-}
+v // us = update_stream v (Stream.fromList us)
+
+-- | /O(m+n)/ For each pair @(i,a)@ from the vector of index/value pairs,
+-- replace the vector element at position @i@ by @a@.
+--
+-- > update <5,9,2,7> <(2,1),(0,3),(2,8)> = <3,9,8,7>
+--
+update :: (Vector v a, Vector v (Int, a))
+        => v a        -- ^ initial vector (of length @m@)
+        -> v (Int, a) -- ^ vector of index/value pairs (of length @n@)
+        -> v a
+{-# INLINE update #-}
+update v w = update_stream v (stream w)
+
+-- | /O(m+min(n1,n2))/ For each index @i@ from the index vector and the
+-- corresponding value @a@ from the value vector, replace the element of the
+-- initial vector at position @i@ by @a@.
+--
+-- > update_ <5,9,2,7>  <2,0,2> <1,3,8> = <3,9,8,7>
+--
+-- This function is useful for instances of 'Vector' that cannot store pairs.
+-- Otherwise, 'update' is probably more convenient.
+--
+-- @
+-- update_ xs is ys = 'update' xs ('zip' is ys)
+-- @
+update_ :: (Vector v a, Vector v Int)
+        => v a   -- ^ initial vector (of length @m@)
+        -> v Int -- ^ index vector (of length @n1@)
+        -> v a   -- ^ value vector (of length @n2@)
+        -> v a
+{-# INLINE update_ #-}
+update_ v is w = update_stream v (Stream.zipWith (,) (stream is) (stream w))
+
+update_stream :: Vector v a => v a -> Stream (Int,a) -> v a
+{-# INLINE update_stream #-}
+update_stream = modifyWithStream M.update
+
+-- | Same as ('//') but without bounds checking.
+unsafeUpd :: Vector v a => v a -> [(Int, a)] -> v a
+{-# INLINE unsafeUpd #-}
+unsafeUpd v us = unsafeUpdate_stream v (Stream.fromList us)
+
+-- | Same as 'update' but without bounds checking.
+unsafeUpdate :: (Vector v a, Vector v (Int, a)) => v a -> v (Int, a) -> v a
+{-# INLINE unsafeUpdate #-}
+unsafeUpdate v w = unsafeUpdate_stream v (stream w)
+
+-- | Same as 'update_' but without bounds checking.
+unsafeUpdate_ :: (Vector v a, Vector v Int) => v a -> v Int -> v a -> v a
+{-# INLINE unsafeUpdate_ #-}
+unsafeUpdate_ v is w
+  = unsafeUpdate_stream v (Stream.zipWith (,) (stream is) (stream w))
+
+unsafeUpdate_stream :: Vector v a => v a -> Stream (Int,a) -> v a
+{-# INLINE unsafeUpdate_stream #-}
+unsafeUpdate_stream = modifyWithStream M.unsafeUpdate
+
+-- Accumulations
+-- -------------
+
+-- | /O(m+n)/ For each pair @(i,b)@ from the list, replace the vector element
+-- @a@ at position @i@ by @f a b@.
+--
+-- > accum (+) <5,9,2> [(2,4),(1,6),(0,3),(1,7)] = <5+3, 9+6+7, 2+4>
+accum :: Vector v a
+      => (a -> b -> a) -- ^ accumulating function @f@
+      -> v a           -- ^ initial vector (of length @m@)
+      -> [(Int,b)]     -- ^ list of index/value pairs (of length @n@)
+      -> v a
+{-# INLINE accum #-}
+accum f v us = accum_stream f v (Stream.fromList us)
+
+-- | /O(m+n)/ For each pair @(i,b)@ from the vector of pairs, replace the vector
+-- element @a@ at position @i@ by @f a b@.
+--
+-- > accumulate (+) <5,9,2> <(2,4),(1,6),(0,3),(1,7)> = <5+3, 9+6+7, 2+4>
+accumulate :: (Vector v a, Vector v (Int, b))
+           => (a -> b -> a) -- ^ accumulating function @f@
+           -> v a           -- ^ initial vector (of length @m@)
+           -> v (Int,b)     -- ^ vector of index/value pairs (of length @n@)
+           -> v a
+{-# INLINE accumulate #-}
+accumulate f v us = accum_stream f v (stream us)
+
+-- | /O(m+min(n1,n2))/ For each index @i@ from the index vector and the
+-- corresponding value @b@ from the the value vector,
+-- replace the element of the initial vector at
+-- position @i@ by @f a b@.
+--
+-- > accumulate_ (+) <5,9,2> <2,1,0,1> <4,6,3,7> = <5+3, 9+6+7, 2+4>
+--
+-- This function is useful for instances of 'Vector' that cannot store pairs.
+-- Otherwise, 'accumulate' is probably more convenient:
+--
+-- @
+-- accumulate_ f as is bs = 'accumulate' f as ('zip' is bs)
+-- @
+accumulate_ :: (Vector v a, Vector v Int, Vector v b)
+                => (a -> b -> a) -- ^ accumulating function @f@
+                -> v a           -- ^ initial vector (of length @m@)
+                -> v Int         -- ^ index vector (of length @n1@)
+                -> v b           -- ^ value vector (of length @n2@)
+                -> v a
+{-# INLINE accumulate_ #-}
+accumulate_ f v is xs = accum_stream f v (Stream.zipWith (,) (stream is)
+                                                             (stream xs))
+                                        
+
+accum_stream :: Vector v a => (a -> b -> a) -> v a -> Stream (Int,b) -> v a
+{-# INLINE accum_stream #-}
+accum_stream f = modifyWithStream (M.accum f)
+
+-- | Same as 'accum' but without bounds checking.
+unsafeAccum :: Vector v a => (a -> b -> a) -> v a -> [(Int,b)] -> v a
+{-# INLINE unsafeAccum #-}
+unsafeAccum f v us = unsafeAccum_stream f v (Stream.fromList us)
+
+-- | Same as 'accumulate' but without bounds checking.
+unsafeAccumulate :: (Vector v a, Vector v (Int, b))
+                => (a -> b -> a) -> v a -> v (Int,b) -> v a
+{-# INLINE unsafeAccumulate #-}
+unsafeAccumulate f v us = unsafeAccum_stream f v (stream us)
+
+-- | Same as 'accumulate_' but without bounds checking.
+unsafeAccumulate_ :: (Vector v a, Vector v Int, Vector v b)
+                => (a -> b -> a) -> v a -> v Int -> v b -> v a
+{-# INLINE unsafeAccumulate_ #-}
+unsafeAccumulate_ f v is xs
+  = unsafeAccum_stream f v (Stream.zipWith (,) (stream is) (stream xs))
+
+unsafeAccum_stream
+  :: Vector v a => (a -> b -> a) -> v a -> Stream (Int,b) -> v a
+{-# INLINE unsafeAccum_stream #-}
+unsafeAccum_stream f = modifyWithStream (M.unsafeAccum f)
+
+-- Permutations
+-- ------------
+
+-- | /O(n)/ Reverse a vector
+reverse :: (Vector v a) => v a -> v a
+{-# INLINE reverse #-}
+-- FIXME: make this fuse better, add support for recycling
+reverse = unstream . streamR
+
+-- | /O(n)/ Yield the vector obtained by replacing each element @i@ of the
+-- index vector by @xs'!'i@. This is equivalent to @'map' (xs'!') is@ but is
+-- often much more efficient.
+--
+-- > backpermute <a,b,c,d> <0,3,2,3,1,0> = <a,d,c,d,b,a>
+backpermute :: (Vector v a, Vector v Int)
+            => v a   -- ^ @xs@ value vector
+            -> v Int -- ^ @is@ index vector (of length @n@)
+            -> v a
+{-# INLINE backpermute #-}
+-- This somewhat non-intuitive definition ensures that the resulting vector
+-- does not retain references to the original one even if it is lazy in its
+-- elements. This would not be the case if we simply used map (v!)
+backpermute v is = seq v
+                 $ unstream
+                 $ Stream.unbox
+                 $ Stream.map (indexM v)
+                 $ stream is
+
+-- | Same as 'backpermute' but without bounds checking.
+unsafeBackpermute :: (Vector v a, Vector v Int) => v a -> v Int -> v a
+{-# INLINE unsafeBackpermute #-}
+unsafeBackpermute v is = seq v
+                       $ unstream
+                       $ Stream.unbox
+                       $ Stream.map (unsafeIndexM v)
+                       $ stream is
+
+-- Safe destructive updates
+-- ------------------------
+
+-- | Apply a destructive operation to a vector. The operation will be
+-- performed in place if it is safe to do so and will modify a copy of the
+-- vector otherwise.
+--
+-- @
+-- modify (\\v -> 'M.write' v 0 \'x\') ('replicate' 3 \'a\') = \<\'x\',\'a\',\'a\'\>
+-- @
+modify :: Vector v a => (forall s. Mutable v s a -> ST s ()) -> v a -> v a
+{-# INLINE modify #-}
+modify p = new . New.modify p . clone
+
+-- We have to make sure that this is strict in the stream but we can't seq on
+-- it while fusion is happening. Hence this ugliness.
+modifyWithStream :: Vector v a
+                 => (forall s. Mutable v s a -> Stream b -> ST s ())
+                 -> v a -> Stream b -> v a
+{-# INLINE modifyWithStream #-}
+modifyWithStream p v s = new (New.modifyWithStream p (clone v) s)
+
+-- Mapping
+-- -------
+
+-- | /O(n)/ Map a function over a vector
+map :: (Vector v a, Vector v b) => (a -> b) -> v a -> v b
+{-# INLINE map #-}
+map f = unstream . inplace (MStream.map f) . stream
+
+-- | /O(n)/ Apply a function to every element of a vector and its index
+imap :: (Vector v a, Vector v b) => (Int -> a -> b) -> v a -> v b
+{-# INLINE imap #-}
+imap f = unstream . inplace (MStream.map (uncurry f) . MStream.indexed)
+                  . stream
+
+-- | Map a function over a vector and concatenate the results.
+concatMap :: (Vector v a, Vector v b) => (a -> v b) -> v a -> v b
+{-# INLINE concatMap #-}
+concatMap f = unstream . Stream.concatMap (stream . f) . stream
+
+-- Monadic mapping
+-- ---------------
+
+-- | /O(n)/ Apply the monadic action to all elements of the vector, yielding a
+-- vector of results
+mapM :: (Monad m, Vector v a, Vector v b) => (a -> m b) -> v a -> m (v b)
+-- FIXME: specialise for ST and IO?
+{-# INLINE mapM #-}
+mapM f = unstreamM . Stream.mapM f . stream
+
+-- | /O(n)/ Apply the monadic action to all elements of a vector and ignore the
+-- results
+mapM_ :: (Monad m, Vector v a) => (a -> m b) -> v a -> m ()
+{-# INLINE mapM_ #-}
+mapM_ f = Stream.mapM_ f . stream
+
+-- | /O(n)/ Apply the monadic action to all elements of the vector, yielding a
+-- vector of results. Equvalent to @flip 'mapM'@.
+forM :: (Monad m, Vector v a, Vector v b) => v a -> (a -> m b) -> m (v b)
+{-# INLINE forM #-}
+forM as f = mapM f as
+
+-- | /O(n)/ Apply the monadic action to all elements of a vector and ignore the
+-- results. Equivalent to @flip 'mapM_'@.
+forM_ :: (Monad m, Vector v a) => v a -> (a -> m b) -> m ()
+{-# INLINE forM_ #-}
+forM_ as f = mapM_ f as
+
+-- Zipping
+-- -------
+
+-- | /O(min(m,n))/ Zip two vectors with the given function.
+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 :: (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 as bs cs = unstream (Stream.zipWith3 f (stream as)
+                                                  (stream bs)
+                                                  (stream cs))
+
+zipWith4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e)
+         => (a -> b -> c -> d -> e) -> v a -> v b -> v c -> v d -> v e
+{-# INLINE zipWith4 #-}
+zipWith4 f as bs cs ds
+  = unstream (Stream.zipWith4 f (stream as)
+                                (stream bs)
+                                (stream cs)
+                                (stream ds))
+
+zipWith5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
+             Vector v f)
+         => (a -> b -> c -> d -> e -> f) -> v a -> v b -> v c -> v d -> v e
+                                         -> v f
+{-# INLINE zipWith5 #-}
+zipWith5 f as bs cs ds es
+  = unstream (Stream.zipWith5 f (stream as)
+                                (stream bs)
+                                (stream cs)
+                                (stream ds)
+                                (stream es))
+
+zipWith6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
+             Vector v f, Vector v g)
+         => (a -> b -> c -> d -> e -> f -> g)
+         -> v a -> v b -> v c -> v d -> v e -> v f -> v g
+{-# INLINE zipWith6 #-}
+zipWith6 f as bs cs ds es fs
+  = unstream (Stream.zipWith6 f (stream as)
+                                (stream bs)
+                                (stream cs)
+                                (stream ds)
+                                (stream es)
+                                (stream fs))
+
+-- | /O(min(m,n))/ Zip two vectors with a function that also takes the
+-- elements' indices.
+izipWith :: (Vector v a, Vector v b, Vector v c)
+        => (Int -> a -> b -> c) -> v a -> v b -> v c
+{-# INLINE izipWith #-}
+izipWith f xs ys = unstream
+                  (Stream.zipWith (uncurry f) (Stream.indexed (stream xs))
+                                                              (stream ys))
+
+izipWith3 :: (Vector v a, Vector v b, Vector v c, Vector v d)
+         => (Int -> a -> b -> c -> d) -> v a -> v b -> v c -> v d
+{-# INLINE izipWith3 #-}
+izipWith3 f as bs cs
+  = unstream (Stream.zipWith3 (uncurry f) (Stream.indexed (stream as))
+                                                          (stream bs)
+                                                          (stream cs))
+
+izipWith4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e)
+         => (Int -> a -> b -> c -> d -> e) -> v a -> v b -> v c -> v d -> v e
+{-# INLINE izipWith4 #-}
+izipWith4 f as bs cs ds
+  = unstream (Stream.zipWith4 (uncurry f) (Stream.indexed (stream as))
+                                                          (stream bs)
+                                                          (stream cs)
+                                                          (stream ds))
+
+izipWith5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
+             Vector v f)
+         => (Int -> a -> b -> c -> d -> e -> f) -> v a -> v b -> v c -> v d
+                                                -> v e -> v f
+{-# INLINE izipWith5 #-}
+izipWith5 f as bs cs ds es
+  = unstream (Stream.zipWith5 (uncurry f) (Stream.indexed (stream as))
+                                                          (stream bs)
+                                                          (stream cs)
+                                                          (stream ds)
+                                                          (stream es))
+
+izipWith6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
+             Vector v f, Vector v g)
+         => (Int -> a -> b -> c -> d -> e -> f -> g)
+         -> v a -> v b -> v c -> v d -> v e -> v f -> v g
+{-# INLINE izipWith6 #-}
+izipWith6 f as bs cs ds es fs
+  = unstream (Stream.zipWith6 (uncurry f) (Stream.indexed (stream as))
+                                                          (stream bs)
+                                                          (stream cs)
+                                                          (stream ds)
+                                                          (stream es)
+                                                          (stream fs))
+
+-- | /O(min(m,n))/ Zip two vectors
+zip :: (Vector v a, Vector v b, Vector v (a,b)) => v a -> v b -> v (a, b)
+{-# INLINE zip #-}
+zip = zipWith (,)
+
+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 (,,)
+
+zip4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v (a, b, c, d))
+     => v a -> v b -> v c -> v d -> v (a, b, c, d)
+{-# INLINE zip4 #-}
+zip4 = zipWith4 (,,,)
+
+zip5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
+         Vector v (a, b, c, d, e))
+     => v a -> v b -> v c -> v d -> v e -> v (a, b, c, d, e)
+{-# INLINE zip5 #-}
+zip5 = zipWith5 (,,,,)
+
+zip6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
+         Vector v f, Vector v (a, b, c, d, e, f))
+     => v a -> v b -> v c -> v d -> v e -> v f -> v (a, b, c, d, e, f)
+{-# INLINE zip6 #-}
+zip6 = zipWith6 (,,,,,)
+
+-- Monadic zipping
+-- ---------------
+
+-- | /O(min(m,n))/ Zip the two vectors with the monadic action and yield a
+-- vector of results
+zipWithM :: (Monad m, Vector v a, Vector v b, Vector v c)
+         => (a -> b -> m c) -> v a -> v b -> m (v c)
+-- FIXME: specialise for ST and IO?
+{-# INLINE zipWithM #-}
+zipWithM f as bs = unstreamM $ Stream.zipWithM f (stream as) (stream bs)
+
+-- | /O(min(m,n))/ Zip the two vectors with the monadic action and ignore the
+-- results
+zipWithM_ :: (Monad m, Vector v a, Vector v b)
+          => (a -> b -> m c) -> v a -> v b -> m ()
+{-# INLINE zipWithM_ #-}
+zipWithM_ f as bs = Stream.zipWithM_ f (stream as) (stream bs)
+
+-- Unzipping
+-- ---------
+
+-- | /O(min(m,n))/ Unzip a vector of pairs.
+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 :: (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)
+
+unzip4 :: (Vector v a, Vector v b, Vector v c, Vector v d,
+           Vector v (a, b, c, d))
+       => v (a, b, c, d) -> (v a, v b, v c, v d)
+{-# INLINE unzip4 #-}
+unzip4 xs = (map (\(a, b, c, d) -> a) xs,
+             map (\(a, b, c, d) -> b) xs,
+             map (\(a, b, c, d) -> c) xs,
+             map (\(a, b, c, d) -> d) xs)
+
+unzip5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
+           Vector v (a, b, c, d, e))
+       => v (a, b, c, d, e) -> (v a, v b, v c, v d, v e)
+{-# INLINE unzip5 #-}
+unzip5 xs = (map (\(a, b, c, d, e) -> a) xs,
+             map (\(a, b, c, d, e) -> b) xs,
+             map (\(a, b, c, d, e) -> c) xs,
+             map (\(a, b, c, d, e) -> d) xs,
+             map (\(a, b, c, d, e) -> e) xs)
+
+unzip6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
+           Vector v f, Vector v (a, b, c, d, e, f))
+       => v (a, b, c, d, e, f) -> (v a, v b, v c, v d, v e, v f)
+{-# INLINE unzip6 #-}
+unzip6 xs = (map (\(a, b, c, d, e, f) -> a) xs,
+             map (\(a, b, c, d, e, f) -> b) xs,
+             map (\(a, b, c, d, e, f) -> c) xs,
+             map (\(a, b, c, d, e, f) -> d) xs,
+             map (\(a, b, c, d, e, f) -> e) xs,
+             map (\(a, b, c, d, e, f) -> f) xs)
+
+-- Filtering
+-- ---------
+
+-- | /O(n)/ Drop elements that do not satisfy the predicate
+filter :: Vector v a => (a -> Bool) -> v a -> v a
+{-# INLINE filter #-}
+filter f = unstream . inplace (MStream.filter f) . stream
+
+-- | /O(n)/ Drop elements that do not satisfy the predicate which is applied to
+-- values and their indices
+ifilter :: Vector v a => (Int -> a -> Bool) -> v a -> v a
+{-# INLINE ifilter #-}
+ifilter f = unstream
+          . inplace (MStream.map snd . MStream.filter (uncurry f)
+                                     . MStream.indexed)
+          . stream
+
+-- | /O(n)/ Drop elements that do not satisfy the monadic predicate
+filterM :: (Monad m, Vector v a) => (a -> m Bool) -> v a -> m (v a)
+{-# INLINE filterM #-}
+filterM f = unstreamM . Stream.filterM f . stream
+
+-- | /O(n)/ Yield the longest prefix of elements satisfying the predicate
+-- without copying.
+takeWhile :: Vector v a => (a -> Bool) -> v a -> v a
+{-# INLINE takeWhile #-}
+takeWhile f = unstream . Stream.takeWhile f . stream
+
+-- | /O(n)/ Drop the longest prefix of elements that satisfy the predicate
+-- without copying.
+dropWhile :: Vector v a => (a -> Bool) -> v a -> v a
+{-# INLINE dropWhile #-}
+dropWhile f = unstream . Stream.dropWhile f . stream
+
+-- Parititioning
+-- -------------
+
+-- | /O(n)/ Split the vector in two parts, the first one containing those
+-- elements that satisfy the predicate and the second one those that don't. The
+-- relative order of the elements is preserved at the cost of a sometimes
+-- reduced performance compared to 'unstablePartition'.
+partition :: Vector v a => (a -> Bool) -> v a -> (v a, v a)
+{-# INLINE partition #-}
+partition f = partition_stream f . stream
+
+-- FIXME: Make this inplace-fusible (look at how stable_partition is
+-- implemented in C++)
+
+partition_stream :: Vector v a => (a -> Bool) -> Stream a -> (v a, v a)
+{-# INLINE_STREAM partition_stream #-}
+partition_stream f s = s `seq` runST (
+  do
+    (mv1,mv2) <- M.partitionStream f s
+    v1 <- unsafeFreeze mv1
+    v2 <- unsafeFreeze mv2
+    return (v1,v2))
+
+-- | /O(n)/ Split the vector in two parts, the first one containing those
+-- elements that satisfy the predicate and the second one those that don't.
+-- The order of the elements is not preserved but the operation is often
+-- faster than 'partition'.
+unstablePartition :: Vector v a => (a -> Bool) -> v a -> (v a, v a)
+{-# INLINE unstablePartition #-}
+unstablePartition f = unstablePartition_stream f . stream
+
+unstablePartition_stream
+  :: Vector v a => (a -> Bool) -> Stream a -> (v a, v a)
+{-# INLINE_STREAM unstablePartition_stream #-}
+unstablePartition_stream f s = s `seq` runST (
+  do
+    (mv1,mv2) <- M.unstablePartitionStream f s
+    v1 <- unsafeFreeze mv1
+    v2 <- unsafeFreeze mv2
+    return (v1,v2))
+
+unstablePartition_new :: Vector v a => (a -> Bool) -> New v a -> (v a, v a)
+{-# INLINE_STREAM unstablePartition_new #-}
+unstablePartition_new f (New.New p) = runST (
+  do
+    mv <- p
+    i <- M.unstablePartition f mv
+    v <- unsafeFreeze mv
+    return (unsafeTake i v, unsafeDrop i v))
+
+{-# RULES
+
+"unstablePartition" forall f p.
+  unstablePartition_stream f (stream (new p))
+    = unstablePartition_new f p
+
+  #-}
+
+
+-- FIXME: make span and break fusible
+
+-- | /O(n)/ Split the vector into the longest prefix of elements that satisfy
+-- the predicate and the rest without copying.
+span :: Vector v a => (a -> Bool) -> v a -> (v a, v a)
+{-# INLINE span #-}
+span f = break (not . f)
+
+-- | /O(n)/ Split the vector into the longest prefix of elements that do not
+-- satisfy the predicate and the rest without copying.
+break :: Vector v a => (a -> Bool) -> v a -> (v a, v a)
+{-# INLINE break #-}
+break f xs = case findIndex f xs of
+               Just i  -> (unsafeSlice 0 i xs, unsafeSlice i (length xs - i) xs)
+               Nothing -> (xs, empty)
+    
+
+-- Searching
+-- ---------
+
+infix 4 `elem`
+-- | /O(n)/ Check if the vector contains an element
+elem :: (Vector v a, Eq a) => a -> v a -> Bool
+{-# INLINE elem #-}
+elem x = Stream.elem x . stream
+
+infix 4 `notElem`
+-- | /O(n)/ Check if the vector does not contain an element (inverse of 'elem')
+notElem :: (Vector v a, Eq a) => a -> v a -> Bool
+{-# INLINE notElem #-}
+notElem x = Stream.notElem x . stream
+
+-- | /O(n)/ Yield 'Just' the first element matching the predicate or 'Nothing'
+-- if no such element exists.
+find :: Vector v a => (a -> Bool) -> v a -> Maybe a
+{-# INLINE find #-}
+find f = Stream.find f . stream
+
+-- | /O(n)/ Yield 'Just' the index of the first element matching the predicate
+-- or 'Nothing' if no such element exists.
+findIndex :: Vector v a => (a -> Bool) -> v a -> Maybe Int
+{-# INLINE findIndex #-}
+findIndex f = Stream.findIndex f . stream
+
+-- | /O(n)/ Yield the indices of elements satisfying the predicate in ascending
+-- order.
+findIndices :: (Vector v a, Vector v Int) => (a -> Bool) -> v a -> v Int
+{-# INLINE findIndices #-}
+findIndices f = unstream
+              . inplace (MStream.map fst . MStream.filter (f . snd)
+                                         . MStream.indexed)
+              . stream
+
+-- | /O(n)/ Yield 'Just' the index of the first occurence of the given element or
+-- 'Nothing' if the vector does not contain the element. This is a specialised
+-- version of 'findIndex'.
+elemIndex :: (Vector v a, Eq a) => a -> v a -> Maybe Int
+{-# INLINE elemIndex #-}
+elemIndex x = findIndex (x==)
+
+-- | /O(n)/ Yield the indices of all occurences of the given element in
+-- ascending order. This is a specialised version of 'findIndices'.
+elemIndices :: (Vector v a, Vector v Int, Eq a) => a -> v a -> v Int
+{-# INLINE elemIndices #-}
+elemIndices x = findIndices (x==)
+
+-- Folding
+-- -------
+
+-- | /O(n)/ Left fold
+foldl :: Vector v b => (a -> b -> a) -> a -> v b -> a
+{-# INLINE foldl #-}
+foldl f z = Stream.foldl f z . stream
+
+-- | /O(n)/ Left fold on non-empty vectors
+foldl1 :: Vector v a => (a -> a -> a) -> v a -> a
+{-# INLINE foldl1 #-}
+foldl1 f = Stream.foldl1 f . stream
+
+-- | /O(n)/ Left fold with strict accumulator
+foldl' :: Vector v b => (a -> b -> a) -> a -> v b -> a
+{-# INLINE foldl' #-}
+foldl' f z = Stream.foldl' f z . stream
+
+-- | /O(n)/ Left fold on non-empty vectors with strict accumulator
+foldl1' :: Vector v a => (a -> a -> a) -> v a -> a
+{-# INLINE foldl1' #-}
+foldl1' f = Stream.foldl1' f . stream
+
+-- | /O(n)/ Right fold
+foldr :: Vector v a => (a -> b -> b) -> b -> v a -> b
+{-# INLINE foldr #-}
+foldr f z = Stream.foldr f z . stream
+
+-- | /O(n)/ Right fold on non-empty vectors
+foldr1 :: Vector v a => (a -> a -> a) -> v a -> a
+{-# INLINE foldr1 #-}
+foldr1 f = Stream.foldr1 f . stream
+
+-- | /O(n)/ Right fold with a strict accumulator
+foldr' :: Vector v a => (a -> b -> b) -> b -> v a -> b
+{-# INLINE foldr' #-}
+foldr' f z = Stream.foldl' (flip f) z . streamR
+
+-- | /O(n)/ Right fold on non-empty vectors with strict accumulator
+foldr1' :: Vector v a => (a -> a -> a) -> v a -> a
+{-# INLINE foldr1' #-}
+foldr1' f = Stream.foldl1' (flip f) . streamR
+
+-- | /O(n)/ Left fold (function applied to each element and its index)
+ifoldl :: Vector v b => (a -> Int -> b -> a) -> a -> v b -> a
+{-# INLINE ifoldl #-}
+ifoldl f z = Stream.foldl (uncurry . f) z . Stream.indexed . stream
+
+-- | /O(n)/ Left fold with strict accumulator (function applied to each element
+-- and its index)
+ifoldl' :: Vector v b => (a -> Int -> b -> a) -> a -> v b -> a
+{-# INLINE ifoldl' #-}
+ifoldl' f z = Stream.foldl' (uncurry . f) z . Stream.indexed . stream
+
+-- | /O(n)/ Right fold (function applied to each element and its index)
+ifoldr :: Vector v a => (Int -> a -> b -> b) -> b -> v a -> b
+{-# INLINE ifoldr #-}
+ifoldr f z = Stream.foldr (uncurry f) z . Stream.indexed . stream
+
+-- | /O(n)/ Right fold with strict accumulator (function applied to each
+-- element and its index)
+ifoldr' :: Vector v a => (Int -> a -> b -> b) -> b -> v a -> b
+{-# INLINE ifoldr' #-}
+ifoldr' f z xs = Stream.foldl' (flip (uncurry f)) z
+               $ Stream.indexedR (length xs) $ streamR xs
+
+-- Specialised folds
+-- -----------------
+
+-- | /O(n)/ Check if all elements satisfy the predicate.
+all :: Vector v a => (a -> Bool) -> v a -> Bool
+{-# INLINE all #-}
+all f = Stream.and . Stream.map f . stream
+
+-- | /O(n)/ Check if any element satisfies the predicate.
+any :: Vector v a => (a -> Bool) -> v a -> Bool
+{-# INLINE any #-}
+any f = Stream.or . Stream.map f . stream
+
+-- | /O(n)/ Check if all elements are 'True'
+and :: Vector v Bool => v Bool -> Bool
+{-# INLINE and #-}
+and = Stream.and . stream
+
+-- | /O(n)/ Check if any element is 'True'
+or :: Vector v Bool => v Bool -> Bool
+{-# INLINE or #-}
+or = Stream.or . stream
+
+-- | /O(n)/ Compute the sum of the elements
+sum :: (Vector v a, Num a) => v a -> a
+{-# INLINE sum #-}
+sum = Stream.foldl' (+) 0 . stream
+
+-- | /O(n)/ Compute the produce of the elements
+product :: (Vector v a, Num a) => v a -> a
+{-# INLINE product #-}
+product = Stream.foldl' (*) 1 . stream
+
+-- | /O(n)/ Yield the maximum element of the vector. The vector may not be
+-- empty.
+maximum :: (Vector v a, Ord a) => v a -> a
+{-# INLINE maximum #-}
+maximum = Stream.foldl1' max . stream
+
+-- | /O(n)/ Yield the maximum element of the vector according to the given
+-- comparison function. The vector may not be empty.
+maximumBy :: Vector v a => (a -> a -> Ordering) -> v a -> a
+{-# INLINE maximumBy #-}
+maximumBy cmp = Stream.foldl1' maxBy . stream
+  where
+    {-# INLINE maxBy #-}
+    maxBy x y = case cmp x y of
+                  LT -> y
+                  _  -> x
+
+-- | /O(n)/ Yield the minimum element of the vector. The vector may not be
+-- empty.
+minimum :: (Vector v a, Ord a) => v a -> a
+{-# INLINE minimum #-}
+minimum = Stream.foldl1' min . stream
+
+-- | /O(n)/ Yield the minimum element of the vector according to the given
+-- comparison function. The vector may not be empty.
+minimumBy :: Vector v a => (a -> a -> Ordering) -> v a -> a
+{-# INLINE minimumBy #-}
+minimumBy cmp = Stream.foldl1' minBy . stream
+  where
+    {-# INLINE minBy #-}
+    minBy x y = case cmp x y of
+                  GT -> y
+                  _  -> x
+
+-- | /O(n)/ Yield the index of the maximum element of the vector. The vector
+-- may not be empty.
+maxIndex :: (Vector v a, Ord a) => v a -> Int
+{-# INLINE maxIndex #-}
+maxIndex = maxIndexBy compare
+
+-- | /O(n)/ Yield the index of the maximum element of the vector according to
+-- the given comparison function. The vector may not be empty.
+maxIndexBy :: Vector v a => (a -> a -> Ordering) -> v a -> Int
+{-# INLINE maxIndexBy #-}
+maxIndexBy cmp = fst . Stream.foldl1' imax . Stream.indexed . stream
+  where
+    imax (i,x) (j,y) = i `seq` j `seq`
+                       case cmp x y of
+                         LT -> (j,y)
+                         _  -> (i,x)
+
+-- | /O(n)/ Yield the index of the minimum element of the vector. The vector
+-- may not be empty.
+minIndex :: (Vector v a, Ord a) => v a -> Int
+{-# INLINE minIndex #-}
+minIndex = minIndexBy compare
+
+-- | /O(n)/ Yield the index of the minimum element of the vector according to
+-- the given comparison function. The vector may not be empty.
+minIndexBy :: Vector v a => (a -> a -> Ordering) -> v a -> Int
+{-# INLINE minIndexBy #-}
+minIndexBy cmp = fst . Stream.foldl1' imin . Stream.indexed . stream
+  where
+    imin (i,x) (j,y) = i `seq` j `seq`
+                       case cmp x y of
+                         GT -> (j,y)
+                         _  -> (i,x)
+
+-- Monadic folds
+-- -------------
+
+-- | /O(n)/ Monadic fold
+foldM :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> v b -> m a
+{-# INLINE foldM #-}
+foldM m z = Stream.foldM m z . stream
+
+-- | /O(n)/ Monadic fold over non-empty vectors
+fold1M :: (Monad m, Vector v a) => (a -> a -> m a) -> v a -> m a
+{-# INLINE fold1M #-}
+fold1M m = Stream.fold1M m . stream
+
+-- | /O(n)/ Monadic fold with strict accumulator
+foldM' :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> v b -> m a
+{-# INLINE foldM' #-}
+foldM' m z = Stream.foldM' m z . stream
+
+-- | /O(n)/ Monad fold over non-empty vectors with strict accumulator
+fold1M' :: (Monad m, Vector v a) => (a -> a -> m a) -> v a -> m a
+{-# INLINE fold1M' #-}
+fold1M' m = Stream.fold1M' m . stream
+
+-- Prefix sums (scans)
+-- -------------------
+
+-- | /O(n)/ Prescan
+--
+-- @
+-- prescanl f z = 'init' . 'scanl' f z
+-- @
+--
+-- Example: @prescanl (+) 0 \<1,2,3,4\> = \<0,1,3,6\>@
+--
+prescanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
+{-# INLINE prescanl #-}
+prescanl f z = unstream . inplace (MStream.prescanl f z) . stream
+
+-- | /O(n)/ Prescan with strict accumulator
+prescanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
+{-# INLINE prescanl' #-}
+prescanl' f z = unstream . inplace (MStream.prescanl' f z) . stream
+
+-- | /O(n)/ Scan
+--
+-- @
+-- postscanl f z = 'tail' . 'scanl' f z
+-- @
+--
+-- Example: @postscanl (+) 0 \<1,2,3,4\> = \<1,3,6,10\>@
+--
+postscanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
+{-# INLINE postscanl #-}
+postscanl f z = unstream . inplace (MStream.postscanl f z) . stream
+
+-- | /O(n)/ Scan with strict accumulator
+postscanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
+{-# INLINE postscanl' #-}
+postscanl' f z = unstream . inplace (MStream.postscanl' f z) . stream
+
+-- | /O(n)/ Haskell-style scan
+--
+-- > scanl f z <x1,...,xn> = <y1,...,y(n+1)>
+-- >   where y1 = z
+-- >         yi = f y(i-1) x(i-1)
+--
+-- Example: @scanl (+) 0 \<1,2,3,4\> = \<0,1,3,6,10\>@
+-- 
+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
+
+-- | /O(n)/ Haskell-style scan with strict accumulator
+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
+
+-- | /O(n)/ Scan over a non-empty vector
+--
+-- > scanl f <x1,...,xn> = <y1,...,yn>
+-- >   where y1 = x1
+-- >         yi = f y(i-1) xi
+--
+scanl1 :: Vector v a => (a -> a -> a) -> v a -> v a
+{-# INLINE scanl1 #-}
+scanl1 f = unstream . inplace (MStream.scanl1 f) . stream
+
+-- | /O(n)/ Scan over a non-empty vector with a strict accumulator
+scanl1' :: Vector v a => (a -> a -> a) -> v a -> v a
+{-# INLINE scanl1' #-}
+scanl1' f = unstream . inplace (MStream.scanl1' f) . stream
+
+-- | /O(n)/ Right-to-left prescan
+--
+-- @
+-- prescanr f z = 'reverse' . 'prescanl' (flip f) z . 'reverse'
+-- @
+--
+prescanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
+{-# INLINE prescanr #-}
+prescanr f z = unstreamR . inplace (MStream.prescanl (flip f) z) . streamR
+
+-- | /O(n)/ Right-to-left prescan with strict accumulator
+prescanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
+{-# INLINE prescanr' #-}
+prescanr' f z = unstreamR . inplace (MStream.prescanl' (flip f) z) . streamR
+
+-- | /O(n)/ Right-to-left scan
+postscanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
+{-# INLINE postscanr #-}
+postscanr f z = unstreamR . inplace (MStream.postscanl (flip f) z) . streamR
+
+-- | /O(n)/ Right-to-left scan with strict accumulator
+postscanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
+{-# INLINE postscanr' #-}
+postscanr' f z = unstreamR . inplace (MStream.postscanl' (flip f) z) . streamR
+
+-- | /O(n)/ Right-to-left Haskell-style scan
+scanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
+{-# INLINE scanr #-}
+scanr f z = unstreamR . Stream.scanl (flip f) z . streamR
+
+-- | /O(n)/ Right-to-left Haskell-style scan with strict accumulator
+scanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
+{-# INLINE scanr' #-}
+scanr' f z = unstreamR . Stream.scanl' (flip f) z . streamR
+
+-- | /O(n)/ Right-to-left scan over a non-empty vector
+scanr1 :: Vector v a => (a -> a -> a) -> v a -> v a
+{-# INLINE scanr1 #-}
+scanr1 f = unstreamR . inplace (MStream.scanl1 (flip f)) . streamR
+
+-- | /O(n)/ Right-to-left scan over a non-empty vector with a strict
+-- accumulator
+scanr1' :: Vector v a => (a -> a -> a) -> v a -> v a
+{-# INLINE scanr1' #-}
+scanr1' f = unstreamR . inplace (MStream.scanl1' (flip f)) . streamR
+
+-- Conversions - Lists
+-- ------------------------
+
+-- | /O(n)/ Convert a vector to a list
+toList :: Vector v a => v a -> [a]
+{-# INLINE toList #-}
+toList = Stream.toList . stream
+
+-- | /O(n)/ Convert a list to a vector
+fromList :: Vector v a => [a] -> v a
+{-# INLINE fromList #-}
+fromList = unstream . Stream.fromList
+
+-- | /O(n)/ Convert the first @n@ elements of a list to a vector
+--
+-- @
+-- fromListN n xs = 'fromList' ('take' n xs)
+-- @
+fromListN :: Vector v a => Int -> [a] -> v a
+{-# INLINE fromListN #-}
+fromListN n = unstream . Stream.fromListN n
+
+-- Conversions - Mutable vectors
+-- -----------------------------
+
+-- | /O(n)/ Copy an immutable vector into a mutable one. The two vectors must
+-- have the same length.
+copy
+  :: (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> v a -> m ()
+{-# INLINE copy #-}
+copy dst src = BOUNDS_CHECK(check) "copy" "length mismatch"
+                                          (M.length dst == length src)
+             $ unsafeCopy dst src
+
+-- | /O(n)/ Copy an immutable vector into a mutable one. The two vectors must
+-- have the same length. This is not checked.
+unsafeCopy
+  :: (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> v a -> m ()
+{-# INLINE unsafeCopy #-}
+unsafeCopy dst src = UNSAFE_CHECK(check) "unsafeCopy" "length mismatch"
+                                         (M.length dst == length src)
+                   $ (dst `seq` src `seq` basicUnsafeCopy dst src)
+
+-- Conversions to/from Streams
+-- ---------------------------
+
+-- | /O(1)/ Convert a vector to a 'Stream'
+stream :: Vector v a => v a -> Stream a
+{-# INLINE_STREAM stream #-}
+stream v = v `seq` (Stream.unfoldr get 0 `Stream.sized` Exact n)
+  where
+    n = length v
+
+    -- NOTE: the False case comes first in Core so making it the recursive one
+    -- makes the code easier to read
+    {-# INLINE get #-}
+    get i | i >= n    = Nothing
+          | otherwise = case basicUnsafeIndexM v i of Box x -> Just (x, i+1)
+
+-- | /O(n)/ Construct a vector from a 'Stream'
+unstream :: Vector v a => Stream a -> v a
+{-# INLINE unstream #-}
+unstream s = new (New.unstream s)
+
+{-# RULES
+
+"stream/unstream [Vector]" forall s.
+  stream (new (New.unstream s)) = s
+
+"New.unstream/stream [Vector]" forall v.
+  New.unstream (stream v) = clone v
+
+"clone/new [Vector]" forall p.
+  clone (new p) = p
+
+"inplace [Vector]"
+  forall (f :: forall m. Monad m => MStream m a -> MStream m a) m.
+  New.unstream (inplace f (stream (new m))) = New.transform f m
+
+"uninplace [Vector]"
+  forall (f :: forall m. Monad m => MStream m a -> MStream m a) m.
+  stream (new (New.transform f m)) = inplace f (stream (new m))
+
+ #-}
+
+-- | /O(1)/ Convert a vector to a 'Stream', proceeding from right to left
+streamR :: Vector v a => v a -> Stream a
+{-# INLINE_STREAM streamR #-}
+streamR v = v `seq` (Stream.unfoldr get n `Stream.sized` Exact n)
+  where
+    n = length v
+
+    {-# INLINE get #-}
+    get 0 = Nothing
+    get i = let i' = i-1
+            in
+            case basicUnsafeIndexM v i' of Box x -> Just (x, i')
+
+-- | /O(n)/ Construct a vector from a 'Stream', proceeding from right to left
+unstreamR :: Vector v a => Stream a -> v a
+{-# INLINE unstreamR #-}
+unstreamR s = new (New.unstreamR s)
+
+{-# RULES
+
+"streamR/unstreamR [Vector]" forall s.
+  streamR (new (New.unstreamR s)) = s
+
+"New.unstreamR/streamR/new [Vector]" forall p.
+  New.unstreamR (streamR (new p)) = p
+
+"inplace right [Vector]"
+  forall (f :: forall m. Monad m => MStream m a -> MStream m a) m.
+  New.unstreamR (inplace f (streamR (new m))) = New.transformR f m
+
+"uninplace right [Vector]"
+  forall (f :: forall m. Monad m => MStream m a -> MStream m a) m.
+  streamR (new (New.transformR f m)) = inplace f (streamR (new m))
+
+ #-}
+
+unstreamM :: (Vector v a, Monad m) => MStream m a -> m (v a)
+{-# INLINE_STREAM unstreamM #-}
+unstreamM s = do
+                xs <- MStream.toList s
+                return $ unstream $ Stream.unsafeFromList (MStream.size s) xs
+
+-- Recycling support
+-- -----------------
+
+-- | Construct a vector from a monadic initialiser.
+new :: Vector v a => New v a -> v a
+{-# INLINE_STREAM new #-}
+new m = m `seq` runST (unsafeFreeze =<< New.run m)
+
+-- | Convert a vector to an initialiser which, when run, produces a copy of
+-- the vector.
+clone :: Vector v a => v a -> New v a
+{-# INLINE_STREAM clone #-}
+clone v = v `seq` New.create (
+  do
+    mv <- M.new (length v)
+    unsafeCopy mv v
+    return mv)
+
+-- Comparisons
+-- -----------
+
+-- | /O(n)/ Check if two vectors are equal. All 'Vector' instances are also
+-- instances of 'Eq' and it is usually more appropriate to use those. This
+-- function is primarily intended for implementing 'Eq' instances for new
+-- vector types.
+eq :: (Vector v a, Eq a) => v a -> v a -> Bool
+{-# INLINE eq #-}
+xs `eq` ys = stream xs == stream ys
+
+-- | /O(n)/ Compare two vectors lexicographically. All 'Vector' instances are
+-- also instances of 'Ord' and it is usually more appropriate to use those. This
+-- function is primarily intended for implementing 'Ord' instances for new
+-- vector types.
+cmp :: (Vector v a, Ord a) => v a -> v a -> Ordering
+{-# INLINE cmp #-}
+cmp xs ys = compare (stream xs) (stream ys)
+
+-- Data and Typeable
+-- -----------------
 
 -- | Generic definion of 'Data.Data.gfoldl' that views a 'Vector' as a
 -- list.
diff --git a/Data/Vector/Generic/Base.hs b/Data/Vector/Generic/Base.hs
--- a/Data/Vector/Generic/Base.hs
+++ b/Data/Vector/Generic/Base.hs
@@ -1,5 +1,6 @@
 {-# LANGUAGE Rank2Types, MultiParamTypeClasses, FlexibleContexts,
              TypeFamilies, ScopedTypeVariables #-}
+{-# OPTIONS_HADDOCK hide #-}
 
 -- |
 -- Module      : Data.Vector.Generic.Base
@@ -27,23 +28,49 @@
 --
 type family Mutable (v :: * -> *) :: * -> * -> *
 
--- | Class of immutable vectors.
+-- | Class of immutable vectors. Every immutable vector is associated with its
+-- mutable version through the 'Mutable' type family. Methods of this class
+-- should not be used directly. Instead, "Data.Vector.Generic" and other
+-- Data.Vector modules provide safe and fusible wrappers.
 --
+-- Minimum complete implementation:
+--
+--   * 'unsafeFreeze'
+--
+--   * 'basicLength'
+--
+--   * 'basicUnsafeSlice'
+--
+--   * 'basicUnsafeIndexM'
+--
 class MVector (Mutable v) a => Vector v a where
-  -- | Unsafely convert a mutable vector to its immutable version
+  -- | /Assume complexity: O(1)/
+  --
+  -- Unsafely convert a mutable vector to its immutable version
   -- without copying. The mutable vector may not be used after
   -- this operation.
   unsafeFreeze :: PrimMonad m => Mutable v (PrimState m) a -> m (v a)
 
-  -- | Length of the vector (not fusible!)
+  -- | /Assumed complexity: O(1)/
+  --
+  -- Yield the length of the vector.
   basicLength      :: v a -> Int
 
-  -- | Yield a part of the vector without copying it. No range checks!
-  basicUnsafeSlice  :: Int -> Int -> v a -> v a
+  -- | /Assumed complexity: O(1)/
+  --
+  -- Yield a slice of the vector without copying it. No range checks are
+  -- performed.
+  basicUnsafeSlice  :: Int -- ^ starting index
+                    -> Int -- ^ length
+                    -> v a -> v a
 
-  -- | Yield the element at the given position in a monad. The monad allows us
-  -- to be strict in the vector if we want. Suppose we had
+  -- | /Assumed complexity: O(1)/
   --
+  -- Yield the element at the given position in a monad. No range checks are
+  -- performed.
+  --
+  -- The monad allows us to be strict in the vector if we want. Suppose we had
+  --
   -- > unsafeIndex :: v a -> Int -> a
   --
   -- instead. Now, if we wanted to copy a vector, we'd do something like
@@ -64,7 +91,16 @@
   --
   basicUnsafeIndexM  :: Monad m => v a -> Int -> m a
 
-  -- | Copy an immutable vector into a mutable one.
+  -- |  /Assumed complexity: O(n)/
+  --
+  -- Copy an immutable vector into a mutable one. The two vectors must have
+  -- the same length but this is not checked.
+  --
+  -- Instances of 'Vector' should redefine this method if they wish to support
+  -- an efficient block copy operation.
+  --
+  -- Default definition: copying basic on 'basicUnsafeIndexM' and
+  -- 'basicUnsafeWrite'.
   basicUnsafeCopy :: PrimMonad m => Mutable v (PrimState m) a -> v a -> m ()
 
   {-# INLINE basicUnsafeCopy #-}
@@ -78,6 +114,16 @@
                             do_copy (i+1)
                 | otherwise = return ()
 
+  -- | Evaluate @a@ as far as storing it in a vector would and yield @b@.
+  -- The @v a@ argument only fixes the type and is not touched. The method is
+  -- only used for optimisation purposes. Thus, it is safe for instances of
+  -- 'Vector' to evaluate @a@ less than it would be when stored in a vector
+  -- although this might result in suboptimal code.
+  --
+  -- > elemseq v x y = (singleton x `asTypeOf` v) `seq` y
+  --
+  -- Default defintion: @a@ is not evaluated at all
+  --
   elemseq :: v a -> a -> b -> b
 
   {-# INLINE elemseq #-}
diff --git a/Data/Vector/Primitive.hs b/Data/Vector/Primitive.hs
--- a/Data/Vector/Primitive.hs
+++ b/Data/Vector/Primitive.hs
@@ -9,61 +9,110 @@
 -- Stability   : experimental
 -- Portability : non-portable
 -- 
--- Unboxed vectors of primitive types.
+-- Unboxed vectors of primitive types. The use of this module is not
+-- recommended except in very special cases. Adaptive unboxed vectors defined
+-- in "Data.Vector.Unboxed" are significantly more flexible at no performance
+-- cost.
 --
 
 module Data.Vector.Primitive (
+  -- * Primitive vectors
   Vector, MVector(..), Prim,
 
-  -- * Length information
-  length, null,
+  -- * Accessors
 
-  -- * Construction
-  empty, singleton, cons, snoc, replicate, generate, (++), force,
+  -- ** Length information
+  length, null,
 
-  -- * Accessing individual elements
-  (!), head, last, indexM, headM, lastM,
+  -- ** Indexing
+  (!), head, last,
   unsafeIndex, unsafeHead, unsafeLast,
+
+  -- ** Monadic indexing
+  indexM, headM, lastM,
   unsafeIndexM, unsafeHeadM, unsafeLastM,
 
-  -- * Subvectors
+  -- ** Extracting subvectors (slicing)
   slice, init, tail, take, drop,
   unsafeSlice, unsafeInit, unsafeTail, unsafeTake, unsafeDrop,
 
-  -- * Permutations
-  accum, accumulate_, (//), update_, backpermute, reverse,
-  unsafeAccum, unsafeAccumulate_,
+  -- * Construction
+
+  -- ** Initialisation
+  empty, singleton, replicate, generate,
+
+  -- ** Monadic initialisation
+  replicateM, create,
+
+  -- ** Unfolding
+  unfoldr, unfoldrN,
+
+  -- ** Enumeration
+  enumFromN, enumFromStepN, enumFromTo, enumFromThenTo,
+
+  -- ** Concatenation
+  cons, snoc, (++),
+
+  -- ** Restricting memory usage
+  force,
+
+  -- * Modifying vectors
+
+  -- ** Bulk updates
+  (//), update_,
   unsafeUpd, unsafeUpdate_,
-  unsafeBackpermute,
 
-  -- * Mapping
+  -- ** Accumulations
+  accum, accumulate_,
+  unsafeAccum, unsafeAccumulate_,
+
+  -- ** Permutations 
+  reverse, backpermute, unsafeBackpermute,
+
+  -- ** Safe destructive updates
+  modify,
+
+  -- * Elementwise operations
+
+  -- ** Mapping
   map, imap, concatMap,
 
-  -- * Zipping and unzipping
+  -- ** Monadic mapping
+  mapM, mapM_, forM, forM_,
+
+  -- ** Zipping
   zipWith, zipWith3, zipWith4, zipWith5, zipWith6,
   izipWith, izipWith3, izipWith4, izipWith5, izipWith6,
 
-  -- * Filtering
-  filter, ifilter, takeWhile, dropWhile,
+  -- ** Monadic zipping
+  zipWithM, zipWithM_,
+
+  -- * Working with predicates
+
+  -- ** Filtering
+  filter, ifilter, filterM,
+  takeWhile, dropWhile,
+
+  -- ** Partitioning
   partition, unstablePartition, span, break,
 
-  -- * Searching
+  -- ** Searching
   elem, notElem, find, findIndex, findIndices, elemIndex, elemIndices,
 
   -- * Folding
   foldl, foldl1, foldl', foldl1', foldr, foldr1, foldr', foldr1',
   ifoldl, ifoldl', ifoldr, ifoldr',
 
-  -- * Specialised folds
+  -- ** Specialised folds
   all, any,
   sum, product,
   maximum, maximumBy, minimum, minimumBy,
   minIndex, minIndexBy, maxIndex, maxIndexBy,
 
-  -- * Unfolding
-  unfoldr, unfoldrN,
+  -- ** Monadic folds
+  foldM, foldM', fold1M, fold1M',
 
-  -- * Scans
+  -- * Prefix sums (scans)
   prescanl, prescanl',
   postscanl, postscanl',
   scanl, scanl', scanl1, scanl1',
@@ -71,18 +120,13 @@
   postscanr, postscanr',
   scanr, scanr', scanr1, scanr1',
 
-  -- * Enumeration
-  enumFromN, enumFromStepN, enumFromTo, enumFromThenTo,
+  -- * Conversions
 
-  -- * Conversion to/from lists
+  -- ** Lists
   toList, fromList, fromListN,
 
-  -- * Monadic operations
-  replicateM, mapM, mapM_, forM, forM_, zipWithM, zipWithM_, filterM,
-  foldM, foldM', fold1M, fold1M',
-
-  -- * Destructive operations
-  create, modify, copy, unsafeCopy
+  -- ** Mutable vectors
+  copy, unsafeCopy
 ) where
 
 import qualified Data.Vector.Generic           as G
@@ -184,248 +228,475 @@
 -- Length
 -- ------
 
+-- | /O(1)/ Yield the length of the vector.
 length :: Prim a => Vector a -> Int
 {-# INLINE length #-}
 length = G.length
 
+-- | /O(1)/ Test whether a vector if empty
 null :: Prim a => Vector a -> Bool
 {-# INLINE null #-}
 null = G.null
 
--- Construction
--- ------------
-
--- | Empty vector
-empty :: Prim a => Vector a
-{-# INLINE empty #-}
-empty = G.empty
-
--- | Vector with exaclty one element
-singleton :: Prim a => a -> Vector a
-{-# INLINE 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 = G.replicate
-
--- | Generate a vector of the given length by applying the function to each
--- index
-generate :: Prim a => Int -> (Int -> a) -> Vector a
-{-# INLINE generate #-}
-generate = G.generate
-
--- | Prepend an element
-cons :: Prim a => a -> Vector a -> Vector a
-{-# INLINE cons #-}
-cons = G.cons
-
--- | Append an element
-snoc :: Prim a => Vector a -> a -> Vector a
-{-# INLINE snoc #-}
-snoc = G.snoc
-
-infixr 5 ++
--- | Concatenate two vectors
-(++) :: Prim a => Vector a -> Vector a -> Vector a
-{-# INLINE (++) #-}
-(++) = (G.++)
-
--- | Create a copy of a vector. Useful when dealing with slices.
-force :: Prim a => Vector a -> Vector a
-{-# INLINE force #-}
-force = G.force
-
--- Accessing individual elements
--- -----------------------------
+-- Indexing
+-- --------
 
--- | Indexing
+-- | O(1) Indexing
 (!) :: Prim a => Vector a -> Int -> a
 {-# INLINE (!) #-}
 (!) = (G.!)
 
--- | First element
+-- | /O(1)/ First element
 head :: Prim a => Vector a -> a
 {-# INLINE head #-}
 head = G.head
 
--- | Last element
+-- | /O(1)/ Last element
 last :: Prim a => Vector a -> a
 {-# INLINE last #-}
 last = G.last
 
--- | Unsafe indexing without bounds checking
+-- | /O(1)/ Unsafe indexing without bounds checking
 unsafeIndex :: Prim a => Vector a -> Int -> a
 {-# INLINE unsafeIndex #-}
 unsafeIndex = G.unsafeIndex
 
--- | Yield the first element of a vector without checking if the vector is
--- empty
+-- | /O(1)/ First element without checking if the vector is empty
 unsafeHead :: Prim a => Vector a -> a
 {-# INLINE unsafeHead #-}
 unsafeHead = G.unsafeHead
 
--- | Yield the last element of a vector without checking if the vector is
--- empty
+-- | /O(1)/ Last element without checking if the vector is empty
 unsafeLast :: Prim a => Vector a -> a
 {-# INLINE unsafeLast #-}
 unsafeLast = G.unsafeLast
 
--- | Monadic indexing which can be strict in the vector while remaining lazy in
--- the element
+-- Monadic indexing
+-- ----------------
+
+-- | /O(1)/ Indexing in a monad.
+--
+-- The monad allows operations to be strict in the vector when necessary.
+-- Suppose vector copying is implemented like this:
+--
+-- > copy mv v = ... write mv i (v ! i) ...
+--
+-- For lazy vectors, @v ! i@ would not be evaluated which means that @mv@
+-- would unnecessarily retain a reference to @v@ in each element written.
+--
+-- With 'indexM', copying can be implemented like this instead:
+--
+-- > copy mv v = ... do
+-- >                   x <- indexM v i
+-- >                   write mv i x
+--
+-- Here, no references to @v@ are retained because indexing (but /not/ the
+-- elements) is evaluated eagerly.
+--
 indexM :: (Prim a, Monad m) => Vector a -> Int -> m a
 {-# INLINE indexM #-}
 indexM = G.indexM
 
+-- | /O(1)/ First element of a vector in a monad. See 'indexM' for an
+-- explanation of why this is useful.
 headM :: (Prim a, Monad m) => Vector a -> m a
 {-# INLINE headM #-}
 headM = G.headM
 
+-- | /O(1)/ Last element of a vector in a monad. See 'indexM' for an
+-- explanation of why this is useful.
 lastM :: (Prim a, Monad m) => Vector a -> m a
 {-# INLINE lastM #-}
 lastM = G.lastM
 
--- | Unsafe monadic indexing without bounds checks
+-- | /O(1)/ Indexing in a monad without bounds checks. See 'indexM' for an
+-- explanation of why this is useful.
 unsafeIndexM :: (Prim a, Monad m) => Vector a -> Int -> m a
 {-# INLINE unsafeIndexM #-}
 unsafeIndexM = G.unsafeIndexM
 
+-- | /O(1)/ First element in a monad without checking for empty vectors.
+-- See 'indexM' for an explanation of why this is useful.
 unsafeHeadM :: (Prim a, Monad m) => Vector a -> m a
 {-# INLINE unsafeHeadM #-}
 unsafeHeadM = G.unsafeHeadM
 
+-- | /O(1)/ Last element in a monad without checking for empty vectors.
+-- See 'indexM' for an explanation of why this is useful.
 unsafeLastM :: (Prim a, Monad m) => Vector a -> m a
 {-# INLINE unsafeLastM #-}
 unsafeLastM = G.unsafeLastM
 
--- Subarrays
--- ---------
+-- Extracting subvectors (slicing)
+-- -------------------------------
 
--- | Yield a part of the vector without copying it. Safer version of
--- 'basicUnsafeSlice'.
-slice :: Prim a => Int   -- ^ starting index
-                -> Int   -- ^ length
-                -> Vector a
-                -> Vector a
+-- | /O(1)/ Yield a slice of the vector without copying it. The vector must
+-- contain at least @i+n@ elements.
+slice :: Prim a
+      => Int   -- ^ @i@ starting index
+      -> Int   -- ^ @n@ length
+      -> Vector a
+      -> Vector a
 {-# INLINE slice #-}
 slice = G.slice
 
--- | Yield all but the last element without copying.
+-- | /O(1)/ Yield all but the last element without copying. The vector may not
+-- be empty.
 init :: Prim a => Vector a -> Vector a
 {-# INLINE init #-}
 init = G.init
 
--- | All but the first element (without copying).
+-- | /O(1)/ Yield all but the first element without copying. The vector may not
+-- be empty.
 tail :: Prim a => Vector a -> Vector a
 {-# INLINE tail #-}
 tail = G.tail
 
--- | Yield the first @n@ elements without copying.
+-- | /O(1)/ Yield at the first @n@ elements without copying. The vector may
+-- contain less than @n@ elements in which case it is returned unchanged.
 take :: Prim a => Int -> Vector a -> Vector a
 {-# INLINE take #-}
 take = G.take
 
--- | Yield all but the first @n@ elements without copying.
+-- | /O(1)/ Yield all but the first @n@ elements without copying. The vector may
+-- contain less than @n@ elements in which case an empty vector is returned.
 drop :: Prim a => Int -> Vector a -> Vector a
 {-# INLINE drop #-}
 drop = G.drop
 
--- | Unsafely yield a part of the vector without copying it and without
--- performing bounds checks.
-unsafeSlice :: Prim a => Int   -- ^ starting index
-                      -> Int   -- ^ length
-                      -> Vector a
-                      -> Vector a
+-- | /O(1)/ Yield a slice of the vector without copying. The vector must
+-- contain at least @i+n@ elements but this is not checked.
+unsafeSlice :: Prim a => Int   -- ^ @i@ starting index
+                       -> Int   -- ^ @n@ length
+                       -> Vector a
+                       -> Vector a
 {-# INLINE unsafeSlice #-}
 unsafeSlice = G.unsafeSlice
 
+-- | /O(1)/ Yield all but the last element without copying. The vector may not
+-- be empty but this is not checked.
 unsafeInit :: Prim a => Vector a -> Vector a
 {-# INLINE unsafeInit #-}
 unsafeInit = G.unsafeInit
 
+-- | /O(1)/ Yield all but the first element without copying. The vector may not
+-- be empty but this is not checked.
 unsafeTail :: Prim a => Vector a -> Vector a
 {-# INLINE unsafeTail #-}
 unsafeTail = G.unsafeTail
 
+-- | /O(1)/ Yield the first @n@ elements without copying. The vector must
+-- contain at least @n@ elements but this is not checked.
 unsafeTake :: Prim a => Int -> Vector a -> Vector a
 {-# INLINE unsafeTake #-}
 unsafeTake = G.unsafeTake
 
+-- | /O(1)/ Yield all but the first @n@ elements without copying. The vector
+-- must contain at least @n@ elements but this is not checked.
 unsafeDrop :: Prim a => Int -> Vector a -> Vector a
 {-# INLINE unsafeDrop #-}
 unsafeDrop = G.unsafeDrop
 
--- Permutations
--- ------------
+-- Initialisation
+-- --------------
 
-unsafeAccum :: Prim a => (a -> b -> a) -> Vector a -> [(Int,b)] -> Vector a
-{-# INLINE unsafeAccum #-}
-unsafeAccum = G.unsafeAccum
+-- | /O(1)/ Empty vector
+empty :: Prim a => Vector a
+{-# INLINE empty #-}
+empty = G.empty
 
-unsafeAccumulate_ :: (Prim a, Prim b) =>
-               (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
-{-# INLINE unsafeAccumulate_ #-}
-unsafeAccumulate_ = G.unsafeAccumulate_
+-- | /O(1)/ Vector with exactly one element
+singleton :: Prim a => a -> Vector a
+{-# INLINE singleton #-}
+singleton = G.singleton
 
-accum :: Prim a => (a -> b -> a) -> Vector a -> [(Int,b)] -> Vector a
-{-# INLINE accum #-}
-accum = G.accum
+-- | /O(n)/ Vector of the given length with the same value in each position
+replicate :: Prim a => Int -> a -> Vector a
+{-# INLINE replicate #-}
+replicate = G.replicate
 
-accumulate_ :: (Prim a, Prim b) =>
-               (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
-{-# INLINE accumulate_ #-}
-accumulate_ = G.accumulate_
+-- | /O(n)/ Construct a vector of the given length by applying the function to
+-- each index
+generate :: Prim a => Int -> (Int -> a) -> Vector a
+{-# INLINE generate #-}
+generate = G.generate
 
+-- Unfolding
+-- ---------
+
+-- | /O(n)/ Construct a vector by repeatedly applying the generator function
+-- to a seed. The generator function yields 'Just' the next element and the
+-- new seed or 'Nothing' if there are no more elements.
+--
+-- > unfoldr (\n -> if n == 0 then Nothing else Just (n,n-1)) 10
+-- >  = <10,9,8,7,6,5,4,3,2,1>
+unfoldr :: Prim a => (b -> Maybe (a, b)) -> b -> Vector a
+{-# INLINE unfoldr #-}
+unfoldr = G.unfoldr
+
+-- | /O(n)/ Construct a vector with at most @n@ by repeatedly applying the
+-- generator function to the a seed. The generator function yields 'Just' the
+-- next element and the new seed or 'Nothing' if there are no more elements.
+--
+-- > unfoldrN 3 (\n -> Just (n,n-1)) 10 = <10,9,8>
+unfoldrN :: Prim a => Int -> (b -> Maybe (a, b)) -> b -> Vector a
+{-# INLINE unfoldrN #-}
+unfoldrN = G.unfoldrN
+
+-- Enumeration
+-- -----------
+
+-- | /O(n)/ Yield a vector of the given length containing the values @x@, @x+1@
+-- etc. This operation is usually more efficient than 'enumFromTo'.
+--
+-- > enumFromN 5 3 = <5,6,7>
+enumFromN :: (Prim a, Num a) => a -> Int -> Vector a
+{-# INLINE enumFromN #-}
+enumFromN = G.enumFromN
+
+-- | /O(n)/ Yield a vector of the given length containing the values @x@, @x+y@,
+-- @x+y+y@ etc. This operations is usually more efficient than 'enumFromThenTo'.
+--
+-- > enumFromStepN 1 0.1 5 = <1,1.1,1.2,1.3,1.4>
+enumFromStepN :: (Prim a, Num a) => a -> a -> Int -> Vector a
+{-# INLINE enumFromStepN #-}
+enumFromStepN = G.enumFromStepN
+
+-- | /O(n)/ Enumerate values from @x@ to @y@.
+--
+-- /WARNING:/ This operation can be very inefficient. If at all possible, use
+-- 'enumFromN' instead.
+enumFromTo :: (Prim a, Enum a) => a -> a -> Vector a
+{-# INLINE enumFromTo #-}
+enumFromTo = G.enumFromTo
+
+-- | /O(n)/ Enumerate values from @x@ to @y@ with a specific step @z@.
+--
+-- /WARNING:/ This operation can be very inefficient. If at all possible, use
+-- 'enumFromStepN' instead.
+enumFromThenTo :: (Prim a, Enum a) => a -> a -> a -> Vector a
+{-# INLINE enumFromThenTo #-}
+enumFromThenTo = G.enumFromThenTo
+
+-- Concatenation
+-- -------------
+
+-- | /O(n)/ Prepend an element
+cons :: Prim a => a -> Vector a -> Vector a
+{-# INLINE cons #-}
+cons = G.cons
+
+-- | /O(n)/ Append an element
+snoc :: Prim a => Vector a -> a -> Vector a
+{-# INLINE snoc #-}
+snoc = G.snoc
+
+infixr 5 ++
+-- | /O(m+n)/ Concatenate two vectors
+(++) :: Prim a => Vector a -> Vector a -> Vector a
+{-# INLINE (++) #-}
+(++) = (G.++)
+
+-- Monadic initialisation
+-- ----------------------
+
+-- | /O(n)/ Execute the monadic action the given number of times and store the
+-- results in a vector.
+replicateM :: (Monad m, Prim a) => Int -> m a -> m (Vector a)
+{-# INLINE replicateM #-}
+replicateM = G.replicateM
+
+-- | Execute the monadic action and freeze the resulting vector.
+--
+-- @
+-- create (do { v \<- new 2; write v 0 \'a\'; write v 1 \'b\' }) = \<'a','b'\>
+-- @
+create :: Prim a => (forall s. ST s (MVector s a)) -> Vector a
+{-# INLINE create #-}
+create = G.create
+
+-- Restricting memory usage
+-- ------------------------
+
+-- | /O(n)/ Yield the argument but force it not to retain any extra memory,
+-- possibly by copying it.
+--
+-- This is especially useful when dealing with slices. For example:
+--
+-- > force (slice 0 2 <huge vector>)
+--
+-- Here, the slice retains a reference to the huge vector. Forcing it creates
+-- a copy of just the elements that belong to the slice and allows the huge
+-- vector to be garbage collected.
+force :: Prim a => Vector a -> Vector a
+{-# INLINE force #-}
+force = G.force
+
+-- Bulk updates
+-- ------------
+
+-- | /O(m+n)/ For each pair @(i,a)@ from the list, replace the vector
+-- element at position @i@ by @a@.
+--
+-- > <5,9,2,7> // [(2,1),(0,3),(2,8)] = <3,9,8,7>
+--
+(//) :: Prim a => Vector a   -- ^ initial vector (of length @m@)
+                -> [(Int, a)] -- ^ list of index/value pairs (of length @n@) 
+                -> Vector a
+{-# INLINE (//) #-}
+(//) = (G.//)
+
+-- | /O(m+min(n1,n2))/ For each index @i@ from the index vector and the
+-- corresponding value @a@ from the value vector, replace the element of the
+-- initial vector at position @i@ by @a@.
+--
+-- > update_ <5,9,2,7>  <2,0,2> <1,3,8> = <3,9,8,7>
+--
+update_ :: Prim a
+        => Vector a   -- ^ initial vector (of length @m@)
+        -> Vector Int -- ^ index vector (of length @n1@)
+        -> Vector a   -- ^ value vector (of length @n2@)
+        -> Vector a
+{-# INLINE update_ #-}
+update_ = G.update_
+
+-- | Same as ('//') but without bounds checking.
 unsafeUpd :: Prim a => Vector a -> [(Int, a)] -> Vector a
 {-# INLINE unsafeUpd #-}
 unsafeUpd = G.unsafeUpd
 
+-- | Same as 'update_' but without bounds checking.
 unsafeUpdate_ :: Prim a => Vector a -> Vector Int -> Vector a -> Vector a
 {-# INLINE unsafeUpdate_ #-}
 unsafeUpdate_ = G.unsafeUpdate_
 
-(//) :: Prim a => Vector a -> [(Int, a)] -> Vector a
-{-# INLINE (//) #-}
-(//) = (G.//)
+-- Accumulations
+-- -------------
 
-update_ :: Prim a => Vector a -> Vector Int -> Vector a -> Vector a
-{-# INLINE update_ #-}
-update_ = G.update_
+-- | /O(m+n)/ For each pair @(i,b)@ from the list, replace the vector element
+-- @a@ at position @i@ by @f a b@.
+--
+-- > accum (+) <5,9,2> [(2,4),(1,6),(0,3),(1,7)] = <5+3, 9+6+7, 2+4>
+accum :: Prim a
+      => (a -> b -> a) -- ^ accumulating function @f@
+      -> Vector a      -- ^ initial vector (of length @m@)
+      -> [(Int,b)]     -- ^ list of index/value pairs (of length @n@)
+      -> Vector a
+{-# INLINE accum #-}
+accum = G.accum
 
+-- | /O(m+min(n1,n2))/ For each index @i@ from the index vector and the
+-- corresponding value @b@ from the the value vector,
+-- replace the element of the initial vector at
+-- position @i@ by @f a b@.
+--
+-- > accumulate_ (+) <5,9,2> <2,1,0,1> <4,6,3,7> = <5+3, 9+6+7, 2+4>
+--
+accumulate_ :: (Prim a, Prim b)
+            => (a -> b -> a) -- ^ accumulating function @f@
+            -> Vector a      -- ^ initial vector (of length @m@)
+            -> Vector Int    -- ^ index vector (of length @n1@)
+            -> Vector b      -- ^ value vector (of length @n2@)
+            -> Vector a
+{-# INLINE accumulate_ #-}
+accumulate_ = G.accumulate_
+
+-- | Same as 'accum' but without bounds checking.
+unsafeAccum :: Prim a => (a -> b -> a) -> Vector a -> [(Int,b)] -> Vector a
+{-# INLINE unsafeAccum #-}
+unsafeAccum = G.unsafeAccum
+
+-- | Same as 'accumulate_' but without bounds checking.
+unsafeAccumulate_ :: (Prim a, Prim b) =>
+               (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
+{-# INLINE unsafeAccumulate_ #-}
+unsafeAccumulate_ = G.unsafeAccumulate_
+
+-- Permutations
+-- ------------
+
+-- | /O(n)/ Reverse a vector
+reverse :: Prim a => Vector a -> Vector a
+{-# INLINE reverse #-}
+reverse = G.reverse
+
+-- | /O(n)/ Yield the vector obtained by replacing each element @i@ of the
+-- index vector by @xs'!'i@. This is equivalent to @'map' (xs'!') is@ but is
+-- often much more efficient.
+--
+-- > backpermute <a,b,c,d> <0,3,2,3,1,0> = <a,d,c,d,b,a>
 backpermute :: Prim a => Vector a -> Vector Int -> Vector a
 {-# INLINE backpermute #-}
 backpermute = G.backpermute
 
+-- | Same as 'backpermute' but without bounds checking.
 unsafeBackpermute :: Prim a => Vector a -> Vector Int -> Vector a
 {-# INLINE unsafeBackpermute #-}
 unsafeBackpermute = G.unsafeBackpermute
 
-reverse :: Prim a => Vector a -> Vector a
-{-# INLINE reverse #-}
-reverse = G.reverse
+-- Safe destructive updates
+-- ------------------------
 
+-- | Apply a destructive operation to a vector. The operation will be
+-- performed in place if it is safe to do so and will modify a copy of the
+-- vector otherwise.
+--
+-- @
+-- modify (\\v -> write v 0 \'x\') ('replicate' 3 \'a\') = \<\'x\',\'a\',\'a\'\>
+-- @
+modify :: Prim a => (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a
+{-# INLINE modify #-}
+modify = G.modify
+
 -- Mapping
 -- -------
 
--- | Map a function over a vector
+-- | /O(n)/ Map a function over a vector
 map :: (Prim a, Prim b) => (a -> b) -> Vector a -> Vector b
 {-# INLINE map #-}
 map = G.map
 
--- | Apply a function to every index/value pair
+-- | /O(n)/ Apply a function to every element of a vector and its index
 imap :: (Prim a, Prim b) => (Int -> a -> b) -> Vector a -> Vector b
 {-# INLINE imap #-}
 imap = G.imap
 
+-- | Map a function over a vector and concatenate the results.
 concatMap :: (Prim a, Prim b) => (a -> Vector b) -> Vector a -> Vector b
 {-# INLINE concatMap #-}
 concatMap = G.concatMap
 
--- Zipping/unzipping
--- -----------------
+-- Monadic mapping
+-- ---------------
 
--- | Zip two vectors with the given function.
+-- | /O(n)/ Apply the monadic action to all elements of the vector, yielding a
+-- vector of results
+mapM :: (Monad m, Prim a, Prim b) => (a -> m b) -> Vector a -> m (Vector b)
+{-# INLINE mapM #-}
+mapM = G.mapM
+
+-- | /O(n)/ Apply the monadic action to all elements of a vector and ignore the
+-- results
+mapM_ :: (Monad m, Prim a) => (a -> m b) -> Vector a -> m ()
+{-# INLINE mapM_ #-}
+mapM_ = G.mapM_
+
+-- | /O(n)/ Apply the monadic action to all elements of the vector, yielding a
+-- vector of results. Equvalent to @flip 'mapM'@.
+forM :: (Monad m, Prim a, Prim b) => Vector a -> (a -> m b) -> m (Vector b)
+{-# INLINE forM #-}
+forM = G.forM
+
+-- | /O(n)/ Apply the monadic action to all elements of a vector and ignore the
+-- results. Equivalent to @flip 'mapM_'@.
+forM_ :: (Monad m, Prim a) => Vector a -> (a -> m b) -> m ()
+{-# INLINE forM_ #-}
+forM_ = G.forM_
+
+-- Zipping
+-- -------
+
+-- | /O(min(m,n))/ Zip two vectors with the given function.
 zipWith :: (Prim a, Prim b, Prim c)
         => (a -> b -> c) -> Vector a -> Vector b -> Vector c
 {-# INLINE zipWith #-}
@@ -443,21 +714,24 @@
 {-# INLINE zipWith4 #-}
 zipWith4 = G.zipWith4
 
-zipWith5 :: (Prim a, Prim b, Prim c, Prim d, Prim e, Prim f)
+zipWith5 :: (Prim a, Prim b, Prim c, Prim d, Prim e,
+             Prim f)
          => (a -> b -> c -> d -> e -> f)
          -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
          -> Vector f
 {-# INLINE zipWith5 #-}
 zipWith5 = G.zipWith5
 
-zipWith6 :: (Prim a, Prim b, Prim c, Prim d, Prim e, Prim f, Prim g)
+zipWith6 :: (Prim a, Prim b, Prim c, Prim d, Prim e,
+             Prim f, Prim g)
          => (a -> b -> c -> d -> e -> f -> g)
          -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
          -> Vector f -> Vector g
 {-# INLINE zipWith6 #-}
 zipWith6 = G.zipWith6
 
--- | Zip two vectors and their indices with the given function.
+-- | /O(min(m,n))/ Zip two vectors with a function that also takes the
+-- elements' indices.
 izipWith :: (Prim a, Prim b, Prim c)
          => (Int -> a -> b -> c) -> Vector a -> Vector b -> Vector c
 {-# INLINE izipWith #-}
@@ -476,67 +750,97 @@
 {-# INLINE izipWith4 #-}
 izipWith4 = G.izipWith4
 
-izipWith5 :: (Prim a, Prim b, Prim c, Prim d, Prim e, Prim f)
+izipWith5 :: (Prim a, Prim b, Prim c, Prim d, Prim e,
+              Prim f)
           => (Int -> a -> b -> c -> d -> e -> f)
           -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
           -> Vector f
 {-# INLINE izipWith5 #-}
 izipWith5 = G.izipWith5
 
-izipWith6 :: (Prim a, Prim b, Prim c, Prim d, Prim e, Prim f, Prim g)
+izipWith6 :: (Prim a, Prim b, Prim c, Prim d, Prim e,
+              Prim f, Prim g)
           => (Int -> a -> b -> c -> d -> e -> f -> g)
           -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
           -> Vector f -> Vector g
 {-# INLINE izipWith6 #-}
 izipWith6 = G.izipWith6
 
+-- Monadic zipping
+-- ---------------
+
+-- | /O(min(m,n))/ Zip the two vectors with the monadic action and yield a
+-- vector of results
+zipWithM :: (Monad m, Prim a, Prim b, Prim c)
+         => (a -> b -> m c) -> Vector a -> Vector b -> m (Vector c)
+{-# INLINE zipWithM #-}
+zipWithM = G.zipWithM
+
+-- | /O(min(m,n))/ Zip the two vectors with the monadic action and ignore the
+-- results
+zipWithM_ :: (Monad m, Prim a, Prim b)
+          => (a -> b -> m c) -> Vector a -> Vector b -> m ()
+{-# INLINE zipWithM_ #-}
+zipWithM_ = G.zipWithM_
+
 -- Filtering
 -- ---------
 
--- | Drop elements which do not satisfy the predicate
+-- | /O(n)/ Drop elements that do not satisfy the predicate
 filter :: Prim a => (a -> Bool) -> Vector a -> Vector a
 {-# INLINE filter #-}
 filter = G.filter
 
--- | Drop elements that do not satisfy the predicate (applied to values and
--- their indices)
+-- | /O(n)/ Drop elements that do not satisfy the predicate which is applied to
+-- values and their indices
 ifilter :: Prim a => (Int -> a -> Bool) -> Vector a -> Vector a
 {-# INLINE ifilter #-}
 ifilter = G.ifilter
 
--- | Yield the longest prefix of elements satisfying the predicate.
+-- | /O(n)/ Drop elements that do not satisfy the monadic predicate
+filterM :: (Monad m, Prim a) => (a -> m Bool) -> Vector a -> m (Vector a)
+{-# INLINE filterM #-}
+filterM = G.filterM
+
+-- | /O(n)/ Yield the longest prefix of elements satisfying the predicate
+-- without copying.
 takeWhile :: Prim a => (a -> Bool) -> Vector a -> Vector a
 {-# INLINE takeWhile #-}
 takeWhile = G.takeWhile
 
--- | Drop the longest prefix of elements that satisfy the predicate.
+-- | /O(n)/ Drop the longest prefix of elements that satisfy the predicate
+-- without copying.
 dropWhile :: Prim a => (a -> Bool) -> Vector a -> Vector a
 {-# INLINE dropWhile #-}
 dropWhile = G.dropWhile
 
--- | Split the vector in two parts, the first one containing those elements
--- that satisfy the predicate and the second one those that don't. The
--- relative order of the elements is preserved at the cost of a (sometimes)
+-- Parititioning
+-- -------------
+
+-- | /O(n)/ Split the vector in two parts, the first one containing those
+-- elements that satisfy the predicate and the second one those that don't. The
+-- relative order of the elements is preserved at the cost of a sometimes
 -- reduced performance compared to 'unstablePartition'.
 partition :: Prim a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
 {-# INLINE partition #-}
 partition = G.partition
 
--- | Split the vector in two parts, the first one containing those elements
--- that satisfy the predicate and the second one those that don't. The order
--- of the elements is not preserved.
+-- | /O(n)/ Split the vector in two parts, the first one containing those
+-- elements that satisfy the predicate and the second one those that don't.
+-- The order of the elements is not preserved but the operation is often
+-- faster than 'partition'.
 unstablePartition :: Prim a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
 {-# INLINE unstablePartition #-}
 unstablePartition = G.unstablePartition
 
--- | Split the vector into the longest prefix of elements that satisfy the
--- predicate and the rest.
+-- | /O(n)/ Split the vector into the longest prefix of elements that satisfy
+-- the predicate and the rest without copying.
 span :: Prim a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
 {-# INLINE span #-}
 span = G.span
 
--- | Split the vector into the longest prefix of elements that do not satisfy
--- the predicate and the rest.
+-- | /O(n)/ Split the vector into the longest prefix of elements that do not
+-- satisfy the predicate and the rest without copying.
 break :: Prim a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
 {-# INLINE break #-}
 break = G.break
@@ -545,41 +849,44 @@
 -- ---------
 
 infix 4 `elem`
--- | Check whether the vector contains an element
+-- | /O(n)/ Check if the vector contains an element
 elem :: (Prim a, Eq a) => a -> Vector a -> Bool
 {-# INLINE elem #-}
 elem = G.elem
 
 infix 4 `notElem`
--- | Inverse of `elem`
+-- | /O(n)/ Check if the vector does not contain an element (inverse of 'elem')
 notElem :: (Prim a, Eq a) => a -> Vector a -> Bool
 {-# INLINE notElem #-}
 notElem = G.notElem
 
--- | Yield 'Just' the first element matching the predicate or 'Nothing' if no
--- such element exists.
+-- | /O(n)/ 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 = G.find
 
--- | Yield 'Just' the index of the first element matching the predicate or
--- 'Nothing' if no such element exists.
+-- | /O(n)/ 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 = G.findIndex
 
--- | Yield the indices of elements satisfying the predicate
+-- | /O(n)/ Yield the indices of elements satisfying the predicate in ascending
+-- order.
 findIndices :: Prim a => (a -> Bool) -> Vector a -> Vector Int
 {-# INLINE findIndices #-}
 findIndices = G.findIndices
 
--- | Yield 'Just' the index of the first occurence of the given element or
--- 'Nothing' if the vector does not contain the element
+-- | /O(n)/ Yield 'Just' the index of the first occurence of the given element or
+-- 'Nothing' if the vector does not contain the element. This is a specialised
+-- version of 'findIndex'.
 elemIndex :: (Prim a, Eq a) => a -> Vector a -> Maybe Int
 {-# INLINE elemIndex #-}
 elemIndex = G.elemIndex
 
--- | Yield the indices of all occurences of the given element
+-- | /O(n)/ Yield the indices of all occurences of the given element in
+-- ascending order. This is a specialised version of 'findIndices'.
 elemIndices :: (Prim a, Eq a) => a -> Vector a -> Vector Int
 {-# INLINE elemIndices #-}
 elemIndices = G.elemIndices
@@ -587,64 +894,64 @@
 -- Folding
 -- -------
 
--- | Left fold
+-- | /O(n)/ Left fold
 foldl :: Prim b => (a -> b -> a) -> a -> Vector b -> a
 {-# INLINE foldl #-}
 foldl = G.foldl
 
--- | Lefgt fold on non-empty vectors
+-- | /O(n)/ Left fold on non-empty vectors
 foldl1 :: Prim a => (a -> a -> a) -> Vector a -> a
 {-# INLINE foldl1 #-}
 foldl1 = G.foldl1
 
--- | Left fold with strict accumulator
+-- | /O(n)/ Left fold with strict accumulator
 foldl' :: Prim b => (a -> b -> a) -> a -> Vector b -> a
 {-# INLINE foldl' #-}
 foldl' = G.foldl'
 
--- | Left fold on non-empty vectors with strict accumulator
+-- | /O(n)/ Left fold on non-empty vectors with strict accumulator
 foldl1' :: Prim a => (a -> a -> a) -> Vector a -> a
 {-# INLINE foldl1' #-}
 foldl1' = G.foldl1'
 
--- | Right fold
+-- | /O(n)/ Right fold
 foldr :: Prim a => (a -> b -> b) -> b -> Vector a -> b
 {-# INLINE foldr #-}
 foldr = G.foldr
 
--- | Right fold on non-empty vectors
+-- | /O(n)/ Right fold on non-empty vectors
 foldr1 :: Prim a => (a -> a -> a) -> Vector a -> a
 {-# INLINE foldr1 #-}
 foldr1 = G.foldr1
 
--- | Right fold with a strict accumulator
+-- | /O(n)/ Right fold with a strict accumulator
 foldr' :: Prim a => (a -> b -> b) -> b -> Vector a -> b
 {-# INLINE foldr' #-}
 foldr' = G.foldr'
 
--- | Right fold on non-empty vectors with strict accumulator
+-- | /O(n)/ Right fold on non-empty vectors with strict accumulator
 foldr1' :: Prim a => (a -> a -> a) -> Vector a -> a
 {-# INLINE foldr1' #-}
 foldr1' = G.foldr1'
 
--- | Left fold (function applied to each element and its index)
+-- | /O(n)/ Left fold (function applied to each element and its index)
 ifoldl :: Prim b => (a -> Int -> b -> a) -> a -> Vector b -> a
 {-# INLINE ifoldl #-}
 ifoldl = G.ifoldl
 
--- | Left fold with strict accumulator (function applied to each element and
--- its index)
+-- | /O(n)/ Left fold with strict accumulator (function applied to each element
+-- and its index)
 ifoldl' :: Prim b => (a -> Int -> b -> a) -> a -> Vector b -> a
 {-# INLINE ifoldl' #-}
 ifoldl' = G.ifoldl'
 
--- | Right fold (function applied to each element and its index)
+-- | /O(n)/ Right fold (function applied to each element and its index)
 ifoldr :: Prim a => (Int -> a -> b -> b) -> b -> Vector a -> b
 {-# INLINE ifoldr #-}
 ifoldr = G.ifoldr
 
--- | Right fold with strict accumulator (function applied to each element and
--- its index)
+-- | /O(n)/ Right fold with strict accumulator (function applied to each
+-- element and its index)
 ifoldr' :: Prim a => (Int -> a -> b -> b) -> b -> Vector a -> b
 {-# INLINE ifoldr' #-}
 ifoldr' = G.ifoldr'
@@ -652,308 +959,248 @@
 -- Specialised folds
 -- -----------------
 
+-- | /O(n)/ Check if all elements satisfy the predicate.
 all :: Prim a => (a -> Bool) -> Vector a -> Bool
 {-# INLINE all #-}
 all = G.all
 
+-- | /O(n)/ Check if any element satisfies the predicate.
 any :: Prim a => (a -> Bool) -> Vector a -> Bool
 {-# INLINE any #-}
 any = G.any
 
+-- | /O(n)/ Compute the sum of the elements
 sum :: (Prim a, Num a) => Vector a -> a
 {-# INLINE sum #-}
 sum = G.sum
 
+-- | /O(n)/ Compute the produce of the elements
 product :: (Prim a, Num a) => Vector a -> a
 {-# INLINE product #-}
 product = G.product
 
+-- | /O(n)/ Yield the maximum element of the vector. The vector may not be
+-- empty.
 maximum :: (Prim a, Ord a) => Vector a -> a
 {-# INLINE maximum #-}
 maximum = G.maximum
 
+-- | /O(n)/ Yield the maximum element of the vector according to the given
+-- comparison function. The vector may not be empty.
 maximumBy :: Prim a => (a -> a -> Ordering) -> Vector a -> a
 {-# INLINE maximumBy #-}
 maximumBy = G.maximumBy
 
+-- | /O(n)/ Yield the minimum element of the vector. The vector may not be
+-- empty.
 minimum :: (Prim a, Ord a) => Vector a -> a
 {-# INLINE minimum #-}
 minimum = G.minimum
 
+-- | /O(n)/ Yield the minimum element of the vector according to the given
+-- comparison function. The vector may not be empty.
 minimumBy :: Prim a => (a -> a -> Ordering) -> Vector a -> a
 {-# INLINE minimumBy #-}
 minimumBy = G.minimumBy
 
+-- | /O(n)/ Yield the index of the maximum element of the vector. The vector
+-- may not be empty.
 maxIndex :: (Prim a, Ord a) => Vector a -> Int
 {-# INLINE maxIndex #-}
 maxIndex = G.maxIndex
 
+-- | /O(n)/ Yield the index of the maximum element of the vector according to
+-- the given comparison function. The vector may not be empty.
 maxIndexBy :: Prim a => (a -> a -> Ordering) -> Vector a -> Int
 {-# INLINE maxIndexBy #-}
 maxIndexBy = G.maxIndexBy
 
+-- | /O(n)/ Yield the index of the minimum element of the vector. The vector
+-- may not be empty.
 minIndex :: (Prim a, Ord a) => Vector a -> Int
 {-# INLINE minIndex #-}
 minIndex = G.minIndex
 
+-- | /O(n)/ Yield the index of the minimum element of the vector according to
+-- the given comparison function. The vector may not be empty.
 minIndexBy :: Prim a => (a -> a -> Ordering) -> Vector a -> Int
 {-# INLINE minIndexBy #-}
 minIndexBy = G.minIndexBy
 
--- Unfolding
--- ---------
+-- Monadic folds
+-- -------------
 
--- | The 'unfoldr' function is a \`dual\' to 'foldr': while 'foldr'
--- reduces a vector to a summary value, 'unfoldr' builds a list from
--- a seed value.  The function takes the element and returns 'Nothing'
--- if it is done generating the vector or returns 'Just' @(a,b)@, in which
--- case, @a@ is a prepended to the vector and @b@ is used as the next
--- element in a recursive call.
---
--- A simple use of unfoldr:
---
--- > unfoldr (\b -> if b == 0 then Nothing else Just (b, b-1)) 10
--- >  [10,9,8,7,6,5,4,3,2,1]
---
-unfoldr :: Prim a => (b -> Maybe (a, b)) -> b -> Vector a
-{-# INLINE unfoldr #-}
-unfoldr = G.unfoldr
+-- | /O(n)/ Monadic fold
+foldM :: (Monad m, Prim b) => (a -> b -> m a) -> a -> Vector b -> m a
+{-# INLINE foldM #-}
+foldM = G.foldM
 
--- | Unfold at most @n@ elements
-unfoldrN :: Prim a => Int -> (b -> Maybe (a, b)) -> b -> Vector a
-{-# INLINE unfoldrN #-}
-unfoldrN = G.unfoldrN
+-- | /O(n)/ Monadic fold over non-empty vectors
+fold1M :: (Monad m, Prim a) => (a -> a -> m a) -> Vector a -> m a
+{-# INLINE fold1M #-}
+fold1M = G.fold1M
 
--- Scans
--- -----
+-- | /O(n)/ Monadic fold with strict accumulator
+foldM' :: (Monad m, Prim b) => (a -> b -> m a) -> a -> Vector b -> m a
+{-# INLINE foldM' #-}
+foldM' = G.foldM'
 
--- | Prefix scan
+-- | /O(n)/ Monad fold over non-empty vectors with strict accumulator
+fold1M' :: (Monad m, Prim a) => (a -> a -> m a) -> Vector a -> m a
+{-# INLINE fold1M' #-}
+fold1M' = G.fold1M'
+
+-- Prefix sums (scans)
+-- -------------------
+
+-- | /O(n)/ Prescan
+--
+-- @
+-- prescanl f z = 'init' . 'scanl' f z
+-- @
+--
+-- Example: @prescanl (+) 0 \<1,2,3,4\> = \<0,1,3,6\>@
+--
 prescanl :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE prescanl #-}
 prescanl = G.prescanl
 
--- | Prefix scan with strict accumulator
+-- | /O(n)/ Prescan with strict accumulator
 prescanl' :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE prescanl' #-}
 prescanl' = G.prescanl'
 
--- | Suffix scan
+-- | /O(n)/ Scan
+--
+-- @
+-- postscanl f z = 'tail' . 'scanl' f z
+-- @
+--
+-- Example: @postscanl (+) 0 \<1,2,3,4\> = \<1,3,6,10\>@
+--
 postscanl :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE postscanl #-}
 postscanl = G.postscanl
 
--- | Suffix scan with strict accumulator
+-- | /O(n)/ Scan with strict accumulator
 postscanl' :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE postscanl' #-}
 postscanl' = G.postscanl'
 
--- | Haskell-style scan
+-- | /O(n)/ Haskell-style scan
+--
+-- > scanl f z <x1,...,xn> = <y1,...,y(n+1)>
+-- >   where y1 = z
+-- >         yi = f y(i-1) x(i-1)
+--
+-- Example: @scanl (+) 0 \<1,2,3,4\> = \<0,1,3,6,10\>@
+-- 
 scanl :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE scanl #-}
 scanl = G.scanl
 
--- | Haskell-style scan with strict accumulator
+-- | /O(n)/ Haskell-style scan with strict accumulator
 scanl' :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE scanl' #-}
 scanl' = G.scanl'
 
--- | Scan over a non-empty 'Vector'
+-- | /O(n)/ Scan over a non-empty vector
+--
+-- > scanl f <x1,...,xn> = <y1,...,yn>
+-- >   where y1 = x1
+-- >         yi = f y(i-1) xi
+--
 scanl1 :: Prim a => (a -> a -> a) -> Vector a -> Vector a
 {-# INLINE scanl1 #-}
 scanl1 = G.scanl1
 
--- | Scan over a non-empty 'Vector' with a strict accumulator
+-- | /O(n)/ Scan over a non-empty vector with a strict accumulator
 scanl1' :: Prim a => (a -> a -> a) -> Vector a -> Vector a
 {-# INLINE scanl1' #-}
 scanl1' = G.scanl1'
 
-
--- | Prefix right-to-left scan
+-- | /O(n)/ Right-to-left prescan
+--
+-- @
+-- prescanr f z = 'reverse' . 'prescanl' (flip f) z . 'reverse'
+-- @
+--
 prescanr :: (Prim a, Prim b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE prescanr #-}
 prescanr = G.prescanr
 
--- | Prefix right-to-left scan with strict accumulator
+-- | /O(n)/ Right-to-left prescan with strict accumulator
 prescanr' :: (Prim a, Prim b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE prescanr' #-}
 prescanr' = G.prescanr'
 
--- | Suffix right-to-left scan
+-- | /O(n)/ Right-to-left scan
 postscanr :: (Prim a, Prim b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE postscanr #-}
 postscanr = G.postscanr
 
--- | Suffix right-to-left scan with strict accumulator
+-- | /O(n)/ Right-to-left scan with strict accumulator
 postscanr' :: (Prim a, Prim b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE postscanr' #-}
 postscanr' = G.postscanr'
 
--- | Haskell-style right-to-left scan
+-- | /O(n)/ Right-to-left Haskell-style scan
 scanr :: (Prim a, Prim b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE scanr #-}
 scanr = G.scanr
 
--- | Haskell-style right-to-left scan with strict accumulator
+-- | /O(n)/ Right-to-left Haskell-style scan with strict accumulator
 scanr' :: (Prim a, Prim b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE scanr' #-}
 scanr' = G.scanr'
 
--- | Right-to-left scan over a non-empty vector
+-- | /O(n)/ Right-to-left scan over a non-empty vector
 scanr1 :: Prim a => (a -> a -> a) -> Vector a -> Vector a
 {-# INLINE scanr1 #-}
 scanr1 = G.scanr1
 
--- | Right-to-left scan over a non-empty vector with a strict accumulator
+-- | /O(n)/ Right-to-left scan over a non-empty vector with a strict
+-- accumulator
 scanr1' :: Prim a => (a -> a -> a) -> Vector a -> Vector a
 {-# INLINE scanr1' #-}
 scanr1' = G.scanr1'
 
--- Enumeration
--- -----------
-
--- | Yield a vector of the given length containing the values @x@, @x+1@ etc.
--- This operation is usually more efficient than 'enumFromTo'.
-enumFromN :: (Prim a, Num a) => a -> Int -> Vector a
-{-# INLINE enumFromN #-}
-enumFromN = G.enumFromN
-
--- | Yield a vector of the given length containing the values @x@, @x+y@,
--- @x+y+y@ etc. This operations is usually more efficient than
--- 'enumFromThenTo'.
-enumFromStepN :: (Prim a, Num a) => a -> a -> Int -> Vector a
-{-# INLINE enumFromStepN #-}
-enumFromStepN = G.enumFromStepN
-
--- | Enumerate values from @x@ to @y@.
---
--- /WARNING:/ This operation can be very inefficient. If at all possible, use
--- 'enumFromN' instead.
-enumFromTo :: (Prim a, Enum a) => a -> a -> Vector a
-{-# INLINE enumFromTo #-}
-enumFromTo = G.enumFromTo
-
--- | Enumerate values from @x@ to @y@ with a specific step @z@.
---
--- /WARNING:/ This operation can be very inefficient. If at all possible, use
--- 'enumFromStepN' instead.
-enumFromThenTo :: (Prim a, Enum a) => a -> a -> a -> Vector a
-{-# INLINE enumFromThenTo #-}
-enumFromThenTo = G.enumFromThenTo
-
--- Conversion to/from lists
+-- Conversions - Lists
 -- ------------------------
 
--- | Convert a vector to a list
+-- | /O(n)/ Convert a vector to a list
 toList :: Prim a => Vector a -> [a]
 {-# INLINE toList #-}
 toList = G.toList
 
--- | Convert a list to a vector
+-- | /O(n)/ Convert a list to a vector
 fromList :: Prim a => [a] -> Vector a
 {-# INLINE fromList #-}
 fromList = G.fromList
 
--- | Convert the first @n@ elements of a list to a vector
+-- | /O(n)/ Convert the first @n@ elements of a list to a vector
 --
--- > fromListN n xs = fromList (take n xs)
+-- @
+-- fromListN n xs = 'fromList' ('take' n xs)
+-- @
 fromListN :: Prim a => Int -> [a] -> Vector a
 {-# INLINE fromListN #-}
 fromListN = G.fromListN
 
--- Monadic operations
--- ------------------
-
--- | Perform the monadic action the given number of times and store the
--- results in a vector.
-replicateM :: (Monad m, Prim a) => Int -> m a -> m (Vector a)
-{-# INLINE replicateM #-}
-replicateM = G.replicateM
-
--- | Apply the monadic action to all elements of the vector, yielding a vector
--- of results
-mapM :: (Monad m, Prim a, Prim b) => (a -> m b) -> Vector a -> m (Vector b)
-{-# INLINE mapM #-}
-mapM = G.mapM
-
--- | Apply the monadic action to all elements of a vector and ignore the
--- results
-mapM_ :: (Monad m, Prim a) => (a -> m b) -> Vector a -> m ()
-{-# INLINE mapM_ #-}
-mapM_ = G.mapM_
-
--- | Apply the monadic action to all elements of the vector, yielding a vector
--- of results
-forM :: (Monad m, Prim a, Prim b) => Vector a -> (a -> m b) -> m (Vector b)
-{-# INLINE forM #-}
-forM = G.forM
-
--- | Apply the monadic action to all elements of a vector and ignore the
--- results
-forM_ :: (Monad m, Prim a) => Vector a -> (a -> m b) -> m ()
-{-# INLINE forM_ #-}
-forM_ = G.forM_
-
--- | Zip the two vectors with the monadic action and yield a vector of results
-zipWithM :: (Monad m, Prim a, Prim b, Prim c)
-         => (a -> b -> m c) -> Vector a -> Vector b -> m (Vector c)
-{-# INLINE zipWithM #-}
-zipWithM = G.zipWithM
-
--- | Zip the two vectors with the monadic action and ignore the results
-zipWithM_ :: (Monad m, Prim a, Prim b)
-          => (a -> b -> m c) -> Vector a -> Vector b -> m ()
-{-# INLINE zipWithM_ #-}
-zipWithM_ = G.zipWithM_
-
--- | Drop elements that do not satisfy the monadic predicate
-filterM :: (Monad m, Prim a) => (a -> m Bool) -> Vector a -> m (Vector a)
-{-# INLINE filterM #-}
-filterM = G.filterM
-
--- | Monadic fold
-foldM :: (Monad m, Prim b) => (a -> b -> m a) -> a -> Vector b -> m a
-{-# INLINE foldM #-}
-foldM = G.foldM
-
--- | Monadic fold over non-empty vectors
-fold1M :: (Monad m, Prim a) => (a -> a -> m a) -> Vector a -> m a
-{-# INLINE fold1M #-}
-fold1M = G.fold1M
-
--- | Monadic fold with strict accumulator
-foldM' :: (Monad m, Prim b) => (a -> b -> m a) -> a -> Vector b -> m a
-{-# INLINE foldM' #-}
-foldM' = G.foldM'
-
--- | Monad fold over non-empty vectors with strict accumulator
-fold1M' :: (Monad m, Prim a) => (a -> a -> m a) -> Vector a -> m a
-{-# INLINE fold1M' #-}
-fold1M' = G.fold1M'
-
--- Destructive operations
--- ----------------------
-
--- | Destructively initialise a vector.
-create :: Prim a => (forall s. ST s (MVector s a)) -> Vector a
-{-# INLINE create #-}
-create = G.create
-
--- | Apply a destructive operation to a vector. The operation is applied to a
--- copy of the vector unless it can be safely performed in place.
-modify :: Prim a => (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a
-{-# INLINE modify #-}
-modify = G.modify
+-- Conversions - Mutable vectors
+-- -----------------------------
 
--- | Copy an immutable vector into a mutable one. The two vectors must have
--- the same length. This is not checked.
+-- | /O(n)/ Copy an immutable vector into a mutable one. The two vectors must
+-- have the same length.
 unsafeCopy
   :: (Prim a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m ()
 {-# INLINE unsafeCopy #-}
 unsafeCopy = G.unsafeCopy
            
--- | Copy an immutable vector into a mutable one. The two vectors must have the
--- same length.
+-- | /O(n)/ Copy an immutable vector into a mutable one. The two vectors must
+-- have the same length. This is not checked.
 copy :: (Prim a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m ()
 {-# INLINE copy #-}
 copy = G.copy
+
 
diff --git a/Data/Vector/Storable.hs b/Data/Vector/Storable.hs
--- a/Data/Vector/Storable.hs
+++ b/Data/Vector/Storable.hs
@@ -13,57 +13,103 @@
 --
 
 module Data.Vector.Storable (
+  -- * Storable vectors
   Vector, MVector(..), Storable,
 
-  -- * Length information
-  length, null,
+  -- * Accessors
 
-  -- * Construction
-  empty, singleton, cons, snoc, replicate, generate, (++), force,
+  -- ** Length information
+  length, null,
 
-  -- * Accessing individual elements
-  (!), head, last, indexM, headM, lastM,
+  -- ** Indexing
+  (!), head, last,
   unsafeIndex, unsafeHead, unsafeLast,
+
+  -- ** Monadic indexing
+  indexM, headM, lastM,
   unsafeIndexM, unsafeHeadM, unsafeLastM,
 
-  -- * Subvectors
+  -- ** Extracting subvectors (slicing)
   slice, init, tail, take, drop,
   unsafeSlice, unsafeInit, unsafeTail, unsafeTake, unsafeDrop,
 
-  -- * Permutations
-  accum, accumulate_, (//), update_, backpermute, reverse,
-  unsafeAccum, unsafeAccumulate_,
+  -- * Construction
+
+  -- ** Initialisation
+  empty, singleton, replicate, generate,
+
+  -- ** Monadic initialisation
+  replicateM, create,
+
+  -- ** Unfolding
+  unfoldr, unfoldrN,
+
+  -- ** Enumeration
+  enumFromN, enumFromStepN, enumFromTo, enumFromThenTo,
+
+  -- ** Concatenation
+  cons, snoc, (++),
+
+  -- ** Restricting memory usage
+  force,
+
+  -- * Modifying vectors
+
+  -- ** Bulk updates
+  (//), update_,
   unsafeUpd, unsafeUpdate_,
-  unsafeBackpermute,
 
-  -- * Mapping
+  -- ** Accumulations
+  accum, accumulate_,
+  unsafeAccum, unsafeAccumulate_,
+
+  -- ** Permutations 
+  reverse, backpermute, unsafeBackpermute,
+
+  -- ** Safe destructive updates
+  modify,
+
+  -- * Elementwise operations
+
+  -- ** Mapping
   map, imap, concatMap,
 
-  -- * Zipping and unzipping
+  -- ** Monadic mapping
+  mapM, mapM_, forM, forM_,
+
+  -- ** Zipping
   zipWith, zipWith3, zipWith4, zipWith5, zipWith6,
   izipWith, izipWith3, izipWith4, izipWith5, izipWith6,
 
-  -- * Filtering
-  filter, ifilter, takeWhile, dropWhile,
+  -- ** Monadic zipping
+  zipWithM, zipWithM_,
+
+  -- * Working with predicates
+
+  -- ** Filtering
+  filter, ifilter, filterM,
+  takeWhile, dropWhile,
+
+  -- ** Partitioning
   partition, unstablePartition, span, break,
 
-  -- * Searching
+  -- ** Searching
   elem, notElem, find, findIndex, findIndices, elemIndex, elemIndices,
 
   -- * Folding
   foldl, foldl1, foldl', foldl1', foldr, foldr1, foldr', foldr1',
   ifoldl, ifoldl', ifoldr, ifoldr',
 
-  -- * Specialised folds
+  -- ** Specialised folds
   all, any, and, or,
   sum, product,
   maximum, maximumBy, minimum, minimumBy,
   minIndex, minIndexBy, maxIndex, maxIndexBy,
 
-  -- * Unfolding
-  unfoldr, unfoldrN,
+  -- ** Monadic folds
+  foldM, foldM', fold1M, fold1M',
 
-  -- * Scans
+  -- * Prefix sums (scans)
   prescanl, prescanl',
   postscanl, postscanl',
   scanl, scanl', scanl1, scanl1',
@@ -71,20 +117,15 @@
   postscanr, postscanr',
   scanr, scanr', scanr1, scanr1',
 
-  -- * Enumeration
-  enumFromN, enumFromStepN, enumFromTo, enumFromThenTo,
+  -- * Conversions
 
-  -- * Conversion to/from lists
+  -- ** Lists
   toList, fromList, fromListN,
 
-  -- * Monadic operations
-  replicateM, mapM, mapM_, forM, forM_, zipWithM, zipWithM_, filterM,
-  foldM, foldM', fold1M, fold1M',
-
-  -- * Destructive operations
-  create, modify, copy, unsafeCopy,
+  -- ** Mutable vectors
+  copy, unsafeCopy,
 
-  -- * Accessing the underlying memory
+  -- * Raw pointers
   unsafeFromForeignPtr, unsafeToForeignPtr, unsafeWith
 ) where
 
@@ -219,248 +260,475 @@
 -- Length
 -- ------
 
+-- | /O(1)/ Yield the length of the vector.
 length :: Storable a => Vector a -> Int
 {-# INLINE length #-}
 length = G.length
 
+-- | /O(1)/ Test whether a vector if empty
 null :: Storable a => Vector a -> Bool
 {-# INLINE null #-}
 null = G.null
 
--- Construction
--- ------------
-
--- | Empty vector
-empty :: Storable a => Vector a
-{-# INLINE empty #-}
-empty = G.empty
-
--- | Vector with exaclty one element
-singleton :: Storable a => a -> Vector a
-{-# INLINE 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 = G.replicate
-
--- | Generate a vector of the given length by applying the function to each
--- index
-generate :: Storable a => Int -> (Int -> a) -> Vector a
-{-# INLINE generate #-}
-generate = G.generate
-
--- | Prepend an element
-cons :: Storable a => a -> Vector a -> Vector a
-{-# INLINE cons #-}
-cons = G.cons
-
--- | Append an element
-snoc :: Storable a => Vector a -> a -> Vector a
-{-# INLINE snoc #-}
-snoc = G.snoc
-
-infixr 5 ++
--- | Concatenate two vectors
-(++) :: Storable a => Vector a -> Vector a -> Vector a
-{-# INLINE (++) #-}
-(++) = (G.++)
-
--- | Create a copy of a vector. Useful when dealing with slices.
-force :: Storable a => Vector a -> Vector a
-{-# INLINE force #-}
-force = G.force
-
--- Accessing individual elements
--- -----------------------------
+-- Indexing
+-- --------
 
--- | Indexing
+-- | O(1) Indexing
 (!) :: Storable a => Vector a -> Int -> a
 {-# INLINE (!) #-}
 (!) = (G.!)
 
--- | First element
+-- | /O(1)/ First element
 head :: Storable a => Vector a -> a
 {-# INLINE head #-}
 head = G.head
 
--- | Last element
+-- | /O(1)/ Last element
 last :: Storable a => Vector a -> a
 {-# INLINE last #-}
 last = G.last
 
--- | Unsafe indexing without bounds checking
+-- | /O(1)/ Unsafe indexing without bounds checking
 unsafeIndex :: Storable a => Vector a -> Int -> a
 {-# INLINE unsafeIndex #-}
 unsafeIndex = G.unsafeIndex
 
--- | Yield the first element of a vector without checking if the vector is
--- empty
+-- | /O(1)/ First element without checking if the vector is empty
 unsafeHead :: Storable a => Vector a -> a
 {-# INLINE unsafeHead #-}
 unsafeHead = G.unsafeHead
 
--- | Yield the last element of a vector without checking if the vector is
--- empty
+-- | /O(1)/ Last element without checking if the vector is empty
 unsafeLast :: Storable a => Vector a -> a
 {-# INLINE unsafeLast #-}
 unsafeLast = G.unsafeLast
 
--- | Monadic indexing which can be strict in the vector while remaining lazy in
--- the element
+-- Monadic indexing
+-- ----------------
+
+-- | /O(1)/ Indexing in a monad.
+--
+-- The monad allows operations to be strict in the vector when necessary.
+-- Suppose vector copying is implemented like this:
+--
+-- > copy mv v = ... write mv i (v ! i) ...
+--
+-- For lazy vectors, @v ! i@ would not be evaluated which means that @mv@
+-- would unnecessarily retain a reference to @v@ in each element written.
+--
+-- With 'indexM', copying can be implemented like this instead:
+--
+-- > copy mv v = ... do
+-- >                   x <- indexM v i
+-- >                   write mv i x
+--
+-- Here, no references to @v@ are retained because indexing (but /not/ the
+-- elements) is evaluated eagerly.
+--
 indexM :: (Storable a, Monad m) => Vector a -> Int -> m a
 {-# INLINE indexM #-}
 indexM = G.indexM
 
+-- | /O(1)/ First element of a vector in a monad. See 'indexM' for an
+-- explanation of why this is useful.
 headM :: (Storable a, Monad m) => Vector a -> m a
 {-# INLINE headM #-}
 headM = G.headM
 
+-- | /O(1)/ Last element of a vector in a monad. See 'indexM' for an
+-- explanation of why this is useful.
 lastM :: (Storable a, Monad m) => Vector a -> m a
 {-# INLINE lastM #-}
 lastM = G.lastM
 
--- | Unsafe monadic indexing without bounds checks
+-- | /O(1)/ Indexing in a monad without bounds checks. See 'indexM' for an
+-- explanation of why this is useful.
 unsafeIndexM :: (Storable a, Monad m) => Vector a -> Int -> m a
 {-# INLINE unsafeIndexM #-}
 unsafeIndexM = G.unsafeIndexM
 
+-- | /O(1)/ First element in a monad without checking for empty vectors.
+-- See 'indexM' for an explanation of why this is useful.
 unsafeHeadM :: (Storable a, Monad m) => Vector a -> m a
 {-# INLINE unsafeHeadM #-}
 unsafeHeadM = G.unsafeHeadM
 
+-- | /O(1)/ Last element in a monad without checking for empty vectors.
+-- See 'indexM' for an explanation of why this is useful.
 unsafeLastM :: (Storable a, Monad m) => Vector a -> m a
 {-# INLINE unsafeLastM #-}
 unsafeLastM = G.unsafeLastM
 
--- Subarrays
--- ---------
+-- Extracting subvectors (slicing)
+-- -------------------------------
 
--- | Yield a part of the vector without copying it. Safer version of
--- 'basicUnsafeSlice'.
-slice :: Storable a => Int   -- ^ starting index
-                    -> Int   -- ^ length
-                    -> Vector a
-                    -> Vector a
+-- | /O(1)/ Yield a slice of the vector without copying it. The vector must
+-- contain at least @i+n@ elements.
+slice :: Storable a
+      => Int   -- ^ @i@ starting index
+      -> Int   -- ^ @n@ length
+      -> Vector a
+      -> Vector a
 {-# INLINE slice #-}
 slice = G.slice
 
--- | Yield all but the last element without copying.
+-- | /O(1)/ Yield all but the last element without copying. The vector may not
+-- be empty.
 init :: Storable a => Vector a -> Vector a
 {-# INLINE init #-}
 init = G.init
 
--- | All but the first element (without copying).
+-- | /O(1)/ Yield all but the first element without copying. The vector may not
+-- be empty.
 tail :: Storable a => Vector a -> Vector a
 {-# INLINE tail #-}
 tail = G.tail
 
--- | Yield the first @n@ elements without copying.
+-- | /O(1)/ Yield at the first @n@ elements without copying. The vector may
+-- contain less than @n@ elements in which case it is returned unchanged.
 take :: Storable a => Int -> Vector a -> Vector a
 {-# INLINE take #-}
 take = G.take
 
--- | Yield all but the first @n@ elements without copying.
+-- | /O(1)/ Yield all but the first @n@ elements without copying. The vector may
+-- contain less than @n@ elements in which case an empty vector is returned.
 drop :: Storable a => Int -> Vector a -> Vector a
 {-# INLINE drop #-}
 drop = G.drop
 
--- | Unsafely yield a part of the vector without copying it and without
--- performing bounds checks.
-unsafeSlice :: Storable a => Int   -- ^ starting index
-                          -> Int   -- ^ length
-                          -> Vector a
-                          -> Vector a
+-- | /O(1)/ Yield a slice of the vector without copying. The vector must
+-- contain at least @i+n@ elements but this is not checked.
+unsafeSlice :: Storable a => Int   -- ^ @i@ starting index
+                       -> Int   -- ^ @n@ length
+                       -> Vector a
+                       -> Vector a
 {-# INLINE unsafeSlice #-}
 unsafeSlice = G.unsafeSlice
 
+-- | /O(1)/ Yield all but the last element without copying. The vector may not
+-- be empty but this is not checked.
 unsafeInit :: Storable a => Vector a -> Vector a
 {-# INLINE unsafeInit #-}
 unsafeInit = G.unsafeInit
 
+-- | /O(1)/ Yield all but the first element without copying. The vector may not
+-- be empty but this is not checked.
 unsafeTail :: Storable a => Vector a -> Vector a
 {-# INLINE unsafeTail #-}
 unsafeTail = G.unsafeTail
 
+-- | /O(1)/ Yield the first @n@ elements without copying. The vector must
+-- contain at least @n@ elements but this is not checked.
 unsafeTake :: Storable a => Int -> Vector a -> Vector a
 {-# INLINE unsafeTake #-}
 unsafeTake = G.unsafeTake
 
+-- | /O(1)/ Yield all but the first @n@ elements without copying. The vector
+-- must contain at least @n@ elements but this is not checked.
 unsafeDrop :: Storable a => Int -> Vector a -> Vector a
 {-# INLINE unsafeDrop #-}
 unsafeDrop = G.unsafeDrop
 
--- Permutations
--- ------------
+-- Initialisation
+-- --------------
 
-unsafeAccum :: Storable a => (a -> b -> a) -> Vector a -> [(Int,b)] -> Vector a
-{-# INLINE unsafeAccum #-}
-unsafeAccum = G.unsafeAccum
+-- | /O(1)/ Empty vector
+empty :: Storable a => Vector a
+{-# INLINE empty #-}
+empty = G.empty
 
-unsafeAccumulate_ :: (Storable a, Storable b) =>
-               (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
-{-# INLINE unsafeAccumulate_ #-}
-unsafeAccumulate_ = G.unsafeAccumulate_
+-- | /O(1)/ Vector with exactly one element
+singleton :: Storable a => a -> Vector a
+{-# INLINE singleton #-}
+singleton = G.singleton
 
-accum :: Storable a => (a -> b -> a) -> Vector a -> [(Int,b)] -> Vector a
-{-# INLINE accum #-}
-accum = G.accum
+-- | /O(n)/ Vector of the given length with the same value in each position
+replicate :: Storable a => Int -> a -> Vector a
+{-# INLINE replicate #-}
+replicate = G.replicate
 
-accumulate_ :: (Storable a, Storable b) =>
-               (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
-{-# INLINE accumulate_ #-}
-accumulate_ = G.accumulate_
+-- | /O(n)/ Construct a vector of the given length by applying the function to
+-- each index
+generate :: Storable a => Int -> (Int -> a) -> Vector a
+{-# INLINE generate #-}
+generate = G.generate
 
+-- Unfolding
+-- ---------
+
+-- | /O(n)/ Construct a vector by repeatedly applying the generator function
+-- to a seed. The generator function yields 'Just' the next element and the
+-- new seed or 'Nothing' if there are no more elements.
+--
+-- > unfoldr (\n -> if n == 0 then Nothing else Just (n,n-1)) 10
+-- >  = <10,9,8,7,6,5,4,3,2,1>
+unfoldr :: Storable a => (b -> Maybe (a, b)) -> b -> Vector a
+{-# INLINE unfoldr #-}
+unfoldr = G.unfoldr
+
+-- | /O(n)/ Construct a vector with at most @n@ by repeatedly applying the
+-- generator function to the a seed. The generator function yields 'Just' the
+-- next element and the new seed or 'Nothing' if there are no more elements.
+--
+-- > unfoldrN 3 (\n -> Just (n,n-1)) 10 = <10,9,8>
+unfoldrN :: Storable a => Int -> (b -> Maybe (a, b)) -> b -> Vector a
+{-# INLINE unfoldrN #-}
+unfoldrN = G.unfoldrN
+
+-- Enumeration
+-- -----------
+
+-- | /O(n)/ Yield a vector of the given length containing the values @x@, @x+1@
+-- etc. This operation is usually more efficient than 'enumFromTo'.
+--
+-- > enumFromN 5 3 = <5,6,7>
+enumFromN :: (Storable a, Num a) => a -> Int -> Vector a
+{-# INLINE enumFromN #-}
+enumFromN = G.enumFromN
+
+-- | /O(n)/ Yield a vector of the given length containing the values @x@, @x+y@,
+-- @x+y+y@ etc. This operations is usually more efficient than 'enumFromThenTo'.
+--
+-- > enumFromStepN 1 0.1 5 = <1,1.1,1.2,1.3,1.4>
+enumFromStepN :: (Storable a, Num a) => a -> a -> Int -> Vector a
+{-# INLINE enumFromStepN #-}
+enumFromStepN = G.enumFromStepN
+
+-- | /O(n)/ Enumerate values from @x@ to @y@.
+--
+-- /WARNING:/ This operation can be very inefficient. If at all possible, use
+-- 'enumFromN' instead.
+enumFromTo :: (Storable a, Enum a) => a -> a -> Vector a
+{-# INLINE enumFromTo #-}
+enumFromTo = G.enumFromTo
+
+-- | /O(n)/ Enumerate values from @x@ to @y@ with a specific step @z@.
+--
+-- /WARNING:/ This operation can be very inefficient. If at all possible, use
+-- 'enumFromStepN' instead.
+enumFromThenTo :: (Storable a, Enum a) => a -> a -> a -> Vector a
+{-# INLINE enumFromThenTo #-}
+enumFromThenTo = G.enumFromThenTo
+
+-- Concatenation
+-- -------------
+
+-- | /O(n)/ Prepend an element
+cons :: Storable a => a -> Vector a -> Vector a
+{-# INLINE cons #-}
+cons = G.cons
+
+-- | /O(n)/ Append an element
+snoc :: Storable a => Vector a -> a -> Vector a
+{-# INLINE snoc #-}
+snoc = G.snoc
+
+infixr 5 ++
+-- | /O(m+n)/ Concatenate two vectors
+(++) :: Storable a => Vector a -> Vector a -> Vector a
+{-# INLINE (++) #-}
+(++) = (G.++)
+
+-- Monadic initialisation
+-- ----------------------
+
+-- | /O(n)/ Execute the monadic action the given number of times and store the
+-- results in a vector.
+replicateM :: (Monad m, Storable a) => Int -> m a -> m (Vector a)
+{-# INLINE replicateM #-}
+replicateM = G.replicateM
+
+-- | Execute the monadic action and freeze the resulting vector.
+--
+-- @
+-- create (do { v \<- new 2; write v 0 \'a\'; write v 1 \'b\' }) = \<'a','b'\>
+-- @
+create :: Storable a => (forall s. ST s (MVector s a)) -> Vector a
+{-# INLINE create #-}
+create = G.create
+
+-- Restricting memory usage
+-- ------------------------
+
+-- | /O(n)/ Yield the argument but force it not to retain any extra memory,
+-- possibly by copying it.
+--
+-- This is especially useful when dealing with slices. For example:
+--
+-- > force (slice 0 2 <huge vector>)
+--
+-- Here, the slice retains a reference to the huge vector. Forcing it creates
+-- a copy of just the elements that belong to the slice and allows the huge
+-- vector to be garbage collected.
+force :: Storable a => Vector a -> Vector a
+{-# INLINE force #-}
+force = G.force
+
+-- Bulk updates
+-- ------------
+
+-- | /O(m+n)/ For each pair @(i,a)@ from the list, replace the vector
+-- element at position @i@ by @a@.
+--
+-- > <5,9,2,7> // [(2,1),(0,3),(2,8)] = <3,9,8,7>
+--
+(//) :: Storable a => Vector a   -- ^ initial vector (of length @m@)
+                -> [(Int, a)] -- ^ list of index/value pairs (of length @n@) 
+                -> Vector a
+{-# INLINE (//) #-}
+(//) = (G.//)
+
+-- | /O(m+min(n1,n2))/ For each index @i@ from the index vector and the
+-- corresponding value @a@ from the value vector, replace the element of the
+-- initial vector at position @i@ by @a@.
+--
+-- > update_ <5,9,2,7>  <2,0,2> <1,3,8> = <3,9,8,7>
+--
+update_ :: Storable a
+        => Vector a   -- ^ initial vector (of length @m@)
+        -> Vector Int -- ^ index vector (of length @n1@)
+        -> Vector a   -- ^ value vector (of length @n2@)
+        -> Vector a
+{-# INLINE update_ #-}
+update_ = G.update_
+
+-- | Same as ('//') but without bounds checking.
 unsafeUpd :: Storable a => Vector a -> [(Int, a)] -> Vector a
 {-# INLINE unsafeUpd #-}
 unsafeUpd = G.unsafeUpd
 
+-- | Same as 'update_' but without bounds checking.
 unsafeUpdate_ :: Storable a => Vector a -> Vector Int -> Vector a -> Vector a
 {-# INLINE unsafeUpdate_ #-}
 unsafeUpdate_ = G.unsafeUpdate_
 
-(//) :: Storable a => Vector a -> [(Int, a)] -> Vector a
-{-# INLINE (//) #-}
-(//) = (G.//)
+-- Accumulations
+-- -------------
 
-update_ :: Storable a => Vector a -> Vector Int -> Vector a -> Vector a
-{-# INLINE update_ #-}
-update_ = G.update_
+-- | /O(m+n)/ For each pair @(i,b)@ from the list, replace the vector element
+-- @a@ at position @i@ by @f a b@.
+--
+-- > accum (+) <5,9,2> [(2,4),(1,6),(0,3),(1,7)] = <5+3, 9+6+7, 2+4>
+accum :: Storable a
+      => (a -> b -> a) -- ^ accumulating function @f@
+      -> Vector a      -- ^ initial vector (of length @m@)
+      -> [(Int,b)]     -- ^ list of index/value pairs (of length @n@)
+      -> Vector a
+{-# INLINE accum #-}
+accum = G.accum
 
+-- | /O(m+min(n1,n2))/ For each index @i@ from the index vector and the
+-- corresponding value @b@ from the the value vector,
+-- replace the element of the initial vector at
+-- position @i@ by @f a b@.
+--
+-- > accumulate_ (+) <5,9,2> <2,1,0,1> <4,6,3,7> = <5+3, 9+6+7, 2+4>
+--
+accumulate_ :: (Storable a, Storable b)
+            => (a -> b -> a) -- ^ accumulating function @f@
+            -> Vector a      -- ^ initial vector (of length @m@)
+            -> Vector Int    -- ^ index vector (of length @n1@)
+            -> Vector b      -- ^ value vector (of length @n2@)
+            -> Vector a
+{-# INLINE accumulate_ #-}
+accumulate_ = G.accumulate_
+
+-- | Same as 'accum' but without bounds checking.
+unsafeAccum :: Storable a => (a -> b -> a) -> Vector a -> [(Int,b)] -> Vector a
+{-# INLINE unsafeAccum #-}
+unsafeAccum = G.unsafeAccum
+
+-- | Same as 'accumulate_' but without bounds checking.
+unsafeAccumulate_ :: (Storable a, Storable b) =>
+               (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
+{-# INLINE unsafeAccumulate_ #-}
+unsafeAccumulate_ = G.unsafeAccumulate_
+
+-- Permutations
+-- ------------
+
+-- | /O(n)/ Reverse a vector
+reverse :: Storable a => Vector a -> Vector a
+{-# INLINE reverse #-}
+reverse = G.reverse
+
+-- | /O(n)/ Yield the vector obtained by replacing each element @i@ of the
+-- index vector by @xs'!'i@. This is equivalent to @'map' (xs'!') is@ but is
+-- often much more efficient.
+--
+-- > backpermute <a,b,c,d> <0,3,2,3,1,0> = <a,d,c,d,b,a>
 backpermute :: Storable a => Vector a -> Vector Int -> Vector a
 {-# INLINE backpermute #-}
 backpermute = G.backpermute
 
+-- | Same as 'backpermute' but without bounds checking.
 unsafeBackpermute :: Storable a => Vector a -> Vector Int -> Vector a
 {-# INLINE unsafeBackpermute #-}
 unsafeBackpermute = G.unsafeBackpermute
 
-reverse :: Storable a => Vector a -> Vector a
-{-# INLINE reverse #-}
-reverse = G.reverse
+-- Safe destructive updates
+-- ------------------------
 
+-- | Apply a destructive operation to a vector. The operation will be
+-- performed in place if it is safe to do so and will modify a copy of the
+-- vector otherwise.
+--
+-- @
+-- modify (\\v -> write v 0 \'x\') ('replicate' 3 \'a\') = \<\'x\',\'a\',\'a\'\>
+-- @
+modify :: Storable a => (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a
+{-# INLINE modify #-}
+modify = G.modify
+
 -- Mapping
 -- -------
 
--- | Map a function over a vector
+-- | /O(n)/ Map a function over a vector
 map :: (Storable a, Storable b) => (a -> b) -> Vector a -> Vector b
 {-# INLINE map #-}
 map = G.map
 
--- | Apply a function to every index/value pair
+-- | /O(n)/ Apply a function to every element of a vector and its index
 imap :: (Storable a, Storable b) => (Int -> a -> b) -> Vector a -> Vector b
 {-# INLINE imap #-}
 imap = G.imap
 
+-- | Map a function over a vector and concatenate the results.
 concatMap :: (Storable a, Storable b) => (a -> Vector b) -> Vector a -> Vector b
 {-# INLINE concatMap #-}
 concatMap = G.concatMap
 
--- Zipping/unzipping
--- -----------------
+-- Monadic mapping
+-- ---------------
 
--- | Zip two vectors with the given function.
+-- | /O(n)/ Apply the monadic action to all elements of the vector, yielding a
+-- vector of results
+mapM :: (Monad m, Storable a, Storable b) => (a -> m b) -> Vector a -> m (Vector b)
+{-# INLINE mapM #-}
+mapM = G.mapM
+
+-- | /O(n)/ Apply the monadic action to all elements of a vector and ignore the
+-- results
+mapM_ :: (Monad m, Storable a) => (a -> m b) -> Vector a -> m ()
+{-# INLINE mapM_ #-}
+mapM_ = G.mapM_
+
+-- | /O(n)/ Apply the monadic action to all elements of the vector, yielding a
+-- vector of results. Equvalent to @flip 'mapM'@.
+forM :: (Monad m, Storable a, Storable b) => Vector a -> (a -> m b) -> m (Vector b)
+{-# INLINE forM #-}
+forM = G.forM
+
+-- | /O(n)/ Apply the monadic action to all elements of a vector and ignore the
+-- results. Equivalent to @flip 'mapM_'@.
+forM_ :: (Monad m, Storable a) => Vector a -> (a -> m b) -> m ()
+{-# INLINE forM_ #-}
+forM_ = G.forM_
+
+-- Zipping
+-- -------
+
+-- | /O(min(m,n))/ Zip two vectors with the given function.
 zipWith :: (Storable a, Storable b, Storable c)
         => (a -> b -> c) -> Vector a -> Vector b -> Vector c
 {-# INLINE zipWith #-}
@@ -494,7 +762,8 @@
 {-# INLINE zipWith6 #-}
 zipWith6 = G.zipWith6
 
--- | Zip two vectors and their indices with the given function.
+-- | /O(min(m,n))/ Zip two vectors with a function that also takes the
+-- elements' indices.
 izipWith :: (Storable a, Storable b, Storable c)
          => (Int -> a -> b -> c) -> Vector a -> Vector b -> Vector c
 {-# INLINE izipWith #-}
@@ -529,54 +798,81 @@
 {-# INLINE izipWith6 #-}
 izipWith6 = G.izipWith6
 
+-- Monadic zipping
+-- ---------------
+
+-- | /O(min(m,n))/ Zip the two vectors with the monadic action and yield a
+-- vector of results
+zipWithM :: (Monad m, Storable a, Storable b, Storable c)
+         => (a -> b -> m c) -> Vector a -> Vector b -> m (Vector c)
+{-# INLINE zipWithM #-}
+zipWithM = G.zipWithM
+
+-- | /O(min(m,n))/ Zip the two vectors with the monadic action and ignore the
+-- results
+zipWithM_ :: (Monad m, Storable a, Storable b)
+          => (a -> b -> m c) -> Vector a -> Vector b -> m ()
+{-# INLINE zipWithM_ #-}
+zipWithM_ = G.zipWithM_
+
 -- Filtering
 -- ---------
 
--- | Drop elements which do not satisfy the predicate
+-- | /O(n)/ Drop elements that do not satisfy the predicate
 filter :: Storable a => (a -> Bool) -> Vector a -> Vector a
 {-# INLINE filter #-}
 filter = G.filter
 
--- | Drop elements that do not satisfy the predicate (applied to values and
--- their indices)
+-- | /O(n)/ Drop elements that do not satisfy the predicate which is applied to
+-- values and their indices
 ifilter :: Storable a => (Int -> a -> Bool) -> Vector a -> Vector a
 {-# INLINE ifilter #-}
 ifilter = G.ifilter
 
--- | Yield the longest prefix of elements satisfying the predicate.
+-- | /O(n)/ Drop elements that do not satisfy the monadic predicate
+filterM :: (Monad m, Storable a) => (a -> m Bool) -> Vector a -> m (Vector a)
+{-# INLINE filterM #-}
+filterM = G.filterM
+
+-- | /O(n)/ Yield the longest prefix of elements satisfying the predicate
+-- without copying.
 takeWhile :: Storable a => (a -> Bool) -> Vector a -> Vector a
 {-# INLINE takeWhile #-}
 takeWhile = G.takeWhile
 
--- | Drop the longest prefix of elements that satisfy the predicate.
+-- | /O(n)/ Drop the longest prefix of elements that satisfy the predicate
+-- without copying.
 dropWhile :: Storable a => (a -> Bool) -> Vector a -> Vector a
 {-# INLINE dropWhile #-}
 dropWhile = G.dropWhile
 
--- | Split the vector in two parts, the first one containing those elements
--- that satisfy the predicate and the second one those that don't. The
--- relative order of the elements is preserved at the cost of a (sometimes)
+-- Parititioning
+-- -------------
+
+-- | /O(n)/ Split the vector in two parts, the first one containing those
+-- elements that satisfy the predicate and the second one those that don't. The
+-- relative order of the elements is preserved at the cost of a sometimes
 -- reduced performance compared to 'unstablePartition'.
 partition :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
 {-# INLINE partition #-}
 partition = G.partition
 
--- | Split the vector in two parts, the first one containing those elements
--- that satisfy the predicate and the second one those that don't. The order
--- of the elements is not preserved.
-unstablePartition
-        :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
+-- | /O(n)/ Split the vector in two parts, the first one containing those
+-- elements that satisfy the predicate and the second one those that don't.
+-- The order of the elements is not preserved but the operation is often
+-- faster than 'partition'.
+unstablePartition :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
 {-# INLINE unstablePartition #-}
 unstablePartition = G.unstablePartition
 
--- | Split the vector into the longest prefix of elements that satisfy the
--- predicate and the rest.
+-- | /O(n)/ Split the vector into the longest prefix of elements that satisfy
+-- the predicate and the rest without copying.
 span :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
 {-# INLINE span #-}
 span = G.span
 
--- | Split the vector into the longest prefix of elements that do not satisfy
--- the predicate and the rest.
+-- | /O(n)/ Split the vector into the longest prefix of elements that do not
+-- satisfy the predicate and the rest without copying.
 break :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
 {-# INLINE break #-}
 break = G.break
@@ -585,41 +881,44 @@
 -- ---------
 
 infix 4 `elem`
--- | Check whether the vector contains an element
+-- | /O(n)/ Check if the vector contains an element
 elem :: (Storable a, Eq a) => a -> Vector a -> Bool
 {-# INLINE elem #-}
 elem = G.elem
 
 infix 4 `notElem`
--- | Inverse of `elem`
+-- | /O(n)/ Check if the vector does not contain an element (inverse of 'elem')
 notElem :: (Storable a, Eq a) => a -> Vector a -> Bool
 {-# INLINE notElem #-}
 notElem = G.notElem
 
--- | Yield 'Just' the first element matching the predicate or 'Nothing' if no
--- such element exists.
+-- | /O(n)/ 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 = G.find
 
--- | Yield 'Just' the index of the first element matching the predicate or
--- 'Nothing' if no such element exists.
+-- | /O(n)/ 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 = G.findIndex
 
--- | Yield the indices of elements satisfying the predicate
+-- | /O(n)/ Yield the indices of elements satisfying the predicate in ascending
+-- order.
 findIndices :: Storable a => (a -> Bool) -> Vector a -> Vector Int
 {-# INLINE findIndices #-}
 findIndices = G.findIndices
 
--- | Yield 'Just' the index of the first occurence of the given element or
--- 'Nothing' if the vector does not contain the element
+-- | /O(n)/ Yield 'Just' the index of the first occurence of the given element or
+-- 'Nothing' if the vector does not contain the element. This is a specialised
+-- version of 'findIndex'.
 elemIndex :: (Storable a, Eq a) => a -> Vector a -> Maybe Int
 {-# INLINE elemIndex #-}
 elemIndex = G.elemIndex
 
--- | Yield the indices of all occurences of the given element
+-- | /O(n)/ Yield the indices of all occurences of the given element in
+-- ascending order. This is a specialised version of 'findIndices'.
 elemIndices :: (Storable a, Eq a) => a -> Vector a -> Vector Int
 {-# INLINE elemIndices #-}
 elemIndices = G.elemIndices
@@ -627,64 +926,64 @@
 -- Folding
 -- -------
 
--- | Left fold
+-- | /O(n)/ Left fold
 foldl :: Storable b => (a -> b -> a) -> a -> Vector b -> a
 {-# INLINE foldl #-}
 foldl = G.foldl
 
--- | Lefgt fold on non-empty vectors
+-- | /O(n)/ Left fold on non-empty vectors
 foldl1 :: Storable a => (a -> a -> a) -> Vector a -> a
 {-# INLINE foldl1 #-}
 foldl1 = G.foldl1
 
--- | Left fold with strict accumulator
+-- | /O(n)/ Left fold with strict accumulator
 foldl' :: Storable b => (a -> b -> a) -> a -> Vector b -> a
 {-# INLINE foldl' #-}
 foldl' = G.foldl'
 
--- | Left fold on non-empty vectors with strict accumulator
+-- | /O(n)/ Left fold on non-empty vectors with strict accumulator
 foldl1' :: Storable a => (a -> a -> a) -> Vector a -> a
 {-# INLINE foldl1' #-}
 foldl1' = G.foldl1'
 
--- | Right fold
+-- | /O(n)/ Right fold
 foldr :: Storable a => (a -> b -> b) -> b -> Vector a -> b
 {-# INLINE foldr #-}
 foldr = G.foldr
 
--- | Right fold on non-empty vectors
+-- | /O(n)/ Right fold on non-empty vectors
 foldr1 :: Storable a => (a -> a -> a) -> Vector a -> a
 {-# INLINE foldr1 #-}
 foldr1 = G.foldr1
 
--- | Right fold with a strict accumulator
+-- | /O(n)/ Right fold with a strict accumulator
 foldr' :: Storable a => (a -> b -> b) -> b -> Vector a -> b
 {-# INLINE foldr' #-}
 foldr' = G.foldr'
 
--- | Right fold on non-empty vectors with strict accumulator
+-- | /O(n)/ Right fold on non-empty vectors with strict accumulator
 foldr1' :: Storable a => (a -> a -> a) -> Vector a -> a
 {-# INLINE foldr1' #-}
 foldr1' = G.foldr1'
 
--- | Left fold (function applied to each element and its index)
+-- | /O(n)/ Left fold (function applied to each element and its index)
 ifoldl :: Storable b => (a -> Int -> b -> a) -> a -> Vector b -> a
 {-# INLINE ifoldl #-}
 ifoldl = G.ifoldl
 
--- | Left fold with strict accumulator (function applied to each element and
--- its index)
+-- | /O(n)/ Left fold with strict accumulator (function applied to each element
+-- and its index)
 ifoldl' :: Storable b => (a -> Int -> b -> a) -> a -> Vector b -> a
 {-# INLINE ifoldl' #-}
 ifoldl' = G.ifoldl'
 
--- | Right fold (function applied to each element and its index)
+-- | /O(n)/ Right fold (function applied to each element and its index)
 ifoldr :: Storable a => (Int -> a -> b -> b) -> b -> Vector a -> b
 {-# INLINE ifoldr #-}
 ifoldr = G.ifoldr
 
--- | Right fold with strict accumulator (function applied to each element and
--- its index)
+-- | /O(n)/ Right fold with strict accumulator (function applied to each
+-- element and its index)
 ifoldr' :: Storable a => (Int -> a -> b -> b) -> b -> Vector a -> b
 {-# INLINE ifoldr' #-}
 ifoldr' = G.ifoldr'
@@ -692,329 +991,265 @@
 -- Specialised folds
 -- -----------------
 
+-- | /O(n)/ Check if all elements satisfy the predicate.
 all :: Storable a => (a -> Bool) -> Vector a -> Bool
 {-# INLINE all #-}
 all = G.all
 
+-- | /O(n)/ Check if any element satisfies the predicate.
 any :: Storable a => (a -> Bool) -> Vector a -> Bool
 {-# INLINE any #-}
 any = G.any
 
+-- | /O(n)/ Check if all elements are 'True'
 and :: Vector Bool -> Bool
 {-# INLINE and #-}
 and = G.and
 
+-- | /O(n)/ Check if any element is 'True'
 or :: Vector Bool -> Bool
 {-# INLINE or #-}
 or = G.or
 
+-- | /O(n)/ Compute the sum of the elements
 sum :: (Storable a, Num a) => Vector a -> a
 {-# INLINE sum #-}
 sum = G.sum
 
+-- | /O(n)/ Compute the produce of the elements
 product :: (Storable a, Num a) => Vector a -> a
 {-# INLINE product #-}
 product = G.product
 
+-- | /O(n)/ Yield the maximum element of the vector. The vector may not be
+-- empty.
 maximum :: (Storable a, Ord a) => Vector a -> a
 {-# INLINE maximum #-}
 maximum = G.maximum
 
+-- | /O(n)/ Yield the maximum element of the vector according to the given
+-- comparison function. The vector may not be empty.
 maximumBy :: Storable a => (a -> a -> Ordering) -> Vector a -> a
 {-# INLINE maximumBy #-}
 maximumBy = G.maximumBy
 
+-- | /O(n)/ Yield the minimum element of the vector. The vector may not be
+-- empty.
 minimum :: (Storable a, Ord a) => Vector a -> a
 {-# INLINE minimum #-}
 minimum = G.minimum
 
+-- | /O(n)/ Yield the minimum element of the vector according to the given
+-- comparison function. The vector may not be empty.
 minimumBy :: Storable a => (a -> a -> Ordering) -> Vector a -> a
 {-# INLINE minimumBy #-}
 minimumBy = G.minimumBy
 
+-- | /O(n)/ Yield the index of the maximum element of the vector. The vector
+-- may not be empty.
 maxIndex :: (Storable a, Ord a) => Vector a -> Int
 {-# INLINE maxIndex #-}
 maxIndex = G.maxIndex
 
+-- | /O(n)/ Yield the index of the maximum element of the vector according to
+-- the given comparison function. The vector may not be empty.
 maxIndexBy :: Storable a => (a -> a -> Ordering) -> Vector a -> Int
 {-# INLINE maxIndexBy #-}
 maxIndexBy = G.maxIndexBy
 
+-- | /O(n)/ Yield the index of the minimum element of the vector. The vector
+-- may not be empty.
 minIndex :: (Storable a, Ord a) => Vector a -> Int
 {-# INLINE minIndex #-}
 minIndex = G.minIndex
 
+-- | /O(n)/ Yield the index of the minimum element of the vector according to
+-- the given comparison function. The vector may not be empty.
 minIndexBy :: Storable a => (a -> a -> Ordering) -> Vector a -> Int
 {-# INLINE minIndexBy #-}
 minIndexBy = G.minIndexBy
 
--- Unfolding
--- ---------
+-- Monadic folds
+-- -------------
 
--- | The 'unfoldr' function is a \`dual\' to 'foldr': while 'foldr'
--- reduces a vector to a summary value, 'unfoldr' builds a list from
--- a seed value.  The function takes the element and returns 'Nothing'
--- if it is done generating the vector or returns 'Just' @(a,b)@, in which
--- case, @a@ is a prepended to the vector and @b@ is used as the next
--- element in a recursive call.
---
--- A simple use of unfoldr:
---
--- > unfoldr (\b -> if b == 0 then Nothing else Just (b, b-1)) 10
--- >  [10,9,8,7,6,5,4,3,2,1]
---
-unfoldr :: Storable a => (b -> Maybe (a, b)) -> b -> Vector a
-{-# INLINE unfoldr #-}
-unfoldr = G.unfoldr
+-- | /O(n)/ Monadic fold
+foldM :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector b -> m a
+{-# INLINE foldM #-}
+foldM = G.foldM
 
--- | Unfold at most @n@ elements
-unfoldrN :: Storable a => Int -> (b -> Maybe (a, b)) -> b -> Vector a
-{-# INLINE unfoldrN #-}
-unfoldrN = G.unfoldrN
+-- | /O(n)/ Monadic fold over non-empty vectors
+fold1M :: (Monad m, Storable a) => (a -> a -> m a) -> Vector a -> m a
+{-# INLINE fold1M #-}
+fold1M = G.fold1M
 
--- Scans
--- -----
+-- | /O(n)/ Monadic fold with strict accumulator
+foldM' :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector b -> m a
+{-# INLINE foldM' #-}
+foldM' = G.foldM'
 
--- | Prefix scan
+-- | /O(n)/ Monad fold over non-empty vectors with strict accumulator
+fold1M' :: (Monad m, Storable a) => (a -> a -> m a) -> Vector a -> m a
+{-# INLINE fold1M' #-}
+fold1M' = G.fold1M'
+
+-- Prefix sums (scans)
+-- -------------------
+
+-- | /O(n)/ Prescan
+--
+-- @
+-- prescanl f z = 'init' . 'scanl' f z
+-- @
+--
+-- Example: @prescanl (+) 0 \<1,2,3,4\> = \<0,1,3,6\>@
+--
 prescanl :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE prescanl #-}
 prescanl = G.prescanl
 
--- | Prefix scan with strict accumulator
+-- | /O(n)/ Prescan with strict accumulator
 prescanl' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE prescanl' #-}
 prescanl' = G.prescanl'
 
--- | Suffix scan
+-- | /O(n)/ Scan
+--
+-- @
+-- postscanl f z = 'tail' . 'scanl' f z
+-- @
+--
+-- Example: @postscanl (+) 0 \<1,2,3,4\> = \<1,3,6,10\>@
+--
 postscanl :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE postscanl #-}
 postscanl = G.postscanl
 
--- | Suffix scan with strict accumulator
+-- | /O(n)/ Scan with strict accumulator
 postscanl' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE postscanl' #-}
 postscanl' = G.postscanl'
 
--- | Haskell-style scan
+-- | /O(n)/ Haskell-style scan
+--
+-- > scanl f z <x1,...,xn> = <y1,...,y(n+1)>
+-- >   where y1 = z
+-- >         yi = f y(i-1) x(i-1)
+--
+-- Example: @scanl (+) 0 \<1,2,3,4\> = \<0,1,3,6,10\>@
+-- 
 scanl :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE scanl #-}
 scanl = G.scanl
 
--- | Haskell-style scan with strict accumulator
+-- | /O(n)/ Haskell-style scan with strict accumulator
 scanl' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE scanl' #-}
 scanl' = G.scanl'
 
--- | Scan over a non-empty 'Vector'
+-- | /O(n)/ Scan over a non-empty vector
+--
+-- > scanl f <x1,...,xn> = <y1,...,yn>
+-- >   where y1 = x1
+-- >         yi = f y(i-1) xi
+--
 scanl1 :: Storable a => (a -> a -> a) -> Vector a -> Vector a
 {-# INLINE scanl1 #-}
 scanl1 = G.scanl1
 
--- | Scan over a non-empty 'Vector' with a strict accumulator
+-- | /O(n)/ Scan over a non-empty vector with a strict accumulator
 scanl1' :: Storable a => (a -> a -> a) -> Vector a -> Vector a
 {-# INLINE scanl1' #-}
 scanl1' = G.scanl1'
 
-
--- | Prefix right-to-left scan
-prescanr
-  :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
+-- | /O(n)/ Right-to-left prescan
+--
+-- @
+-- prescanr f z = 'reverse' . 'prescanl' (flip f) z . 'reverse'
+-- @
+--
+prescanr :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE prescanr #-}
 prescanr = G.prescanr
 
--- | Prefix right-to-left scan with strict accumulator
-prescanr'
-  :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
+-- | /O(n)/ Right-to-left prescan with strict accumulator
+prescanr' :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE prescanr' #-}
 prescanr' = G.prescanr'
 
--- | Suffix right-to-left scan
-postscanr
-  :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
+-- | /O(n)/ Right-to-left scan
+postscanr :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE postscanr #-}
 postscanr = G.postscanr
 
--- | Suffix right-to-left scan with strict accumulator
-postscanr'
-  :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
+-- | /O(n)/ Right-to-left scan with strict accumulator
+postscanr' :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE postscanr' #-}
 postscanr' = G.postscanr'
 
--- | Haskell-style right-to-left scan
+-- | /O(n)/ Right-to-left Haskell-style scan
 scanr :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE scanr #-}
 scanr = G.scanr
 
--- | Haskell-style right-to-left scan with strict accumulator
+-- | /O(n)/ Right-to-left Haskell-style scan with strict accumulator
 scanr' :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE scanr' #-}
 scanr' = G.scanr'
 
--- | Right-to-left scan over a non-empty vector
+-- | /O(n)/ Right-to-left scan over a non-empty vector
 scanr1 :: Storable a => (a -> a -> a) -> Vector a -> Vector a
 {-# INLINE scanr1 #-}
 scanr1 = G.scanr1
 
--- | Right-to-left scan over a non-empty vector with a strict accumulator
+-- | /O(n)/ Right-to-left scan over a non-empty vector with a strict
+-- accumulator
 scanr1' :: Storable a => (a -> a -> a) -> Vector a -> Vector a
 {-# INLINE scanr1' #-}
 scanr1' = G.scanr1'
 
--- Enumeration
--- -----------
-
--- | Yield a vector of the given length containing the values @x@, @x+1@ etc.
--- This operation is usually more efficient than 'enumFromTo'.
-enumFromN :: (Storable a, Num a) => a -> Int -> Vector a
-{-# INLINE enumFromN #-}
-enumFromN = G.enumFromN
-
--- | Yield a vector of the given length containing the values @x@, @x+y@,
--- @x+y+y@ etc. This operations is usually more efficient than
--- 'enumFromThenTo'.
-enumFromStepN :: (Storable a, Num a) => a -> a -> Int -> Vector a
-{-# INLINE enumFromStepN #-}
-enumFromStepN = G.enumFromStepN
-
--- | Enumerate values from @x@ to @y@.
---
--- /WARNING:/ This operation can be very inefficient. If at all possible, use
--- 'enumFromN' instead.
-enumFromTo :: (Storable a, Enum a) => a -> a -> Vector a
-{-# INLINE enumFromTo #-}
-enumFromTo = G.enumFromTo
-
--- | Enumerate values from @x@ to @y@ with a specific step @z@.
---
--- /WARNING:/ This operation can be very inefficient. If at all possible, use
--- 'enumFromStepN' instead.
-enumFromThenTo :: (Storable a, Enum a) => a -> a -> a -> Vector a
-{-# INLINE enumFromThenTo #-}
-enumFromThenTo = G.enumFromThenTo
-
--- Conversion to/from lists
+-- Conversions - Lists
 -- ------------------------
 
--- | Convert a vector to a list
+-- | /O(n)/ Convert a vector to a list
 toList :: Storable a => Vector a -> [a]
 {-# INLINE toList #-}
 toList = G.toList
 
--- | Convert a list to a vector
+-- | /O(n)/ Convert a list to a vector
 fromList :: Storable a => [a] -> Vector a
 {-# INLINE fromList #-}
 fromList = G.fromList
 
--- | Convert the first @n@ elements of a list to a vector
+-- | /O(n)/ Convert the first @n@ elements of a list to a vector
 --
--- > fromListN n xs = fromList (take n xs)
+-- @
+-- fromListN n xs = 'fromList' ('take' n xs)
+-- @
 fromListN :: Storable a => Int -> [a] -> Vector a
 {-# INLINE fromListN #-}
 fromListN = G.fromListN
 
--- Monadic operations
--- ------------------
-
--- | Perform the monadic action the given number of times and store the
--- results in a vector.
-replicateM :: (Monad m, Storable a) => Int -> m a -> m (Vector a)
-{-# INLINE replicateM #-}
-replicateM = G.replicateM
-
--- | Apply the monadic action to all elements of the vector, yielding a vector
--- of results
-mapM :: (Monad m, Storable a, Storable b) => (a -> m b) -> Vector a -> m (Vector b)
-{-# INLINE mapM #-}
-mapM = G.mapM
-
--- | Apply the monadic action to all elements of a vector and ignore the
--- results
-mapM_ :: (Monad m, Storable a) => (a -> m b) -> Vector a -> m ()
-{-# INLINE mapM_ #-}
-mapM_ = G.mapM_
-
--- | Apply the monadic action to all elements of the vector, yielding a vector
--- of results
-forM :: (Monad m, Storable a, Storable b) => Vector a -> (a -> m b) -> m (Vector b)
-{-# INLINE forM #-}
-forM = G.forM
-
--- | Apply the monadic action to all elements of a vector and ignore the
--- results
-forM_ :: (Monad m, Storable a) => Vector a -> (a -> m b) -> m ()
-{-# INLINE forM_ #-}
-forM_ = G.forM_
-
--- | Zip the two vectors with the monadic action and yield a vector of results
-zipWithM :: (Monad m, Storable a, Storable b, Storable c)
-         => (a -> b -> m c) -> Vector a -> Vector b -> m (Vector c)
-{-# INLINE zipWithM #-}
-zipWithM = G.zipWithM
-
--- | Zip the two vectors with the monadic action and ignore the results
-zipWithM_ :: (Monad m, Storable a, Storable b)
-          => (a -> b -> m c) -> Vector a -> Vector b -> m ()
-{-# INLINE zipWithM_ #-}
-zipWithM_ = G.zipWithM_
-
--- | Drop elements that do not satisfy the monadic predicate
-filterM :: (Monad m, Storable a) => (a -> m Bool) -> Vector a -> m (Vector a)
-{-# INLINE filterM #-}
-filterM = G.filterM
-
--- | Monadic fold
-foldM :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector b -> m a
-{-# INLINE foldM #-}
-foldM = G.foldM
-
--- | Monadic fold over non-empty vectors
-fold1M :: (Monad m, Storable a) => (a -> a -> m a) -> Vector a -> m a
-{-# INLINE fold1M #-}
-fold1M = G.fold1M
-
--- | Monadic fold with strict accumulator
-foldM' :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector b -> m a
-{-# INLINE foldM' #-}
-foldM' = G.foldM'
-
--- | Monad fold over non-empty vectors with strict accumulator
-fold1M' :: (Monad m, Storable a) => (a -> a -> m a) -> Vector a -> m a
-{-# INLINE fold1M' #-}
-fold1M' = G.fold1M'
-
--- Destructive operations
--- ----------------------
-
--- | Destructively initialise a vector.
-create :: Storable a => (forall s. ST s (MVector s a)) -> Vector a
-{-# INLINE create #-}
-create = G.create
-
--- | Apply a destructive operation to a vector. The operation is applied to a
--- copy of the vector unless it can be safely performed in place.
-modify
-  :: Storable a => (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a
-{-# INLINE modify #-}
-modify = G.modify
+-- Conversions - Mutable vectors
+-- -----------------------------
 
--- | Copy an immutable vector into a mutable one. The two vectors must have
--- the same length. This is not checked.
+-- | /O(n)/ Copy an immutable vector into a mutable one. The two vectors must
+-- have the same length.
 unsafeCopy
   :: (Storable a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m ()
 {-# INLINE unsafeCopy #-}
 unsafeCopy = G.unsafeCopy
            
--- | Copy an immutable vector into a mutable one. The two vectors must have the
--- same length.
+-- | /O(n)/ Copy an immutable vector into a mutable one. The two vectors must
+-- have the same length. This is not checked.
 copy :: (Storable a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m ()
 {-# INLINE copy #-}
 copy = G.copy
 
--- Accessing the underlying memory
--- -------------------------------
+-- Conversions - Raw pointers
+-- --------------------------
 
--- | Create a vector from a 'ForeignPtr' with an offset and a length. The data
--- may not be modified through the 'ForeignPtr' afterwards.
+-- | /O(1)/ Create a vector from a 'ForeignPtr' with an offset and a length.
+-- The data may not be modified through the 'ForeignPtr' afterwards.
 unsafeFromForeignPtr :: Storable a
                      => ForeignPtr a    -- ^ pointer
                      -> Int             -- ^ offset
@@ -1023,8 +1258,8 @@
 {-# INLINE unsafeFromForeignPtr #-}
 unsafeFromForeignPtr fp i n = Vector (offsetToPtr fp i) n fp
 
--- | Yield the underlying 'ForeignPtr' together with the offset to the data
--- and its length. The data may not be modified through the 'ForeignPtr'.
+-- | /O(1)/ Yield the underlying 'ForeignPtr' together with the offset to the
+-- data and its length. The data may not be modified through the 'ForeignPtr'.
 unsafeToForeignPtr :: Storable a => Vector a -> (ForeignPtr a, Int, Int)
 {-# INLINE unsafeToForeignPtr #-}
 unsafeToForeignPtr (Vector p n fp) = (fp, ptrToOffset fp p, n)
diff --git a/Data/Vector/Unboxed.hs b/Data/Vector/Unboxed.hs
--- a/Data/Vector/Unboxed.hs
+++ b/Data/Vector/Unboxed.hs
@@ -9,65 +9,134 @@
 -- Stability   : experimental
 -- Portability : non-portable
 --
--- Adaptive unboxed vectors
+-- Adaptive unboxed vectors. The implementation is based on type families
+-- and picks an efficient, specialised representation for every element type.
+-- In particular, unboxed vectors of pairs are represented as pairs of unboxed
+-- vectors.
 --
+-- Implementing unboxed vectors for new data types can be very easy. Here is
+-- how the library does this for 'Complex' by simply wrapping vectors of
+-- pairs.
+--
+-- @
+-- newtype instance 'MVector' s ('Complex' a) = MV_Complex ('MVector' s (a,a))
+-- newtype instance 'Vector'    ('Complex' a) = V_Complex  ('Vector'    (a,a))
+--
+-- instance ('RealFloat' a, 'Unbox' a) => 'Data.Vector.Generic.Mutable.MVector' 'MVector' ('Complex' a) where
+--   {-\# INLINE basicLength \#-}
+--   basicLength (MV_Complex v) = 'Data.Vector.Generic.Mutable.basicLength' v
+--   ...
+--
+-- instance ('RealFloat' a, 'Unbox' a) => Data.Vector.Generic.Vector 'Vector' ('Complex' a) where
+--   {-\# INLINE basicLength \#-}
+--   basicLength (V_Complex v) = Data.Vector.Generic.basicLength v
+--   ...
+--
+-- instance ('RealFloat' a, 'Unbox' a) => 'Unbox' ('Complex' a)
+-- @
 
 module Data.Vector.Unboxed (
+  -- * Unboxed vectors
   Vector, MVector(..), Unbox,
 
-  -- * Length information
-  length, null,
+  -- * Accessors
 
-  -- * Construction
-  empty, singleton, cons, snoc, replicate, generate, (++), force,
+  -- ** Length information
+  length, null,
 
-  -- * Accessing individual elements
-  (!), head, last, indexM, headM, lastM,
+  -- ** Indexing
+  (!), head, last,
   unsafeIndex, unsafeHead, unsafeLast,
+
+  -- ** Monadic indexing
+  indexM, headM, lastM,
   unsafeIndexM, unsafeHeadM, unsafeLastM,
 
-  -- * Subvectors
+  -- ** Extracting subvectors (slicing)
   slice, init, tail, take, drop,
   unsafeSlice, unsafeInit, unsafeTail, unsafeTake, unsafeDrop,
 
-  -- * Permutations
-  accum, accumulate, accumulate_,
+  -- * Construction
+
+  -- ** Initialisation
+  empty, singleton, replicate, generate,
+
+  -- ** Monadic initialisation
+  replicateM, create,
+
+  -- ** Unfolding
+  unfoldr, unfoldrN,
+
+  -- ** Enumeration
+  enumFromN, enumFromStepN, enumFromTo, enumFromThenTo,
+
+  -- ** Concatenation
+  cons, snoc, (++),
+
+  -- ** Restricting memory usage
+  force,
+
+  -- * Modifying vectors
+
+  -- ** Bulk updates
   (//), update, update_,
-  backpermute, reverse,
-  unsafeAccum, unsafeAccumulate, unsafeAccumulate_,
   unsafeUpd, unsafeUpdate, unsafeUpdate_,
-  unsafeBackpermute,
 
-  -- * Mapping
+  -- ** Accumulations
+  accum, accumulate, accumulate_,
+  unsafeAccum, unsafeAccumulate, unsafeAccumulate_,
+
+  -- ** Permutations 
+  reverse, backpermute, unsafeBackpermute,
+
+  -- ** Safe destructive updates
+  modify,
+
+  -- * Elementwise operations
+
+  -- ** Mapping
   map, imap, concatMap,
 
-  -- * Zipping and unzipping
+  -- ** Monadic mapping
+  mapM, mapM_, forM, forM_,
+
+  -- ** Zipping
   zipWith, zipWith3, zipWith4, zipWith5, zipWith6,
   izipWith, izipWith3, izipWith4, izipWith5, izipWith6,
   zip, zip3, zip4, zip5, zip6,
+
+  -- ** Monadic zipping
+  zipWithM, zipWithM_,
+
+  -- ** Unzipping
   unzip, unzip3, unzip4, unzip5, unzip6,
 
-  -- * Filtering
-  filter, ifilter, takeWhile, dropWhile,
+  -- * Working with predicates
+
+  -- ** Filtering
+  filter, ifilter, filterM,
+  takeWhile, dropWhile,
+
+  -- ** Partitioning
   partition, unstablePartition, span, break,
 
-  -- * Searching
+  -- ** Searching
   elem, notElem, find, findIndex, findIndices, elemIndex, elemIndices,
 
   -- * Folding
   foldl, foldl1, foldl', foldl1', foldr, foldr1, foldr', foldr1',
   ifoldl, ifoldl', ifoldr, ifoldr',
 
-  -- * Specialised folds
+  -- ** Specialised folds
   all, any, and, or,
   sum, product,
   maximum, maximumBy, minimum, minimumBy,
   minIndex, minIndexBy, maxIndex, maxIndexBy,
 
-  -- * Unfolding
-  unfoldr, unfoldrN,
+  -- ** Monadic folds
+  foldM, foldM', fold1M, fold1M',
 
-  -- * Scans
+  -- * Prefix sums (scans)
   prescanl, prescanl',
   postscanl, postscanl',
   scanl, scanl', scanl1, scanl1',
@@ -75,18 +144,13 @@
   postscanr, postscanr',
   scanr, scanr', scanr1, scanr1',
 
-  -- * Enumeration
-  enumFromN, enumFromStepN, enumFromTo, enumFromThenTo,
+  -- * Conversions
 
-  -- * Conversion to/from lists
+  -- ** Lists
   toList, fromList, fromListN,
 
-  -- * Monadic operations
-  replicateM, mapM, mapM_, forM, forM_, zipWithM, zipWithM_, filterM,
-  foldM, foldM', fold1M, fold1M',
-
-  -- * Destructive operations
-  create, modify, copy, unsafeCopy
+  -- ** Mutable vectors
+  copy, unsafeCopy
 ) where
 
 import Data.Vector.Unboxed.Base
@@ -141,269 +205,524 @@
 instance (Show a, Unbox a) => Show (Vector a) where
     show = (Prelude.++ " :: Data.Vector.Unboxed.Vector") . ("fromList " Prelude.++) . show . toList
 
--- Length
--- ------
+-- Length information
+-- ------------------
 
+-- | /O(1)/ Yield the length of the vector.
 length :: Unbox a => Vector a -> Int
 {-# INLINE length #-}
 length = G.length
 
+-- | /O(1)/ Test whether a vector if empty
 null :: Unbox a => Vector a -> Bool
 {-# INLINE null #-}
 null = G.null
 
--- Construction
--- ------------
-
--- | Empty vector
-empty :: Unbox a => Vector a
-{-# INLINE empty #-}
-empty = G.empty
-
--- | Vector with exaclty one element
-singleton :: Unbox a => a -> Vector a
-{-# INLINE singleton #-}
-singleton = G.singleton
-
--- | Vector of the given length with the given value in each position
-replicate :: Unbox a => Int -> a -> Vector a
-{-# INLINE replicate #-}
-replicate = G.replicate
-
--- | Generate a vector of the given length by applying the function to each
--- index
-generate :: Unbox a => Int -> (Int -> a) -> Vector a
-{-# INLINE generate #-}
-generate = G.generate
-
--- | Prepend an element
-cons :: Unbox a => a -> Vector a -> Vector a
-{-# INLINE cons #-}
-cons = G.cons
-
--- | Append an element
-snoc :: Unbox a => Vector a -> a -> Vector a
-{-# INLINE snoc #-}
-snoc = G.snoc
-
-infixr 5 ++
--- | Concatenate two vectors
-(++) :: Unbox a => Vector a -> Vector a -> Vector a
-{-# INLINE (++) #-}
-(++) = (G.++)
-
--- | Create a copy of a vector. Useful when dealing with slices.
-force :: Unbox a => Vector a -> Vector a
-{-# INLINE force #-}
-force = G.force
-
--- Accessing individual elements
--- -----------------------------
+-- Indexing
+-- --------
 
--- | Indexing
+-- | O(1) Indexing
 (!) :: Unbox a => Vector a -> Int -> a
 {-# INLINE (!) #-}
 (!) = (G.!)
 
--- | First element
+-- | /O(1)/ First element
 head :: Unbox a => Vector a -> a
 {-# INLINE head #-}
 head = G.head
 
--- | Last element
+-- | /O(1)/ Last element
 last :: Unbox a => Vector a -> a
 {-# INLINE last #-}
 last = G.last
 
--- | Unsafe indexing without bounds checking
+-- | /O(1)/ Unsafe indexing without bounds checking
 unsafeIndex :: Unbox a => Vector a -> Int -> a
 {-# INLINE unsafeIndex #-}
 unsafeIndex = G.unsafeIndex
 
--- | Yield the first element of a vector without checking if the vector is
--- empty
+-- | /O(1)/ First element without checking if the vector is empty
 unsafeHead :: Unbox a => Vector a -> a
 {-# INLINE unsafeHead #-}
 unsafeHead = G.unsafeHead
 
--- | Yield the last element of a vector without checking if the vector is
--- empty
+-- | /O(1)/ Last element without checking if the vector is empty
 unsafeLast :: Unbox a => Vector a -> a
 {-# INLINE unsafeLast #-}
 unsafeLast = G.unsafeLast
 
--- | Monadic indexing which can be strict in the vector while remaining lazy in
--- the element
+-- Monadic indexing
+-- ----------------
+
+-- | /O(1)/ Indexing in a monad.
+--
+-- The monad allows operations to be strict in the vector when necessary.
+-- Suppose vector copying is implemented like this:
+--
+-- > copy mv v = ... write mv i (v ! i) ...
+--
+-- For lazy vectors, @v ! i@ would not be evaluated which means that @mv@
+-- would unnecessarily retain a reference to @v@ in each element written.
+--
+-- With 'indexM', copying can be implemented like this instead:
+--
+-- > copy mv v = ... do
+-- >                   x <- indexM v i
+-- >                   write mv i x
+--
+-- Here, no references to @v@ are retained because indexing (but /not/ the
+-- elements) is evaluated eagerly.
+--
 indexM :: (Unbox a, Monad m) => Vector a -> Int -> m a
 {-# INLINE indexM #-}
 indexM = G.indexM
 
+-- | /O(1)/ First element of a vector in a monad. See 'indexM' for an
+-- explanation of why this is useful.
 headM :: (Unbox a, Monad m) => Vector a -> m a
 {-# INLINE headM #-}
 headM = G.headM
 
+-- | /O(1)/ Last element of a vector in a monad. See 'indexM' for an
+-- explanation of why this is useful.
 lastM :: (Unbox a, Monad m) => Vector a -> m a
 {-# INLINE lastM #-}
 lastM = G.lastM
 
--- | Unsafe monadic indexing without bounds checks
+-- | /O(1)/ Indexing in a monad without bounds checks. See 'indexM' for an
+-- explanation of why this is useful.
 unsafeIndexM :: (Unbox a, Monad m) => Vector a -> Int -> m a
 {-# INLINE unsafeIndexM #-}
 unsafeIndexM = G.unsafeIndexM
 
+-- | /O(1)/ First element in a monad without checking for empty vectors.
+-- See 'indexM' for an explanation of why this is useful.
 unsafeHeadM :: (Unbox a, Monad m) => Vector a -> m a
 {-# INLINE unsafeHeadM #-}
 unsafeHeadM = G.unsafeHeadM
 
+-- | /O(1)/ Last element in a monad without checking for empty vectors.
+-- See 'indexM' for an explanation of why this is useful.
 unsafeLastM :: (Unbox a, Monad m) => Vector a -> m a
 {-# INLINE unsafeLastM #-}
 unsafeLastM = G.unsafeLastM
 
--- Subarrays
--- ---------
+-- Extracting subvectors (slicing)
+-- -------------------------------
 
--- | Yield a part of the vector without copying it. Safer version of
--- 'basicUnsafeSlice'.
-slice :: Unbox a => Int   -- ^ starting index
-                 -> Int   -- ^ length
+-- | /O(1)/ Yield a slice of the vector without copying it. The vector must
+-- contain at least @i+n@ elements.
+slice :: Unbox a => Int   -- ^ @i@ starting index
+                 -> Int   -- ^ @n@ length
                  -> Vector a
                  -> Vector a
 {-# INLINE slice #-}
 slice = G.slice
 
--- | Yield all but the last element without copying.
+-- | /O(1)/ Yield all but the last element without copying. The vector may not
+-- be empty.
 init :: Unbox a => Vector a -> Vector a
 {-# INLINE init #-}
 init = G.init
 
--- | All but the first element (without copying).
+-- | /O(1)/ Yield all but the first element without copying. The vector may not
+-- be empty.
 tail :: Unbox a => Vector a -> Vector a
 {-# INLINE tail #-}
 tail = G.tail
 
--- | Yield the first @n@ elements without copying.
+-- | /O(1)/ Yield at the first @n@ elements without copying. The vector may
+-- contain less than @n@ elements in which case it is returned unchanged.
 take :: Unbox a => Int -> Vector a -> Vector a
 {-# INLINE take #-}
 take = G.take
 
--- | Yield all but the first @n@ elements without copying.
+-- | /O(1)/ Yield all but the first @n@ elements without copying. The vector may
+-- contain less than @n@ elements in which case an empty vector is returned.
 drop :: Unbox a => Int -> Vector a -> Vector a
 {-# INLINE drop #-}
 drop = G.drop
 
--- | Unsafely yield a part of the vector without copying it and without
--- performing bounds checks.
-unsafeSlice :: Unbox a => Int   -- ^ starting index
-                       -> Int   -- ^ length
+-- | /O(1)/ Yield a slice of the vector without copying. The vector must
+-- contain at least @i+n@ elements but this is not checked.
+unsafeSlice :: Unbox a => Int   -- ^ @i@ starting index
+                       -> Int   -- ^ @n@ length
                        -> Vector a
                        -> Vector a
 {-# INLINE unsafeSlice #-}
 unsafeSlice = G.unsafeSlice
 
+-- | /O(1)/ Yield all but the last element without copying. The vector may not
+-- be empty but this is not checked.
 unsafeInit :: Unbox a => Vector a -> Vector a
 {-# INLINE unsafeInit #-}
 unsafeInit = G.unsafeInit
 
+-- | /O(1)/ Yield all but the first element without copying. The vector may not
+-- be empty but this is not checked.
 unsafeTail :: Unbox a => Vector a -> Vector a
 {-# INLINE unsafeTail #-}
 unsafeTail = G.unsafeTail
 
+-- | /O(1)/ Yield the first @n@ elements without copying. The vector must
+-- contain at least @n@ elements but this is not checked.
 unsafeTake :: Unbox a => Int -> Vector a -> Vector a
 {-# INLINE unsafeTake #-}
 unsafeTake = G.unsafeTake
 
+-- | /O(1)/ Yield all but the first @n@ elements without copying. The vector
+-- must contain at least @n@ elements but this is not checked.
 unsafeDrop :: Unbox a => Int -> Vector a -> Vector a
 {-# INLINE unsafeDrop #-}
 unsafeDrop = G.unsafeDrop
 
--- Permutations
--- ------------
+-- Initialisation
+-- --------------
 
-unsafeAccum :: Unbox a => (a -> b -> a) -> Vector a -> [(Int,b)] -> Vector a
-{-# INLINE unsafeAccum #-}
-unsafeAccum = G.unsafeAccum
+-- | /O(1)/ Empty vector
+empty :: Unbox a => Vector a
+{-# INLINE empty #-}
+empty = G.empty
 
-unsafeAccumulate :: (Unbox a, Unbox b)
-                => (a -> b -> a) -> Vector a -> Vector (Int,b) -> Vector a
-{-# INLINE unsafeAccumulate #-}
-unsafeAccumulate = G.unsafeAccumulate
+-- | /O(1)/ Vector with exactly one element
+singleton :: Unbox a => a -> Vector a
+{-# INLINE singleton #-}
+singleton = G.singleton
 
-unsafeAccumulate_ :: (Unbox a, Unbox b) =>
-               (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
-{-# INLINE unsafeAccumulate_ #-}
-unsafeAccumulate_ = G.unsafeAccumulate_
+-- | /O(n)/ Vector of the given length with the same value in each position
+replicate :: Unbox a => Int -> a -> Vector a
+{-# INLINE replicate #-}
+replicate = G.replicate
 
-accum :: Unbox a => (a -> b -> a) -> Vector a -> [(Int,b)] -> Vector a
-{-# INLINE accum #-}
-accum = G.accum
+-- | /O(n)/ Construct a vector of the given length by applying the function to
+-- each index
+generate :: Unbox a => Int -> (Int -> a) -> Vector a
+{-# INLINE generate #-}
+generate = G.generate
 
-accumulate :: (Unbox a, Unbox b)
-                => (a -> b -> a) -> Vector a -> Vector (Int,b) -> Vector a
-{-# INLINE accumulate #-}
-accumulate = G.accumulate
+-- Unfolding
+-- ---------
 
-accumulate_ :: (Unbox a, Unbox b) =>
-               (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
-{-# INLINE accumulate_ #-}
-accumulate_ = G.accumulate_
+-- | /O(n)/ Construct a vector by repeatedly applying the generator function
+-- to a seed. The generator function yields 'Just' the next element and the
+-- new seed or 'Nothing' if there are no more elements.
+--
+-- > unfoldr (\n -> if n == 0 then Nothing else Just (n,n-1)) 10
+-- >  = <10,9,8,7,6,5,4,3,2,1>
+unfoldr :: Unbox a => (b -> Maybe (a, b)) -> b -> Vector a
+{-# INLINE unfoldr #-}
+unfoldr = G.unfoldr
 
+-- | /O(n)/ Construct a vector with at most @n@ by repeatedly applying the
+-- generator function to the a seed. The generator function yields 'Just' the
+-- next element and the new seed or 'Nothing' if there are no more elements.
+--
+-- > unfoldrN 3 (\n -> Just (n,n-1)) 10 = <10,9,8>
+unfoldrN :: Unbox a => Int -> (b -> Maybe (a, b)) -> b -> Vector a
+{-# INLINE unfoldrN #-}
+unfoldrN = G.unfoldrN
+
+-- Enumeration
+-- -----------
+
+-- | /O(n)/ Yield a vector of the given length containing the values @x@, @x+1@
+-- etc. This operation is usually more efficient than 'enumFromTo'.
+--
+-- > enumFromN 5 3 = <5,6,7>
+enumFromN :: (Unbox a, Num a) => a -> Int -> Vector a
+{-# INLINE enumFromN #-}
+enumFromN = G.enumFromN
+
+-- | /O(n)/ Yield a vector of the given length containing the values @x@, @x+y@,
+-- @x+y+y@ etc. This operations is usually more efficient than 'enumFromThenTo'.
+--
+-- > enumFromStepN 1 0.1 5 = <1,1.1,1.2,1.3,1.4>
+enumFromStepN :: (Unbox a, Num a) => a -> a -> Int -> Vector a
+{-# INLINE enumFromStepN #-}
+enumFromStepN = G.enumFromStepN
+
+-- | /O(n)/ Enumerate values from @x@ to @y@.
+--
+-- /WARNING:/ This operation can be very inefficient. If at all possible, use
+-- 'enumFromN' instead.
+enumFromTo :: (Unbox a, Enum a) => a -> a -> Vector a
+{-# INLINE enumFromTo #-}
+enumFromTo = G.enumFromTo
+
+-- | /O(n)/ Enumerate values from @x@ to @y@ with a specific step @z@.
+--
+-- /WARNING:/ This operation can be very inefficient. If at all possible, use
+-- 'enumFromStepN' instead.
+enumFromThenTo :: (Unbox a, Enum a) => a -> a -> a -> Vector a
+{-# INLINE enumFromThenTo #-}
+enumFromThenTo = G.enumFromThenTo
+
+-- Concatenation
+-- -------------
+
+-- | /O(n)/ Prepend an element
+cons :: Unbox a => a -> Vector a -> Vector a
+{-# INLINE cons #-}
+cons = G.cons
+
+-- | /O(n)/ Append an element
+snoc :: Unbox a => Vector a -> a -> Vector a
+{-# INLINE snoc #-}
+snoc = G.snoc
+
+infixr 5 ++
+-- | /O(m+n)/ Concatenate two vectors
+(++) :: Unbox a => Vector a -> Vector a -> Vector a
+{-# INLINE (++) #-}
+(++) = (G.++)
+
+-- Monadic initialisation
+-- ----------------------
+
+-- | /O(n)/ Execute the monadic action the given number of times and store the
+-- results in a vector.
+replicateM :: (Monad m, Unbox a) => Int -> m a -> m (Vector a)
+{-# INLINE replicateM #-}
+replicateM = G.replicateM
+
+-- | Execute the monadic action and freeze the resulting vector.
+--
+-- @
+-- create (do { v \<- new 2; write v 0 \'a\'; write v 1 \'b\' }) = \<'a','b'\>
+-- @
+create :: Unbox a => (forall s. ST s (MVector s a)) -> Vector a
+{-# INLINE create #-}
+create = G.create
+
+-- Restricting memory usage
+-- ------------------------
+
+-- | /O(n)/ Yield the argument but force it not to retain any extra memory,
+-- possibly by copying it.
+--
+-- This is especially useful when dealing with slices. For example:
+--
+-- > force (slice 0 2 <huge vector>)
+--
+-- Here, the slice retains a reference to the huge vector. Forcing it creates
+-- a copy of just the elements that belong to the slice and allows the huge
+-- vector to be garbage collected.
+force :: Unbox a => Vector a -> Vector a
+{-# INLINE force #-}
+force = G.force
+
+-- Bulk updates
+-- ------------
+
+-- | /O(m+n)/ For each pair @(i,a)@ from the list, replace the vector
+-- element at position @i@ by @a@.
+--
+-- > <5,9,2,7> // [(2,1),(0,3),(2,8)] = <3,9,8,7>
+--
+(//) :: Unbox a => Vector a   -- ^ initial vector (of length @m@)
+                -> [(Int, a)] -- ^ list of index/value pairs (of length @n@) 
+                -> Vector a
+{-# INLINE (//) #-}
+(//) = (G.//)
+
+-- | /O(m+n)/ For each pair @(i,a)@ from the vector of index/value pairs,
+-- replace the vector element at position @i@ by @a@.
+--
+-- > update <5,9,2,7> <(2,1),(0,3),(2,8)> = <3,9,8,7>
+--
+update :: Unbox a
+       => Vector a        -- ^ initial vector (of length @m@)
+       -> Vector (Int, a) -- ^ vector of index/value pairs (of length @n@)
+       -> Vector a
+{-# INLINE update #-}
+update = G.update
+
+-- | /O(m+min(n1,n2))/ For each index @i@ from the index vector and the
+-- corresponding value @a@ from the value vector, replace the element of the
+-- initial vector at position @i@ by @a@.
+--
+-- > update_ <5,9,2,7>  <2,0,2> <1,3,8> = <3,9,8,7>
+--
+-- The function 'update' provides the same functionality and is usually more
+-- convenient.
+--
+-- @
+-- update_ xs is ys = 'update' xs ('zip' is ys)
+-- @
+update_ :: Unbox a
+        => Vector a   -- ^ initial vector (of length @m@)
+        -> Vector Int -- ^ index vector (of length @n1@)
+        -> Vector a   -- ^ value vector (of length @n2@)
+        -> Vector a
+{-# INLINE update_ #-}
+update_ = G.update_
+
+-- | Same as ('//') but without bounds checking.
 unsafeUpd :: Unbox a => Vector a -> [(Int, a)] -> Vector a
 {-# INLINE unsafeUpd #-}
 unsafeUpd = G.unsafeUpd
 
+-- | Same as 'update' but without bounds checking.
 unsafeUpdate :: Unbox a => Vector a -> Vector (Int, a) -> Vector a
 {-# INLINE unsafeUpdate #-}
 unsafeUpdate = G.unsafeUpdate
 
+-- | Same as 'update_' but without bounds checking.
 unsafeUpdate_ :: Unbox a => Vector a -> Vector Int -> Vector a -> Vector a
 {-# INLINE unsafeUpdate_ #-}
 unsafeUpdate_ = G.unsafeUpdate_
 
-(//) :: Unbox a => Vector a -> [(Int, a)] -> Vector a
-{-# INLINE (//) #-}
-(//) = (G.//)
+-- Accumulations
+-- -------------
 
-update :: Unbox a => Vector a -> Vector (Int, a) -> Vector a
-{-# INLINE update #-}
-update = G.update
+-- | /O(m+n)/ For each pair @(i,b)@ from the list, replace the vector element
+-- @a@ at position @i@ by @f a b@.
+--
+-- > accum (+) <5,9,2> [(2,4),(1,6),(0,3),(1,7)] = <5+3, 9+6+7, 2+4>
+accum :: Unbox a
+      => (a -> b -> a) -- ^ accumulating function @f@
+      -> Vector a      -- ^ initial vector (of length @m@)
+      -> [(Int,b)]     -- ^ list of index/value pairs (of length @n@)
+      -> Vector a
+{-# INLINE accum #-}
+accum = G.accum
 
-update_ :: Unbox a => Vector a -> Vector Int -> Vector a -> Vector a
-{-# INLINE update_ #-}
-update_ = G.update_
+-- | /O(m+n)/ For each pair @(i,b)@ from the vector of pairs, replace the vector
+-- element @a@ at position @i@ by @f a b@.
+--
+-- > accumulate (+) <5,9,2> <(2,4),(1,6),(0,3),(1,7)> = <5+3, 9+6+7, 2+4>
+accumulate :: (Unbox a, Unbox b)
+            => (a -> b -> a)  -- ^ accumulating function @f@
+            -> Vector a       -- ^ initial vector (of length @m@)
+            -> Vector (Int,b) -- ^ vector of index/value pairs (of length @n@)
+            -> Vector a
+{-# INLINE accumulate #-}
+accumulate = G.accumulate
 
+-- | /O(m+min(n1,n2))/ For each index @i@ from the index vector and the
+-- corresponding value @b@ from the the value vector,
+-- replace the element of the initial vector at
+-- position @i@ by @f a b@.
+--
+-- > accumulate_ (+) <5,9,2> <2,1,0,1> <4,6,3,7> = <5+3, 9+6+7, 2+4>
+--
+-- The function 'accumulate' provides the same functionality and is usually more
+-- convenient.
+--
+-- @
+-- accumulate_ f as is bs = 'accumulate' f as ('zip' is bs)
+-- @
+accumulate_ :: (Unbox a, Unbox b)
+            => (a -> b -> a) -- ^ accumulating function @f@
+            -> Vector a      -- ^ initial vector (of length @m@)
+            -> Vector Int    -- ^ index vector (of length @n1@)
+            -> Vector b      -- ^ value vector (of length @n2@)
+            -> Vector a
+{-# INLINE accumulate_ #-}
+accumulate_ = G.accumulate_
+
+-- | Same as 'accum' but without bounds checking.
+unsafeAccum :: Unbox a => (a -> b -> a) -> Vector a -> [(Int,b)] -> Vector a
+{-# INLINE unsafeAccum #-}
+unsafeAccum = G.unsafeAccum
+
+-- | Same as 'accumulate' but without bounds checking.
+unsafeAccumulate :: (Unbox a, Unbox b)
+                => (a -> b -> a) -> Vector a -> Vector (Int,b) -> Vector a
+{-# INLINE unsafeAccumulate #-}
+unsafeAccumulate = G.unsafeAccumulate
+
+-- | Same as 'accumulate_' but without bounds checking.
+unsafeAccumulate_ :: (Unbox a, Unbox b) =>
+               (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
+{-# INLINE unsafeAccumulate_ #-}
+unsafeAccumulate_ = G.unsafeAccumulate_
+
+-- Permutations
+-- ------------
+
+-- | /O(n)/ Reverse a vector
+reverse :: Unbox a => Vector a -> Vector a
+{-# INLINE reverse #-}
+reverse = G.reverse
+
+-- | /O(n)/ Yield the vector obtained by replacing each element @i@ of the
+-- index vector by @xs'!'i@. This is equivalent to @'map' (xs'!') is@ but is
+-- often much more efficient.
+--
+-- > backpermute <a,b,c,d> <0,3,2,3,1,0> = <a,d,c,d,b,a>
 backpermute :: Unbox a => Vector a -> Vector Int -> Vector a
 {-# INLINE backpermute #-}
 backpermute = G.backpermute
 
+-- | Same as 'backpermute' but without bounds checking.
 unsafeBackpermute :: Unbox a => Vector a -> Vector Int -> Vector a
 {-# INLINE unsafeBackpermute #-}
 unsafeBackpermute = G.unsafeBackpermute
 
-reverse :: Unbox a => Vector a -> Vector a
-{-# INLINE reverse #-}
-reverse = G.reverse
+-- Safe destructive updates
+-- ------------------------
 
+-- | Apply a destructive operation to a vector. The operation will be
+-- performed in place if it is safe to do so and will modify a copy of the
+-- vector otherwise.
+--
+-- @
+-- modify (\\v -> write v 0 \'x\') ('replicate' 3 \'a\') = \<\'x\',\'a\',\'a\'\>
+-- @
+modify :: Unbox a => (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a
+{-# INLINE modify #-}
+modify = G.modify
+
 -- Mapping
 -- -------
 
--- | Map a function over a vector
+-- | /O(n)/ Map a function over a vector
 map :: (Unbox a, Unbox b) => (a -> b) -> Vector a -> Vector b
 {-# INLINE map #-}
 map = G.map
 
--- | Apply a function to every index/value pair
+-- | /O(n)/ Apply a function to every element of a vector and its index
 imap :: (Unbox a, Unbox b) => (Int -> a -> b) -> Vector a -> Vector b
 {-# INLINE imap #-}
 imap = G.imap
 
+-- | Map a function over a vector and concatenate the results.
 concatMap :: (Unbox a, Unbox b) => (a -> Vector b) -> Vector a -> Vector b
 {-# INLINE concatMap #-}
 concatMap = G.concatMap
 
--- Zipping/unzipping
--- -----------------
+-- Monadic mapping
+-- ---------------
 
--- | Zip two vectors with the given function.
+-- | /O(n)/ Apply the monadic action to all elements of the vector, yielding a
+-- vector of results
+mapM :: (Monad m, Unbox a, Unbox b) => (a -> m b) -> Vector a -> m (Vector b)
+{-# INLINE mapM #-}
+mapM = G.mapM
+
+-- | /O(n)/ Apply the monadic action to all elements of a vector and ignore the
+-- results
+mapM_ :: (Monad m, Unbox a) => (a -> m b) -> Vector a -> m ()
+{-# INLINE mapM_ #-}
+mapM_ = G.mapM_
+
+-- | /O(n)/ Apply the monadic action to all elements of the vector, yielding a
+-- vector of results. Equvalent to @flip 'mapM'@.
+forM :: (Monad m, Unbox a, Unbox b) => Vector a -> (a -> m b) -> m (Vector b)
+{-# INLINE forM #-}
+forM = G.forM
+
+-- | /O(n)/ Apply the monadic action to all elements of a vector and ignore the
+-- results. Equivalent to @flip 'mapM_'@.
+forM_ :: (Monad m, Unbox a) => Vector a -> (a -> m b) -> m ()
+{-# INLINE forM_ #-}
+forM_ = G.forM_
+
+-- Zipping
+-- -------
+
+-- | /O(min(m,n))/ Zip two vectors with the given function.
 zipWith :: (Unbox a, Unbox b, Unbox c)
         => (a -> b -> c) -> Vector a -> Vector b -> Vector c
 {-# INLINE zipWith #-}
@@ -435,7 +754,8 @@
 {-# INLINE zipWith6 #-}
 zipWith6 = G.zipWith6
 
--- | Zip two vectors and their indices with the given function.
+-- | /O(min(m,n))/ Zip two vectors with a function that also takes the
+-- elements' indices.
 izipWith :: (Unbox a, Unbox b, Unbox c)
          => (Int -> a -> b -> c) -> Vector a -> Vector b -> Vector c
 {-# INLINE izipWith #-}
@@ -468,53 +788,81 @@
 {-# INLINE izipWith6 #-}
 izipWith6 = G.izipWith6
 
+-- Monadic zipping
+-- ---------------
+
+-- | /O(min(m,n))/ Zip the two vectors with the monadic action and yield a
+-- vector of results
+zipWithM :: (Monad m, Unbox a, Unbox b, Unbox c)
+         => (a -> b -> m c) -> Vector a -> Vector b -> m (Vector c)
+{-# INLINE zipWithM #-}
+zipWithM = G.zipWithM
+
+-- | /O(min(m,n))/ Zip the two vectors with the monadic action and ignore the
+-- results
+zipWithM_ :: (Monad m, Unbox a, Unbox b)
+          => (a -> b -> m c) -> Vector a -> Vector b -> m ()
+{-# INLINE zipWithM_ #-}
+zipWithM_ = G.zipWithM_
+
 -- Filtering
 -- ---------
 
--- | Drop elements which do not satisfy the predicate
+-- | /O(n)/ Drop elements that do not satisfy the predicate
 filter :: Unbox a => (a -> Bool) -> Vector a -> Vector a
 {-# INLINE filter #-}
 filter = G.filter
 
--- | Drop elements that do not satisfy the predicate (applied to values and
--- their indices)
+-- | /O(n)/ Drop elements that do not satisfy the predicate which is applied to
+-- values and their indices
 ifilter :: Unbox a => (Int -> a -> Bool) -> Vector a -> Vector a
 {-# INLINE ifilter #-}
 ifilter = G.ifilter
 
--- | Yield the longest prefix of elements satisfying the predicate.
+-- | /O(n)/ Drop elements that do not satisfy the monadic predicate
+filterM :: (Monad m, Unbox a) => (a -> m Bool) -> Vector a -> m (Vector a)
+{-# INLINE filterM #-}
+filterM = G.filterM
+
+-- | /O(n)/ Yield the longest prefix of elements satisfying the predicate
+-- without copying.
 takeWhile :: Unbox a => (a -> Bool) -> Vector a -> Vector a
 {-# INLINE takeWhile #-}
 takeWhile = G.takeWhile
 
--- | Drop the longest prefix of elements that satisfy the predicate.
+-- | /O(n)/ Drop the longest prefix of elements that satisfy the predicate
+-- without copying.
 dropWhile :: Unbox a => (a -> Bool) -> Vector a -> Vector a
 {-# INLINE dropWhile #-}
 dropWhile = G.dropWhile
 
--- | Split the vector in two parts, the first one containing those elements
--- that satisfy the predicate and the second one those that don't. The
--- relative order of the elements is preserved at the cost of a (sometimes)
+-- Parititioning
+-- -------------
+
+-- | /O(n)/ Split the vector in two parts, the first one containing those
+-- elements that satisfy the predicate and the second one those that don't. The
+-- relative order of the elements is preserved at the cost of a sometimes
 -- reduced performance compared to 'unstablePartition'.
 partition :: Unbox a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
 {-# INLINE partition #-}
 partition = G.partition
 
--- | Split the vector in two parts, the first one containing those elements
--- that satisfy the predicate and the second one those that don't. The order
--- of the elements is not preserved.
+-- | /O(n)/ Split the vector in two parts, the first one containing those
+-- elements that satisfy the predicate and the second one those that don't.
+-- The order of the elements is not preserved but the operation is often
+-- faster than 'partition'.
 unstablePartition :: Unbox a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
 {-# INLINE unstablePartition #-}
 unstablePartition = G.unstablePartition
 
--- | Split the vector into the longest prefix of elements that satisfy the
--- predicate and the rest.
+-- | /O(n)/ Split the vector into the longest prefix of elements that satisfy
+-- the predicate and the rest without copying.
 span :: Unbox a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
 {-# INLINE span #-}
 span = G.span
 
--- | Split the vector into the longest prefix of elements that do not satisfy
--- the predicate and the rest.
+-- | /O(n)/ Split the vector into the longest prefix of elements that do not
+-- satisfy the predicate and the rest without copying.
 break :: Unbox a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
 {-# INLINE break #-}
 break = G.break
@@ -523,41 +871,44 @@
 -- ---------
 
 infix 4 `elem`
--- | Check whether the vector contains an element
+-- | /O(n)/ Check if the vector contains an element
 elem :: (Unbox a, Eq a) => a -> Vector a -> Bool
 {-# INLINE elem #-}
 elem = G.elem
 
 infix 4 `notElem`
--- | Inverse of `elem`
+-- | /O(n)/ Check if the vector does not contain an element (inverse of 'elem')
 notElem :: (Unbox a, Eq a) => a -> Vector a -> Bool
 {-# INLINE notElem #-}
 notElem = G.notElem
 
--- | Yield 'Just' the first element matching the predicate or 'Nothing' if no
--- such element exists.
+-- | /O(n)/ Yield 'Just' the first element matching the predicate or 'Nothing'
+-- if no such element exists.
 find :: Unbox a => (a -> Bool) -> Vector a -> Maybe a
 {-# INLINE find #-}
 find = G.find
 
--- | Yield 'Just' the index of the first element matching the predicate or
--- 'Nothing' if no such element exists.
+-- | /O(n)/ Yield 'Just' the index of the first element matching the predicate
+-- or 'Nothing' if no such element exists.
 findIndex :: Unbox a => (a -> Bool) -> Vector a -> Maybe Int
 {-# INLINE findIndex #-}
 findIndex = G.findIndex
 
--- | Yield the indices of elements satisfying the predicate
+-- | /O(n)/ Yield the indices of elements satisfying the predicate in ascending
+-- order.
 findIndices :: Unbox a => (a -> Bool) -> Vector a -> Vector Int
 {-# INLINE findIndices #-}
 findIndices = G.findIndices
 
--- | Yield 'Just' the index of the first occurence of the given element or
--- 'Nothing' if the vector does not contain the element
+-- | /O(n)/ Yield 'Just' the index of the first occurence of the given element or
+-- 'Nothing' if the vector does not contain the element. This is a specialised
+-- version of 'findIndex'.
 elemIndex :: (Unbox a, Eq a) => a -> Vector a -> Maybe Int
 {-# INLINE elemIndex #-}
 elemIndex = G.elemIndex
 
--- | Yield the indices of all occurences of the given element
+-- | /O(n)/ Yield the indices of all occurences of the given element in
+-- ascending order. This is a specialised version of 'findIndices'.
 elemIndices :: (Unbox a, Eq a) => a -> Vector a -> Vector Int
 {-# INLINE elemIndices #-}
 elemIndices = G.elemIndices
@@ -565,64 +916,64 @@
 -- Folding
 -- -------
 
--- | Left fold
+-- | /O(n)/ Left fold
 foldl :: Unbox b => (a -> b -> a) -> a -> Vector b -> a
 {-# INLINE foldl #-}
 foldl = G.foldl
 
--- | Lefgt fold on non-empty vectors
+-- | /O(n)/ Left fold on non-empty vectors
 foldl1 :: Unbox a => (a -> a -> a) -> Vector a -> a
 {-# INLINE foldl1 #-}
 foldl1 = G.foldl1
 
--- | Left fold with strict accumulator
+-- | /O(n)/ Left fold with strict accumulator
 foldl' :: Unbox b => (a -> b -> a) -> a -> Vector b -> a
 {-# INLINE foldl' #-}
 foldl' = G.foldl'
 
--- | Left fold on non-empty vectors with strict accumulator
+-- | /O(n)/ Left fold on non-empty vectors with strict accumulator
 foldl1' :: Unbox a => (a -> a -> a) -> Vector a -> a
 {-# INLINE foldl1' #-}
 foldl1' = G.foldl1'
 
--- | Right fold
+-- | /O(n)/ Right fold
 foldr :: Unbox a => (a -> b -> b) -> b -> Vector a -> b
 {-# INLINE foldr #-}
 foldr = G.foldr
 
--- | Right fold on non-empty vectors
+-- | /O(n)/ Right fold on non-empty vectors
 foldr1 :: Unbox a => (a -> a -> a) -> Vector a -> a
 {-# INLINE foldr1 #-}
 foldr1 = G.foldr1
 
--- | Right fold with a strict accumulator
+-- | /O(n)/ Right fold with a strict accumulator
 foldr' :: Unbox a => (a -> b -> b) -> b -> Vector a -> b
 {-# INLINE foldr' #-}
 foldr' = G.foldr'
 
--- | Right fold on non-empty vectors with strict accumulator
+-- | /O(n)/ Right fold on non-empty vectors with strict accumulator
 foldr1' :: Unbox a => (a -> a -> a) -> Vector a -> a
 {-# INLINE foldr1' #-}
 foldr1' = G.foldr1'
 
--- | Left fold (function applied to each element and its index)
+-- | /O(n)/ Left fold (function applied to each element and its index)
 ifoldl :: Unbox b => (a -> Int -> b -> a) -> a -> Vector b -> a
 {-# INLINE ifoldl #-}
 ifoldl = G.ifoldl
 
--- | Left fold with strict accumulator (function applied to each element and
--- its index)
+-- | /O(n)/ Left fold with strict accumulator (function applied to each element
+-- and its index)
 ifoldl' :: Unbox b => (a -> Int -> b -> a) -> a -> Vector b -> a
 {-# INLINE ifoldl' #-}
 ifoldl' = G.ifoldl'
 
--- | Right fold (function applied to each element and its index)
+-- | /O(n)/ Right fold (function applied to each element and its index)
 ifoldr :: Unbox a => (Int -> a -> b -> b) -> b -> Vector a -> b
 {-# INLINE ifoldr #-}
 ifoldr = G.ifoldr
 
--- | Right fold with strict accumulator (function applied to each element and
--- its index)
+-- | /O(n)/ Right fold with strict accumulator (function applied to each
+-- element and its index)
 ifoldr' :: Unbox a => (Int -> a -> b -> b) -> b -> Vector a -> b
 {-# INLINE ifoldr' #-}
 ifoldr' = G.ifoldr'
@@ -630,315 +981,256 @@
 -- Specialised folds
 -- -----------------
 
+-- | /O(n)/ Check if all elements satisfy the predicate.
 all :: Unbox a => (a -> Bool) -> Vector a -> Bool
 {-# INLINE all #-}
 all = G.all
 
+-- | /O(n)/ Check if any element satisfies the predicate.
 any :: Unbox a => (a -> Bool) -> Vector a -> Bool
 {-# INLINE any #-}
 any = G.any
 
+-- | /O(n)/ Check if all elements are 'True'
 and :: Vector Bool -> Bool
 {-# INLINE and #-}
 and = G.and
 
+-- | /O(n)/ Check if any element is 'True'
 or :: Vector Bool -> Bool
 {-# INLINE or #-}
 or = G.or
 
+-- | /O(n)/ Compute the sum of the elements
 sum :: (Unbox a, Num a) => Vector a -> a
 {-# INLINE sum #-}
 sum = G.sum
 
+-- | /O(n)/ Compute the produce of the elements
 product :: (Unbox a, Num a) => Vector a -> a
 {-# INLINE product #-}
 product = G.product
 
+-- | /O(n)/ Yield the maximum element of the vector. The vector may not be
+-- empty.
 maximum :: (Unbox a, Ord a) => Vector a -> a
 {-# INLINE maximum #-}
 maximum = G.maximum
 
+-- | /O(n)/ Yield the maximum element of the vector according to the given
+-- comparison function. The vector may not be empty.
 maximumBy :: Unbox a => (a -> a -> Ordering) -> Vector a -> a
 {-# INLINE maximumBy #-}
 maximumBy = G.maximumBy
 
+-- | /O(n)/ Yield the minimum element of the vector. The vector may not be
+-- empty.
 minimum :: (Unbox a, Ord a) => Vector a -> a
 {-# INLINE minimum #-}
 minimum = G.minimum
 
+-- | /O(n)/ Yield the minimum element of the vector according to the given
+-- comparison function. The vector may not be empty.
 minimumBy :: Unbox a => (a -> a -> Ordering) -> Vector a -> a
 {-# INLINE minimumBy #-}
 minimumBy = G.minimumBy
 
+-- | /O(n)/ Yield the index of the maximum element of the vector. The vector
+-- may not be empty.
 maxIndex :: (Unbox a, Ord a) => Vector a -> Int
 {-# INLINE maxIndex #-}
 maxIndex = G.maxIndex
 
+-- | /O(n)/ Yield the index of the maximum element of the vector according to
+-- the given comparison function. The vector may not be empty.
 maxIndexBy :: Unbox a => (a -> a -> Ordering) -> Vector a -> Int
 {-# INLINE maxIndexBy #-}
 maxIndexBy = G.maxIndexBy
 
+-- | /O(n)/ Yield the index of the minimum element of the vector. The vector
+-- may not be empty.
 minIndex :: (Unbox a, Ord a) => Vector a -> Int
 {-# INLINE minIndex #-}
 minIndex = G.minIndex
 
+-- | /O(n)/ Yield the index of the minimum element of the vector according to
+-- the given comparison function. The vector may not be empty.
 minIndexBy :: Unbox a => (a -> a -> Ordering) -> Vector a -> Int
 {-# INLINE minIndexBy #-}
 minIndexBy = G.minIndexBy
 
--- Unfolding
--- ---------
+-- Monadic folds
+-- -------------
 
--- | The 'unfoldr' function is a \`dual\' to 'foldr': while 'foldr'
--- reduces a vector to a summary value, 'unfoldr' builds a list from
--- a seed value.  The function takes the element and returns 'Nothing'
--- if it is done generating the vector or returns 'Just' @(a,b)@, in which
--- case, @a@ is a prepended to the vector and @b@ is used as the next
--- element in a recursive call.
---
--- A simple use of unfoldr:
---
--- > unfoldr (\b -> if b == 0 then Nothing else Just (b, b-1)) 10
--- >  [10,9,8,7,6,5,4,3,2,1]
---
-unfoldr :: Unbox a => (b -> Maybe (a, b)) -> b -> Vector a
-{-# INLINE unfoldr #-}
-unfoldr = G.unfoldr
+-- | /O(n)/ Monadic fold
+foldM :: (Monad m, Unbox b) => (a -> b -> m a) -> a -> Vector b -> m a
+{-# INLINE foldM #-}
+foldM = G.foldM
 
--- | Unfold at most @n@ elements
-unfoldrN :: Unbox a => Int -> (b -> Maybe (a, b)) -> b -> Vector a
-{-# INLINE unfoldrN #-}
-unfoldrN = G.unfoldrN
+-- | /O(n)/ Monadic fold over non-empty vectors
+fold1M :: (Monad m, Unbox a) => (a -> a -> m a) -> Vector a -> m a
+{-# INLINE fold1M #-}
+fold1M = G.fold1M
 
--- Scans
--- -----
+-- | /O(n)/ Monadic fold with strict accumulator
+foldM' :: (Monad m, Unbox b) => (a -> b -> m a) -> a -> Vector b -> m a
+{-# INLINE foldM' #-}
+foldM' = G.foldM'
 
--- | Prefix scan
+-- | /O(n)/ Monad fold over non-empty vectors with strict accumulator
+fold1M' :: (Monad m, Unbox a) => (a -> a -> m a) -> Vector a -> m a
+{-# INLINE fold1M' #-}
+fold1M' = G.fold1M'
+
+-- Prefix sums (scans)
+-- -------------------
+
+-- | /O(n)/ Prescan
+--
+-- @
+-- prescanl f z = 'init' . 'scanl' f z
+-- @
+--
+-- Example: @prescanl (+) 0 \<1,2,3,4\> = \<0,1,3,6\>@
+--
 prescanl :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE prescanl #-}
 prescanl = G.prescanl
 
--- | Prefix scan with strict accumulator
+-- | /O(n)/ Prescan with strict accumulator
 prescanl' :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE prescanl' #-}
 prescanl' = G.prescanl'
 
--- | Suffix scan
+-- | /O(n)/ Scan
+--
+-- @
+-- postscanl f z = 'tail' . 'scanl' f z
+-- @
+--
+-- Example: @postscanl (+) 0 \<1,2,3,4\> = \<1,3,6,10\>@
+--
 postscanl :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE postscanl #-}
 postscanl = G.postscanl
 
--- | Suffix scan with strict accumulator
+-- | /O(n)/ Scan with strict accumulator
 postscanl' :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE postscanl' #-}
 postscanl' = G.postscanl'
 
--- | Haskell-style scan
+-- | /O(n)/ Haskell-style scan
+--
+-- > scanl f z <x1,...,xn> = <y1,...,y(n+1)>
+-- >   where y1 = z
+-- >         yi = f y(i-1) x(i-1)
+--
+-- Example: @scanl (+) 0 \<1,2,3,4\> = \<0,1,3,6,10\>@
+-- 
 scanl :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE scanl #-}
 scanl = G.scanl
 
--- | Haskell-style scan with strict accumulator
+-- | /O(n)/ Haskell-style scan with strict accumulator
 scanl' :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE scanl' #-}
 scanl' = G.scanl'
 
--- | Scan over a non-empty 'Vector'
+-- | /O(n)/ Scan over a non-empty vector
+--
+-- > scanl f <x1,...,xn> = <y1,...,yn>
+-- >   where y1 = x1
+-- >         yi = f y(i-1) xi
+--
 scanl1 :: Unbox a => (a -> a -> a) -> Vector a -> Vector a
 {-# INLINE scanl1 #-}
 scanl1 = G.scanl1
 
--- | Scan over a non-empty 'Vector' with a strict accumulator
+-- | /O(n)/ Scan over a non-empty vector with a strict accumulator
 scanl1' :: Unbox a => (a -> a -> a) -> Vector a -> Vector a
 {-# INLINE scanl1' #-}
 scanl1' = G.scanl1'
 
-
--- | Prefix right-to-left scan
+-- | /O(n)/ Right-to-left prescan
+--
+-- @
+-- prescanr f z = 'reverse' . 'prescanl' (flip f) z . 'reverse'
+-- @
+--
 prescanr :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE prescanr #-}
 prescanr = G.prescanr
 
--- | Prefix right-to-left scan with strict accumulator
+-- | /O(n)/ Right-to-left prescan with strict accumulator
 prescanr' :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE prescanr' #-}
 prescanr' = G.prescanr'
 
--- | Suffix right-to-left scan
+-- | /O(n)/ Right-to-left scan
 postscanr :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE postscanr #-}
 postscanr = G.postscanr
 
--- | Suffix right-to-left scan with strict accumulator
+-- | /O(n)/ Right-to-left scan with strict accumulator
 postscanr' :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE postscanr' #-}
 postscanr' = G.postscanr'
 
--- | Haskell-style right-to-left scan
+-- | /O(n)/ Right-to-left Haskell-style scan
 scanr :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE scanr #-}
 scanr = G.scanr
 
--- | Haskell-style right-to-left scan with strict accumulator
+-- | /O(n)/ Right-to-left Haskell-style scan with strict accumulator
 scanr' :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE scanr' #-}
 scanr' = G.scanr'
 
--- | Right-to-left scan over a non-empty vector
+-- | /O(n)/ Right-to-left scan over a non-empty vector
 scanr1 :: Unbox a => (a -> a -> a) -> Vector a -> Vector a
 {-# INLINE scanr1 #-}
 scanr1 = G.scanr1
 
--- | Right-to-left scan over a non-empty vector with a strict accumulator
+-- | /O(n)/ Right-to-left scan over a non-empty vector with a strict
+-- accumulator
 scanr1' :: Unbox a => (a -> a -> a) -> Vector a -> Vector a
 {-# INLINE scanr1' #-}
 scanr1' = G.scanr1'
 
--- Enumeration
--- -----------
-
--- | Yield a vector of the given length containing the values @x@, @x+1@ etc.
--- This operation is usually more efficient than 'enumFromTo'.
-enumFromN :: (Unbox a, Num a) => a -> Int -> Vector a
-{-# INLINE enumFromN #-}
-enumFromN = G.enumFromN
-
--- | Yield a vector of the given length containing the values @x@, @x+y@,
--- @x+y+y@ etc. This operations is usually more efficient than
--- 'enumFromThenTo'.
-enumFromStepN :: (Unbox a, Num a) => a -> a -> Int -> Vector a
-{-# INLINE enumFromStepN #-}
-enumFromStepN = G.enumFromStepN
-
--- | Enumerate values from @x@ to @y@.
---
--- /WARNING:/ This operation can be very inefficient. If at all possible, use
--- 'enumFromN' instead.
-enumFromTo :: (Unbox a, Enum a) => a -> a -> Vector a
-{-# INLINE enumFromTo #-}
-enumFromTo = G.enumFromTo
-
--- | Enumerate values from @x@ to @y@ with a specific step @z@.
---
--- /WARNING:/ This operation can be very inefficient. If at all possible, use
--- 'enumFromStepN' instead.
-enumFromThenTo :: (Unbox a, Enum a) => a -> a -> a -> Vector a
-{-# INLINE enumFromThenTo #-}
-enumFromThenTo = G.enumFromThenTo
-
--- Conversion to/from lists
+-- Conversions - Lists
 -- ------------------------
 
--- | Convert a vector to a list
+-- | /O(n)/ Convert a vector to a list
 toList :: Unbox a => Vector a -> [a]
 {-# INLINE toList #-}
 toList = G.toList
 
--- | Convert a list to a vector
+-- | /O(n)/ Convert a list to a vector
 fromList :: Unbox a => [a] -> Vector a
 {-# INLINE fromList #-}
 fromList = G.fromList
 
--- | Convert the first @n@ elements of a list to a vector
+-- | /O(n)/ Convert the first @n@ elements of a list to a vector
 --
--- > fromListN n xs = fromList (take n xs)
+-- @
+-- fromListN n xs = 'fromList' ('take' n xs)
+-- @
 fromListN :: Unbox a => Int -> [a] -> Vector a
 {-# INLINE fromListN #-}
 fromListN = G.fromListN
 
--- Monadic operations
--- ------------------
-
--- | Perform the monadic action the given number of times and store the
--- results in a vector.
-replicateM :: (Monad m, Unbox a) => Int -> m a -> m (Vector a)
-{-# INLINE replicateM #-}
-replicateM = G.replicateM
-
--- | Apply the monadic action to all elements of the vector, yielding a vector
--- of results
-mapM :: (Monad m, Unbox a, Unbox b) => (a -> m b) -> Vector a -> m (Vector b)
-{-# INLINE mapM #-}
-mapM = G.mapM
-
--- | Apply the monadic action to all elements of a vector and ignore the
--- results
-mapM_ :: (Monad m, Unbox a) => (a -> m b) -> Vector a -> m ()
-{-# INLINE mapM_ #-}
-mapM_ = G.mapM_
-
--- | Apply the monadic action to all elements of the vector, yielding a vector
--- of results
-forM :: (Monad m, Unbox a, Unbox b) => Vector a -> (a -> m b) -> m (Vector b)
-{-# INLINE forM #-}
-forM = G.forM
-
--- | Apply the monadic action to all elements of a vector and ignore the
--- results
-forM_ :: (Monad m, Unbox a) => Vector a -> (a -> m b) -> m ()
-{-# INLINE forM_ #-}
-forM_ = G.forM_
-
--- | Zip the two vectors with the monadic action and yield a vector of results
-zipWithM :: (Monad m, Unbox a, Unbox b, Unbox c)
-         => (a -> b -> m c) -> Vector a -> Vector b -> m (Vector c)
-{-# INLINE zipWithM #-}
-zipWithM = G.zipWithM
-
--- | Zip the two vectors with the monadic action and ignore the results
-zipWithM_ :: (Monad m, Unbox a, Unbox b)
-          => (a -> b -> m c) -> Vector a -> Vector b -> m ()
-{-# INLINE zipWithM_ #-}
-zipWithM_ = G.zipWithM_
-
--- | Drop elements that do not satisfy the monadic predicate
-filterM :: (Monad m, Unbox a) => (a -> m Bool) -> Vector a -> m (Vector a)
-{-# INLINE filterM #-}
-filterM = G.filterM
-
--- | Monadic fold
-foldM :: (Monad m, Unbox b) => (a -> b -> m a) -> a -> Vector b -> m a
-{-# INLINE foldM #-}
-foldM = G.foldM
-
--- | Monadic fold over non-empty vectors
-fold1M :: (Monad m, Unbox a) => (a -> a -> m a) -> Vector a -> m a
-{-# INLINE fold1M #-}
-fold1M = G.fold1M
-
--- | Monadic fold with strict accumulator
-foldM' :: (Monad m, Unbox b) => (a -> b -> m a) -> a -> Vector b -> m a
-{-# INLINE foldM' #-}
-foldM' = G.foldM'
-
--- | Monad fold over non-empty vectors with strict accumulator
-fold1M' :: (Monad m, Unbox a) => (a -> a -> m a) -> Vector a -> m a
-{-# INLINE fold1M' #-}
-fold1M' = G.fold1M'
-
--- Destructive operations
--- ----------------------
-
--- | Destructively initialise a vector.
-create :: Unbox a => (forall s. ST s (MVector s a)) -> Vector a
-{-# INLINE create #-}
-create = G.create
-
--- | Apply a destructive operation to a vector. The operation is applied to a
--- copy of the vector unless it can be safely performed in place.
-modify :: Unbox a => (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a
-{-# INLINE modify #-}
-modify = G.modify
+-- Conversions - Mutable vectors
+-- -----------------------------
 
--- | Copy an immutable vector into a mutable one. The two vectors must have
--- the same length. This is not checked.
+-- | /O(n)/ Copy an immutable vector into a mutable one. The two vectors must
+-- have the same length.
 unsafeCopy
   :: (Unbox a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m ()
 {-# INLINE unsafeCopy #-}
 unsafeCopy = G.unsafeCopy
            
--- | Copy an immutable vector into a mutable one. The two vectors must have the
--- same length.
+-- | /O(n)/ Copy an immutable vector into a mutable one. The two vectors must
+-- have the same length. This is not checked.
 copy :: (Unbox a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m ()
 {-# INLINE copy #-}
 copy = G.copy
diff --git a/Data/Vector/Unboxed/Base.hs b/Data/Vector/Unboxed/Base.hs
--- a/Data/Vector/Unboxed/Base.hs
+++ b/Data/Vector/Unboxed/Base.hs
@@ -1,4 +1,6 @@
 {-# LANGUAGE MultiParamTypeClasses, TypeFamilies, FlexibleContexts #-}
+{-# OPTIONS_HADDOCK hide #-}
+
 -- |
 -- Module      : Data.Vector.Unboxed.Base
 -- Copyright   : (c) Roman Leshchinskiy 2009-2010
diff --git a/benchmarks/vector-benchmarks.cabal b/benchmarks/vector-benchmarks.cabal
--- a/benchmarks/vector-benchmarks.cabal
+++ b/benchmarks/vector-benchmarks.cabal
@@ -1,5 +1,5 @@
 Name:           vector-benchmarks
-Version:        0.6
+Version:        0.6.0.1
 License:        BSD3
 License-File:   LICENSE
 Author:         Roman Leshchinskiy <rl@cse.unsw.edu.au>
@@ -14,7 +14,7 @@
   Build-Depends: base >= 2 && < 5, array,
                  criterion >= 0.5 && < 0.6,
                  mwc-random >= 0.5 && < 0.6,
-                 vector >= 0.6 && < 0.7
+                 vector == 0.6.0.1
 
   if impl(ghc<6.13)
     Ghc-Options: -finline-if-enough-args -fno-method-sharing
diff --git a/internal/GenUnboxTuple.hs b/internal/GenUnboxTuple.hs
--- a/internal/GenUnboxTuple.hs
+++ b/internal/GenUnboxTuple.hs
@@ -52,7 +52,8 @@
 
 
     define_zip ty c
-      = sep [name <+> text "::"
+      = sep [text "-- | /O(1)/ Zip" <+> int n <+> text "vectors"
+            ,name <+> text "::"
                   <+> vtuple [text "Unbox" <+> v | v <- vars]
                   <+> text "=>"
                   <+> sep (punctuate (text " ->") [text ty <+> v | v <- vars])
@@ -92,7 +93,8 @@
        
 
     define_unzip ty c
-      = sep [name <+> text "::"
+      = sep [text "-- | /O(1)/ Unzip" <+> int n <+> text "vectors"
+            ,name <+> text "::"
                   <+> vtuple [text "Unbox" <+> v | v <- vars]
                   <+> text "=>"
                   <+> text ty <+> tuple vars
diff --git a/internal/unbox-tuple-instances b/internal/unbox-tuple-instances
--- a/internal/unbox-tuple-instances
+++ b/internal/unbox-tuple-instances
@@ -91,17 +91,20 @@
         . G.elemseq (undefined :: Vector b) b
 #endif
 #ifdef DEFINE_MUTABLE
+-- | /O(1)/ Zip 2 vectors
 zip :: (Unbox a, Unbox b) => MVector s a ->
                              MVector s b -> MVector s (a, b)
 {-# INLINE_STREAM zip #-}
 zip as bs = MV_2 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs)
   where len = length as `min` length bs
+-- | /O(1)/ Unzip 2 vectors
 unzip :: (Unbox a, Unbox b) => MVector s (a, b) -> (MVector s a,
                                                     MVector s b)
 {-# INLINE unzip #-}
 unzip (MV_2 n_ as bs) = (as, bs)
 #endif
 #ifdef DEFINE_IMMUTABLE
+-- | /O(1)/ Zip 2 vectors
 zip :: (Unbox a, Unbox b) => Vector a -> Vector b -> Vector (a, b)
 {-# INLINE_STREAM zip #-}
 zip as bs = V_2 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs)
@@ -110,6 +113,7 @@
   G.stream (zip as bs) = Stream.zipWith (,) (G.stream as)
                                             (G.stream bs)
   #-}
+-- | /O(1)/ Unzip 2 vectors
 unzip :: (Unbox a, Unbox b) => Vector (a, b) -> (Vector a,
                                                  Vector b)
 {-# INLINE unzip #-}
@@ -229,6 +233,7 @@
         . G.elemseq (undefined :: Vector c) c
 #endif
 #ifdef DEFINE_MUTABLE
+-- | /O(1)/ Zip 3 vectors
 zip3 :: (Unbox a, Unbox b, Unbox c) => MVector s a ->
                                        MVector s b ->
                                        MVector s c -> MVector s (a, b, c)
@@ -237,6 +242,7 @@
                          (unsafeSlice 0 len bs)
                          (unsafeSlice 0 len cs)
   where len = length as `min` length bs `min` length cs
+-- | /O(1)/ Unzip 3 vectors
 unzip3 :: (Unbox a,
            Unbox b,
            Unbox c) => MVector s (a, b, c) -> (MVector s a,
@@ -246,6 +252,7 @@
 unzip3 (MV_3 n_ as bs cs) = (as, bs, cs)
 #endif
 #ifdef DEFINE_IMMUTABLE
+-- | /O(1)/ Zip 3 vectors
 zip3 :: (Unbox a, Unbox b, Unbox c) => Vector a ->
                                        Vector b ->
                                        Vector c -> Vector (a, b, c)
@@ -259,6 +266,7 @@
                                                    (G.stream bs)
                                                    (G.stream cs)
   #-}
+-- | /O(1)/ Unzip 3 vectors
 unzip3 :: (Unbox a,
            Unbox b,
            Unbox c) => Vector (a, b, c) -> (Vector a, Vector b, Vector c)
@@ -404,6 +412,7 @@
         . G.elemseq (undefined :: Vector d) d
 #endif
 #ifdef DEFINE_MUTABLE
+-- | /O(1)/ Zip 4 vectors
 zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => MVector s a ->
                                                 MVector s b ->
                                                 MVector s c ->
@@ -415,6 +424,7 @@
                             (unsafeSlice 0 len ds)
   where
     len = length as `min` length bs `min` length cs `min` length ds
+-- | /O(1)/ Unzip 4 vectors
 unzip4 :: (Unbox a,
            Unbox b,
            Unbox c,
@@ -426,6 +436,7 @@
 unzip4 (MV_4 n_ as bs cs ds) = (as, bs, cs, ds)
 #endif
 #ifdef DEFINE_IMMUTABLE
+-- | /O(1)/ Zip 4 vectors
 zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => Vector a ->
                                                 Vector b ->
                                                 Vector c ->
@@ -443,6 +454,7 @@
                                                         (G.stream cs)
                                                         (G.stream ds)
   #-}
+-- | /O(1)/ Unzip 4 vectors
 unzip4 :: (Unbox a,
            Unbox b,
            Unbox c,
@@ -621,6 +633,7 @@
         . G.elemseq (undefined :: Vector e) e
 #endif
 #ifdef DEFINE_MUTABLE
+-- | /O(1)/ Zip 5 vectors
 zip5 :: (Unbox a,
          Unbox b,
          Unbox c,
@@ -642,6 +655,7 @@
           length cs `min`
           length ds `min`
           length es
+-- | /O(1)/ Unzip 5 vectors
 unzip5 :: (Unbox a,
            Unbox b,
            Unbox c,
@@ -655,6 +669,7 @@
 unzip5 (MV_5 n_ as bs cs ds es) = (as, bs, cs, ds, es)
 #endif
 #ifdef DEFINE_IMMUTABLE
+-- | /O(1)/ Zip 5 vectors
 zip5 :: (Unbox a,
          Unbox b,
          Unbox c,
@@ -687,6 +702,7 @@
                                                  (G.stream ds)
                                                  (G.stream es)
   #-}
+-- | /O(1)/ Unzip 5 vectors
 unzip5 :: (Unbox a,
            Unbox b,
            Unbox c,
@@ -890,6 +906,7 @@
         . G.elemseq (undefined :: Vector f) f
 #endif
 #ifdef DEFINE_MUTABLE
+-- | /O(1)/ Zip 6 vectors
 zip6 :: (Unbox a,
          Unbox b,
          Unbox c,
@@ -915,6 +932,7 @@
           length ds `min`
           length es `min`
           length fs
+-- | /O(1)/ Unzip 6 vectors
 unzip6 :: (Unbox a,
            Unbox b,
            Unbox c,
@@ -930,6 +948,7 @@
 unzip6 (MV_6 n_ as bs cs ds es fs) = (as, bs, cs, ds, es, fs)
 #endif
 #ifdef DEFINE_IMMUTABLE
+-- | /O(1)/ Zip 6 vectors
 zip6 :: (Unbox a,
          Unbox b,
          Unbox c,
@@ -968,6 +987,7 @@
                                                    (G.stream es)
                                                    (G.stream fs)
   #-}
+-- | /O(1)/ Unzip 6 vectors
 unzip6 :: (Unbox a,
            Unbox b,
            Unbox c,
diff --git a/tests/vector-tests.cabal b/tests/vector-tests.cabal
--- a/tests/vector-tests.cabal
+++ b/tests/vector-tests.cabal
@@ -1,10 +1,10 @@
 Name:           vector-tests
-Version:        0.6
+Version:        0.6.0.1
 License:        BSD3
 License-File:   LICENSE
 Author:         Max Bolingbroke, Roman Leshchinskiy
 Maintainer:     Roman Leshchinskiy <rl@cse.unsw.edu.au>
-Copyright:      (c) Max Bolinbroke, Roman Leshchinskiy 2008-2009
+Copyright:      (c) Max Bolinbroke, Roman Leshchinskiy 2008-2010
 Homepage:       http://darcs.haskell.org/vector
 Category:       Data Structures
 Synopsis:       Efficient Arrays
@@ -27,7 +27,7 @@
               TypeFamilies,
               TemplateHaskell
 
-  Build-Depends: base >= 4 && < 5, template-haskell, vector >= 0.6 && < 0.7,
+  Build-Depends: base >= 4 && < 5, template-haskell, vector == 0.6.0.1,
                  random,
                  QuickCheck >= 2, test-framework, test-framework-quickcheck2
 
diff --git a/vector.cabal b/vector.cabal
--- a/vector.cabal
+++ b/vector.cabal
@@ -1,5 +1,5 @@
 Name:           vector
-Version:        0.6
+Version:        0.6.0.1
 License:        BSD3
 License-File:   LICENSE
 Author:         Roman Leshchinskiy <rl@cse.unsw.edu.au>
@@ -38,6 +38,10 @@
         .
         * <http://trac.haskell.org/vector>
         .
+        Changes since version 0.6
+        .
+        * Improved documentation
+        .
         Changes since version 0.5
         .
         * More efficient representation of @Storable@ vectors
@@ -82,6 +86,7 @@
       benchmarks/TestData/Random.hs
       internal/GenUnboxTuple.hs
       internal/unbox-tuple-instances
+      Changelog
 
 Flag BoundsChecks
   Description: Enable bounds checking