diff --git a/pipes-vector.cabal b/pipes-vector.cabal
--- a/pipes-vector.cabal
+++ b/pipes-vector.cabal
@@ -1,12 +1,12 @@
 name:                pipes-vector
-version:             0.5.3
+version:             0.6
 synopsis:            Various proxies for streaming data into vectors
 description:         Proxies for streaming data into vectors.        
 license:             BSD3
 license-file:        LICENSE
 author:              Ben Gamari
 maintainer:          Ben Gamari <bgamari.foss@gmail.com>
--- copyright:           
+copyright:           (c) 2015 Ben Gamari
 category:            Control
 build-type:          Simple
 cabal-version:       >=1.10
@@ -16,10 +16,10 @@
   exposed-modules:     Pipes.Vector
   build-depends:       base >=3.0 && <5,
                        transformers >= 0.2 && < 1.0,
-                       primitive >=0.4 && <1.0,
+                       primitive >=0.6 && <0.7,
                        pipes >=4.0 && <5.0,
                        vector >=0.9 && <1.0,
-                       monad-primitive >= 0.1 && < 1.0
+                       monad-primitive >= 0.1 && < 0.2
   default-language:    Haskell2010
   other-extensions:    RankNTypes, FlexibleContexts, GeneralizedNewtypeDeriving, TypeFamilies
 
diff --git a/src/Pipes/Vector.hs b/src/Pipes/Vector.hs
--- a/src/Pipes/Vector.hs
+++ b/src/Pipes/Vector.hs
@@ -22,14 +22,14 @@
 import Control.Monad
 import Control.Monad.Trans.State.Strict as S
 import Control.Monad.Primitive
-import Control.Monad.Primitive.Class
+import qualified Control.Monad.Primitive.Class as MP
 import Pipes
 import Pipes.Internal (unsafeHoist)
 import Pipes.Lift
 import qualified Data.Vector.Generic as V
 import qualified Data.Vector.Generic.Mutable as M
 
-data ToVectorState v e m = ToVecS { result :: V.Mutable v (PrimState (BasePrimMonad m)) e
+data ToVectorState v e m = ToVecS { result :: V.Mutable v (PrimState m) e
                                   , idx :: Int
                                   }
 
@@ -39,14 +39,23 @@
 instance MonadTrans (ToVector v e) where
     lift = TV . lift
 
+instance PrimMonad m => PrimMonad (ToVector v e m) where
+    type PrimState (ToVector v e m) = PrimState m
+    primitive = lift . primitive
+
 -- Nasty orphan instances
-instance MonadPrim m => MonadPrim (Proxy a' a b' b m) where
-    type BasePrimMonad (Proxy a' a b' b m) = BasePrimMonad m
-    liftPrim = lift . liftPrim
+instance PrimMonad m => PrimMonad (Proxy a' a b' b m) where
+    type PrimState (Proxy a' a b' b m) = PrimState m
+    primitive = lift .  primitive
+
+-- monad-primitive instances (TODO: remove these)
+instance MP.MonadPrim m => MP.MonadPrim (Proxy a' a b' b m) where
+    type BasePrimMonad (Proxy a' a b' b m) = MP.BasePrimMonad m
+    liftPrim = lift . MP.liftPrim
   
-instance MonadPrim m => MonadPrim (ToVector v e m) where
-    type BasePrimMonad (ToVector v e m) = BasePrimMonad m
-    liftPrim = TV . liftPrim
+instance MP.MonadPrim m => MP.MonadPrim (ToVector v e m) where
+    type BasePrimMonad (ToVector v e m) = MP.BasePrimMonad m
+    liftPrim = TV . MP.liftPrim
                          
 maxChunkSize :: Int
 maxChunkSize = 8*1024*1024
@@ -56,38 +65,38 @@
 -- For efficient filling, the vector is grown geometrically up to a
 -- maximum chunk size.
 toVector
-     :: (MonadPrim m, M.MVector (V.Mutable v) e)
+     :: (PrimMonad m, M.MVector (V.Mutable v) e)
      => Consumer e (ToVector v e m) r
 toVector = forever $ do
       length <- M.length . result <$> lift (TV get)
-      pos <- idx `liftM` lift (TV get)
+      pos <- idx <$> lift (TV get)
       lift $ TV $ when (pos >= length) $ do
-          v <- result `liftM` get
-          v' <- liftPrim $ M.unsafeGrow v (min length maxChunkSize)
+          v <- result <$> get
+          v' <- M.unsafeGrow v (min length maxChunkSize)
           modify $ \(ToVecS r i) -> ToVecS v' i
       r <- await
       lift $ TV $ do
-          v <- result `liftM` get
-          liftPrim $ M.unsafeWrite v pos r
+          v <- result <$> get
+          M.unsafeWrite v pos r
           modify $ \(ToVecS r i) -> ToVecS r (pos+1)
 
 -- | Extract and freeze the constructed vector
 runToVectorP
-     :: (MonadPrim m, V.Vector v e)
+     :: (PrimMonad m, V.Vector v e)
      => Proxy a' a b' b (ToVector v e m) r
      -> Proxy a' a b' b m (v e)
 runToVectorP x = do
-     v <- liftPrim $ M.new 10
+     v <- M.new 10
      s <- execStateP (ToVecS v 0) (hoist unTV x)
-     frozen <- liftPrim $ V.freeze (result s)
+     frozen <- V.freeze (result s)
      return $ V.take (idx s) frozen
 
-runToVector :: (MonadPrim m, V.Vector v e)
+runToVector :: (PrimMonad m, V.Vector v e)
             => ToVector v e m r -> m (v e)
 runToVector (TV a) = do
-     v <- liftPrim $ M.new 10
+     v <- M.new 10
      s <- execStateT a (ToVecS v 0)
-     frozen <- liftPrim $ V.freeze (result s)
+     frozen <- V.freeze (result s)
      return $ V.take (idx s) frozen
 
 {- $usage
@@ -97,6 +106,6 @@
 
 -}
 
-fromProducer :: (V.Vector v e, MonadPrim m) => Producer e (ToVector v e m) r -> m (v e)
+fromProducer :: (V.Vector v e, PrimMonad m) => Producer e (ToVector v e m) r -> m (v e)
 fromProducer p = runEffect $ runToVectorP (p >-> toVector)