Tie New to a particular vector type
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Sat, 17 Apr 2010 06:37:27 +0000 (06:37 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Sat, 17 Apr 2010 06:37:27 +0000 (06:37 +0000)
We now have (New v a) which can only be used to create vectors of type (v a)
where before, (New a) could be used to create arbitrary vectors. This allows
the initialiser in New to include operations which only work for a particular
implementation of Vector. This will be quite useful in the future, I'm sure.

Data/Vector/Generic.hs
Data/Vector/Generic/Base.hs [new file with mode: 0644]
Data/Vector/Generic/New.hs
vector.cabal

index 5789560..2339da2 100644 (file)
@@ -95,6 +95,8 @@ module Data.Vector.Generic (
   gfoldl, dataCast, mkType
 ) where
 
   gfoldl, dataCast, mkType
 ) where
 
+import           Data.Vector.Generic.Base
+
 import           Data.Vector.Generic.Mutable ( MVector )
 import qualified Data.Vector.Generic.Mutable as M
 
 import           Data.Vector.Generic.Mutable ( MVector )
 import qualified Data.Vector.Generic.Mutable as M
 
@@ -127,80 +129,13 @@ import Data.Data ( Data, DataType, mkNorepType )
 
 #include "vector.h"
 
 
 #include "vector.h"
 
-type family Mutable (v :: * -> *) :: * -> * -> *
-
--- | Class of immutable vectors.
---
-class MVector (Mutable v) a => Vector v a where
-  -- | 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!)
-  basicLength      :: v a -> Int
-
-  -- | Yield a part of the vector without copying it. No range checks!
-  basicUnsafeSlice  :: Int -> Int -> 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
-  --
-  -- > unsafeIndex :: v a -> Int -> a
-  --
-  -- instead. Now, if we wanted to copy a vector, we'd do something like
-  --
-  -- > copy mv v ... = ... unsafeWrite mv i (unsafeIndex v i) ...
-  --
-  -- For lazy vectors, the indexing would not be evaluated which means that we
-  -- would retain a reference to the original vector in each element we write.
-  -- This is not what we want!
-  --
-  -- With 'basicUnsafeIndexM', we can do
-  --
-  -- > copy mv v ... = ... case basicUnsafeIndexM v i of
-  -- >                       Box x -> unsafeWrite mv i x ...
-  --
-  -- which does not have this problem because indexing (but not the returned
-  -- element!) is evaluated immediately.
-  --
-  basicUnsafeIndexM  :: Monad m => v a -> Int -> m a
-
-  -- | Copy an immutable vector into a mutable one.
-  basicUnsafeCopy :: PrimMonad m => Mutable v (PrimState m) a -> v a -> m ()
-
-  basicUnsafeCopy dst src = do_copy 0
-    where
-      n = basicLength src
-
-      do_copy i | i < n = do
-                            x <- basicUnsafeIndexM src i
-                            M.basicUnsafeWrite dst i x
-                            do_copy (i+1)
-                | otherwise = return ()
-
-  elemseq :: v a -> a -> b -> b
-
-  {-# INLINE elemseq #-}
-  elemseq _ = \_ x -> x
-
 -- Fusion
 -- ------
 
 -- | Construct a pure vector from a monadic initialiser 
 -- Fusion
 -- ------
 
 -- | Construct a pure vector from a monadic initialiser 
-new :: Vector v a => New a -> v a
-{-# INLINE new #-}
-new m = new' undefined m
-
--- | Same as 'new' but with a dummy argument necessary for correctly typing
--- the rule @uninplace@.
---
--- See http://hackage.haskell.org/trac/ghc/ticket/2600
-new' :: Vector v a => v a -> New a -> v a
-{-# INLINE_STREAM new' #-}
-new' _ m = m `seq` runST (do
-                            mv <- New.run m
-                            unsafeFreeze mv)
+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 a 'Stream'
 stream :: Vector v a => v a -> Stream a
 
 -- | Convert a vector to a 'Stream'
 stream :: Vector v a => v a -> Stream a
@@ -222,23 +157,23 @@ unstream s = new (New.unstream s)
 
 {-# RULES
 
 
 {-# RULES
 
-"stream/unstream [Vector]" forall s.
-  stream (new' v (New.unstream s)) = s
+"stream/unstream [Vector]" forall s.
+  stream (new (New.unstream s)) = s
 
 
-"New.unstream/stream/new [Vector]" forall p.
-  New.unstream (stream (new' v p)) = p
+"New.unstream/stream/new [Vector]" forall p.
+  New.unstream (stream (new p)) = p
 
  #-}
 
 {-# RULES
 
 "inplace [Vector]"
 
  #-}
 
 {-# RULES
 
 "inplace [Vector]"
-  forall (f :: forall m. Monad m => MStream m a -> MStream m a) m.
-  New.unstream (inplace f (stream (new' v m))) = New.transform f m
+  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]"
 
 "uninplace [Vector]"
-  forall (f :: forall m. Monad m => MStream m a -> MStream m a) m.
-  stream (new' v (New.transform f m)) = inplace f (stream (new' v m))
+  forall (f :: forall m. Monad m => MStream m a -> MStream m a) m.
+  stream (new (New.transform f m)) = inplace f (stream (new m))
 
  #-}
 
 
  #-}
 
@@ -262,23 +197,23 @@ unstreamR s = new (New.unstreamR s)
 
 {-# RULES
 
 
 {-# RULES
 
-"streamR/unstreamR [Vector]" forall s.
-  streamR (new' v (New.unstreamR s)) = s
+"streamR/unstreamR [Vector]" forall s.
+  streamR (new (New.unstreamR s)) = s
 
 
-"New.unstreamR/streamR/new [Vector]" forall p.
-  New.unstreamR (streamR (new' v p)) = p
+"New.unstreamR/streamR/new [Vector]" forall p.
+  New.unstreamR (streamR (new p)) = p
 
  #-}
 
 {-# RULES
 
 "inplace [Vector]"
 
  #-}
 
 {-# RULES
 
 "inplace [Vector]"
-  forall (f :: forall m. Monad m => MStream m a -> MStream m a) m.
-  New.unstreamR (inplace f (streamR (new' v m))) = New.transformR f m
+  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 [Vector]"
 
 "uninplace [Vector]"
-  forall (f :: forall m. Monad m => MStream m a -> MStream m a) m.
-  streamR (new' v (New.transformR f m)) = inplace f (streamR (new' v m))
+  forall (f :: forall m. Monad m => MStream m a -> MStream m a) m.
+  streamR (new (New.transformR f m)) = inplace f (streamR (new m))
 
  #-}
 
 
  #-}
 
@@ -313,8 +248,8 @@ modify p v = runST (
 {-# RULES
 
 "modify/new [Vector]"
 {-# RULES
 
 "modify/new [Vector]"
-    forall (f :: forall mv s. MVector mv a => mv s a -> ST s ())  v m.
-  modify f (new' v m) = new' v (New.modify f m)
+    forall (f :: forall mv s. MVector mv a => mv s a -> ST s ()) m.
+  modify f (new m) = new (New.modify f m)
 
  #-}
 
 
  #-}
 
@@ -327,8 +262,8 @@ length v = basicLength v
 
 {-# RULES
 
 
 {-# RULES
 
-"length/unstream [Vector]" forall s.
-  length (new' v (New.unstream s)) = Stream.length s
+"length/unstream [Vector]" forall s.
+  length (new (New.unstream s)) = Stream.length s
 
   #-}
 
 
   #-}
 
@@ -338,8 +273,8 @@ null v = basicLength v == 0
 
 {-# RULES
 
 
 {-# RULES
 
-"null/unstream [Vector]" forall s.
-  null (new' v (New.unstream s)) = Stream.null s
+"null/unstream [Vector]" forall s.
+  null (new (New.unstream s)) = Stream.null s
 
   #-}
 
 
   #-}
 
@@ -398,8 +333,8 @@ force = unstream . stream
 
 {-# RULES
 
 
 {-# RULES
 
-"force/unstream [Vector]" forall s.
-  force (new' v (New.unstream s)) = new' v (New.unstream s)
+"force/unstream [Vector]" forall s.
+  force (new (New.unstream s)) = new (New.unstream s)
 
  #-}
 
 
  #-}
 
@@ -442,23 +377,23 @@ unsafeLast v = unsafeIndex v (length v - 1)
 
 {-# RULES
 
 
 {-# RULES
 
-"(!)/unstream [Vector]" forall i s.
-  new' v (New.unstream s) ! i = s Stream.!! i
+"(!)/unstream [Vector]" forall i s.
+  new (New.unstream s) ! i = s Stream.!! i
 
 
-"head/unstream [Vector]" forall s.
-  head (new' v (New.unstream s)) = Stream.head s
+"head/unstream [Vector]" forall s.
+  head (new (New.unstream s)) = Stream.head s
 
 
-"last/unstream [Vector]" forall s.
-  last (new' v (New.unstream s)) = Stream.last s
+"last/unstream [Vector]" forall s.
+  last (new (New.unstream s)) = Stream.last s
 
 
-"unsafeIndex/unstream [Vector]" forall i s.
-  unsafeIndex (new' v (New.unstream s)) i = s Stream.!! i
+"unsafeIndex/unstream [Vector]" forall i s.
+  unsafeIndex (new (New.unstream s)) i = s Stream.!! i
 
 
-"unsafeHead/unstream [Vector]" forall s.
-  unsafeHead (new' v (New.unstream s)) = Stream.head s
+"unsafeHead/unstream [Vector]" forall s.
+  unsafeHead (new (New.unstream s)) = Stream.head s
 
 
-"unsafeLast/unstream [Vector]" forall s.
-  unsafeLast (new' v (New.unstream s)) = Stream.last s
+"unsafeLast/unstream [Vector]" forall s.
+  unsafeLast (new (New.unstream s)) = Stream.last s
 
  #-}
 
 
  #-}
 
@@ -571,29 +506,29 @@ unsafeDrop n v = unsafeSlice n (length v - n) v
 
 {-# RULES
 
 
 {-# RULES
 
-"slice/new [Vector]" forall i n p.
-  slice i n (new' v p) = new' v (New.slice i n p)
+"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' v p) = new' v (New.init p)
+"init/new [Vector]" forall p.
+  init (new p) = new (New.init p)
 
 
-"tail/new [Vector]" forall p.
-  tail (new' v p) = new' v (New.tail p)
+"tail/new [Vector]" forall p.
+  tail (new p) = new (New.tail p)
 
 
-"take/new [Vector]" forall n p.
-  take n (new' v p) = new' v (New.take n 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' v p) = new' v (New.drop 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' v p) = new' v (New.unsafeSlice i 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' v p) = new' v (New.unsafeInit p)
+"unsafeInit/new [Vector]" forall p.
+  unsafeInit (new p) = new (New.unsafeInit p)
 
 
-"unsafeTail/new [Vector]" forall p.
-  unsafeTail (new' v p) = new' v (New.unsafeTail p)
+"unsafeTail/new [Vector]" forall p.
+  unsafeTail (new p) = new (New.unsafeTail p)
 
   #-}
 
 
   #-}
 
@@ -962,7 +897,7 @@ unstablePartition_stream f s = s `seq` runST (
     v2 <- unsafeFreeze mv2
     return (v1,v2))
 
     v2 <- unsafeFreeze mv2
     return (v1,v2))
 
-unstablePartition_new :: Vector v a => (a -> Bool) -> New a -> (v a, v a)
+unstablePartition_new :: Vector v a => (a -> Bool) -> New a -> (v a, v a)
 {-# INLINE_STREAM unstablePartition_new #-}
 unstablePartition_new f (New.New p) = runST (
   do
 {-# INLINE_STREAM unstablePartition_new #-}
 unstablePartition_new f (New.New p) = runST (
   do
@@ -973,8 +908,8 @@ unstablePartition_new f (New.New p) = runST (
 
 {-# RULES
 
 
 {-# RULES
 
-"unstablePartition" forall f p.
-  unstablePartition_stream f (stream (new' v p))
+"unstablePartition" forall f p.
+  unstablePartition_stream f (stream (new p))
     = unstablePartition_new f p
 
   #-}
     = unstablePartition_new f p
 
   #-}
diff --git a/Data/Vector/Generic/Base.hs b/Data/Vector/Generic/Base.hs
new file mode 100644 (file)
index 0000000..7ffbacc
--- /dev/null
@@ -0,0 +1,86 @@
+{-# LANGUAGE Rank2Types, MultiParamTypeClasses, FlexibleContexts,
+             TypeFamilies, ScopedTypeVariables #-}
+
+-- |
+-- Module      : Data.Vector.Generic.Base
+-- Copyright   : (c) Roman Leshchinskiy 2008-2010
+-- License     : BSD-style
+--
+-- Maintainer  : Roman Leshchinskiy <rl@cse.unsw.edu.au>
+-- Stability   : experimental
+-- Portability : non-portable
+-- 
+-- Class of pure vectors
+--
+
+module Data.Vector.Generic.Base (
+  Vector(..), Mutable
+) where
+
+import           Data.Vector.Generic.Mutable ( MVector )
+import qualified Data.Vector.Generic.Mutable as M
+
+import Control.Monad.Primitive
+
+-- | @Mutable v s a@ is the mutable version of the pure vector type @v a@ with
+-- the state token @s@
+--
+type family Mutable (v :: * -> *) :: * -> * -> *
+
+-- | Class of immutable vectors.
+--
+class MVector (Mutable v) a => Vector v a where
+  -- | 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!)
+  basicLength      :: v a -> Int
+
+  -- | Yield a part of the vector without copying it. No range checks!
+  basicUnsafeSlice  :: Int -> Int -> 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
+  --
+  -- > unsafeIndex :: v a -> Int -> a
+  --
+  -- instead. Now, if we wanted to copy a vector, we'd do something like
+  --
+  -- > copy mv v ... = ... unsafeWrite mv i (unsafeIndex v i) ...
+  --
+  -- For lazy vectors, the indexing would not be evaluated which means that we
+  -- would retain a reference to the original vector in each element we write.
+  -- This is not what we want!
+  --
+  -- With 'basicUnsafeIndexM', we can do
+  --
+  -- > copy mv v ... = ... case basicUnsafeIndexM v i of
+  -- >                       Box x -> unsafeWrite mv i x ...
+  --
+  -- which does not have this problem because indexing (but not the returned
+  -- element!) is evaluated immediately.
+  --
+  basicUnsafeIndexM  :: Monad m => v a -> Int -> m a
+
+  -- | Copy an immutable vector into a mutable one.
+  basicUnsafeCopy :: PrimMonad m => Mutable v (PrimState m) a -> v a -> m ()
+
+  {-# INLINE basicUnsafeCopy #-}
+  basicUnsafeCopy dst src = do_copy 0
+    where
+      n = basicLength src
+
+      do_copy i | i < n = do
+                            x <- basicUnsafeIndexM src i
+                            M.basicUnsafeWrite dst i x
+                            do_copy (i+1)
+                | otherwise = return ()
+
+  elemseq :: v a -> a -> b -> b
+
+  {-# INLINE elemseq #-}
+  elemseq _ = \_ x -> x
+
+
index 6729aeb..400b913 100644 (file)
@@ -23,6 +23,8 @@ module Data.Vector.Generic.New (
 import qualified Data.Vector.Generic.Mutable as MVector
 import           Data.Vector.Generic.Mutable ( MVector )
 
 import qualified Data.Vector.Generic.Mutable as MVector
 import           Data.Vector.Generic.Mutable ( MVector )
 
+import          Data.Vector.Generic.Base ( Vector, Mutable )
+
 import           Data.Vector.Fusion.Stream ( Stream, MStream )
 import qualified Data.Vector.Fusion.Stream as Stream
 
 import           Data.Vector.Fusion.Stream ( Stream, MStream )
 import qualified Data.Vector.Fusion.Stream as Stream
 
@@ -32,25 +34,26 @@ import Prelude hiding ( init, tail, take, drop, reverse, map, filter )
 
 #include "vector.h"
 
 
 #include "vector.h"
 
-data New a = New (forall mv s. MVector mv a => ST s (mv s a))
+data New v a = New (forall s. ST s (Mutable v s a))
 
 
-run :: MVector mv a => New a -> ST s (mv s a)
+run :: New v a -> ST s (Mutable v s a)
 {-# INLINE run #-}
 run (New p) = p
 
 {-# INLINE run #-}
 run (New p) = p
 
-apply :: (forall mv s a. MVector mv a => mv s a -> mv s a) -> New a -> New a
+apply :: (forall s. Mutable v s a -> Mutable v s a) -> New v a -> New v a
 {-# INLINE apply #-}
 apply f (New p) = New (liftM f p)
 
 {-# INLINE apply #-}
 apply f (New p) = New (liftM f p)
 
-modify :: (forall mv s. MVector mv a => mv s a -> ST s ()) -> New a -> New a
+modify :: (forall s. Mutable v s a -> ST s ()) -> New v a -> New v a
 {-# INLINE modify #-}
 modify f (New p) = New (do { v <- p; f v; return v })
 
 {-# INLINE modify #-}
 modify f (New p) = New (do { v <- p; f v; return v })
 
-unstream :: Stream a -> New a
+unstream :: Vector v a => Stream a -> New v a
 {-# INLINE_STREAM unstream #-}
 unstream s = s `seq` New (MVector.unstream s)
 
 {-# INLINE_STREAM unstream #-}
 unstream s = s `seq` New (MVector.unstream s)
 
-transform :: (forall m. Monad m => MStream m a -> MStream m a) -> New a -> New a
+transform :: Vector v a =>
+        (forall m. Monad m => MStream m a -> MStream m a) -> New v a -> New v a
 {-# INLINE_STREAM transform #-}
 transform f (New p) = New (MVector.transform f =<< p)
 
 {-# INLINE_STREAM transform #-}
 transform f (New p) = New (MVector.transform f =<< p)
 
@@ -70,11 +73,12 @@ transform f (New p) = New (MVector.transform f =<< p)
  #-}
 
 
  #-}
 
 
-unstreamR :: Stream a -> New a
+unstreamR :: Vector v a => Stream a -> New v a
 {-# INLINE_STREAM unstreamR #-}
 unstreamR s = s `seq` New (MVector.unstreamR s)
 
 {-# INLINE_STREAM unstreamR #-}
 unstreamR s = s `seq` New (MVector.unstreamR s)
 
-transformR :: (forall m. Monad m => MStream m a -> MStream m a) -> New a -> New a
+transformR :: Vector v a =>
+        (forall m. Monad m => MStream m a -> MStream m a) -> New v a -> New v a
 {-# INLINE_STREAM transformR #-}
 transformR f (New p) = New (MVector.transformR f =<< p)
 
 {-# INLINE_STREAM transformR #-}
 transformR f (New p) = New (MVector.transformR f =<< p)
 
@@ -93,35 +97,35 @@ transformR f (New p) = New (MVector.transformR f =<< p)
 
  #-}
 
 
  #-}
 
-slice :: Int -> Int -> New a -> New a
+slice :: Vector v a => Int -> Int -> New v a -> New v a
 {-# INLINE_STREAM slice #-}
 slice i n m = apply (MVector.slice i n) m
 
 {-# INLINE_STREAM slice #-}
 slice i n m = apply (MVector.slice i n) m
 
-init :: New a -> New a
+init :: Vector v a => New v a -> New v a
 {-# INLINE_STREAM init #-}
 init m = apply MVector.init m
 
 {-# INLINE_STREAM init #-}
 init m = apply MVector.init m
 
-tail :: New a -> New a
+tail :: Vector v a => New v a -> New v a
 {-# INLINE_STREAM tail #-}
 tail m = apply MVector.tail m
 
 {-# INLINE_STREAM tail #-}
 tail m = apply MVector.tail m
 
-take :: Int -> New a -> New a
+take :: Vector v a => Int -> New v a -> New v a
 {-# INLINE_STREAM take #-}
 take n m = apply (MVector.take n) m
 
 {-# INLINE_STREAM take #-}
 take n m = apply (MVector.take n) m
 
-drop :: Int -> New a -> New a
+drop :: Vector v a => Int -> New v a -> New v a
 {-# INLINE_STREAM drop #-}
 drop n m = apply (MVector.drop n) m
 
 {-# INLINE_STREAM drop #-}
 drop n m = apply (MVector.drop n) m
 
-unsafeSlice :: Int -> Int -> New a -> New a
+unsafeSlice :: Vector v a => Int -> Int -> New v a -> New v a
 {-# INLINE_STREAM unsafeSlice #-}
 unsafeSlice i n m = apply (MVector.unsafeSlice i n) m
 
 {-# INLINE_STREAM unsafeSlice #-}
 unsafeSlice i n m = apply (MVector.unsafeSlice i n) m
 
-unsafeInit :: New a -> New a
+unsafeInit :: Vector v a => New v a -> New v a
 {-# INLINE_STREAM unsafeInit #-}
 unsafeInit m = apply MVector.unsafeInit m
 
 {-# INLINE_STREAM unsafeInit #-}
 unsafeInit m = apply MVector.unsafeInit m
 
-unsafeTail :: New a -> New a
+unsafeTail :: Vector v a => New v a -> New v a
 {-# INLINE_STREAM unsafeTail #-}
 unsafeTail m = apply MVector.unsafeTail m
 
 {-# INLINE_STREAM unsafeTail #-}
 unsafeTail m = apply MVector.unsafeTail m
 
@@ -153,23 +157,24 @@ unsafeTail m = apply MVector.unsafeTail m
 
   #-}
 
 
   #-}
 
-unsafeAccum :: (a -> b -> a) -> New a -> Stream (Int, b) -> New a
+unsafeAccum
+        :: Vector v a => (a -> b -> a) -> New v a -> Stream (Int, b) -> New v a
 {-# INLINE_STREAM unsafeAccum #-}
 unsafeAccum f m s = s `seq` modify (\v -> MVector.unsafeAccum f v s) m
 
 {-# INLINE_STREAM unsafeAccum #-}
 unsafeAccum f m s = s `seq` modify (\v -> MVector.unsafeAccum f v s) m
 
-accum :: (a -> b -> a) -> New a -> Stream (Int, b) -> New a
+accum :: Vector v a => (a -> b -> a) -> New v a -> Stream (Int, b) -> New v a
 {-# INLINE_STREAM accum #-}
 accum f m s = s `seq` modify (\v -> MVector.accum f v s) m
 
 {-# INLINE_STREAM accum #-}
 accum f m s = s `seq` modify (\v -> MVector.accum f v s) m
 
-unsafeUpdate :: New a -> Stream (Int, a) -> New a
+unsafeUpdate :: Vector v a => New v a -> Stream (Int, a) -> New v a
 {-# INLINE_STREAM unsafeUpdate #-}
 unsafeUpdate m s = s `seq` modify (\v -> MVector.unsafeUpdate v s) m
 
 {-# INLINE_STREAM unsafeUpdate #-}
 unsafeUpdate m s = s `seq` modify (\v -> MVector.unsafeUpdate v s) m
 
-update :: New a -> Stream (Int, a) -> New a
+update :: Vector v a => New v a -> Stream (Int, a) -> New v a
 {-# INLINE_STREAM update #-}
 update m s = s `seq` modify (\v -> MVector.update v s) m
 
 {-# INLINE_STREAM update #-}
 update m s = s `seq` modify (\v -> MVector.update v s) m
 
-reverse :: New a -> New a
+reverse :: Vector v a => New v a -> New v a
 {-# INLINE_STREAM reverse #-}
 reverse m = modify (MVector.reverse) m
 
 {-# INLINE_STREAM reverse #-}
 reverse m = modify (MVector.reverse) m
 
index 3b4eeb8..eaa30b2 100644 (file)
@@ -91,6 +91,7 @@ Library
         Data.Vector.Fusion.Stream
 
         Data.Vector.Generic.Mutable
         Data.Vector.Fusion.Stream
 
         Data.Vector.Generic.Mutable
+        Data.Vector.Generic.Base
         Data.Vector.Generic.New
         Data.Vector.Generic
 
         Data.Vector.Generic.New
         Data.Vector.Generic