diff --git a/Data/Conduit/Vector.hs b/Data/Conduit/Vector.hs
new file mode 100644
--- /dev/null
+++ b/Data/Conduit/Vector.hs
@@ -0,0 +1,113 @@
+module Data.Conduit.Vector
+    (
+    sourceVector,
+    sourceMVector,
+    consumeVector,
+    consumeMVector,
+    takeVector,
+    takeMVector,
+    thawConduit,
+    freezeConduit
+    )
+where
+
+import Control.Monad.Primitive
+import Control.Monad.ST.Safe
+import Control.Monad.Trans.Class
+import Data.Conduit
+import qualified Data.Conduit.List as L
+import qualified Data.Vector.Generic as V
+import qualified Data.Vector.Generic.Mutable as M
+
+-- | Use an immutable vector as a source.
+sourceVector :: (Monad m, V.Vector v a) => v a -> Source m a
+sourceVector v = sourceState 0 f
+    where f index | index == V.length v = return StateClosed
+                  | otherwise = return $ StateOpen (index + 1) (v V.! index)
+
+-- | Use a mutable vector as a source in the ST or IO monad.
+sourceMVector :: (PrimMonad m, M.MVector v a)
+                 => v (PrimState m) a
+                 -> Source m a
+sourceMVector v = sourceState 0 f
+    where f index | index == M.length v = return StateClosed
+                  | otherwise = do x <- M.read v index
+                                   return $ StateOpen (index + 1) x
+
+-- | Consumes all values from the stream and return as an immutable vector.
+-- Due to the way it operates, it requires the ST monad at the minimum,
+-- although it can also operate IO. This is due to its dependency on
+-- a mutable vector.
+consumeVector :: (PrimMonad m, V.Vector v a)
+                 => Sink a m (v a)
+consumeVector = sinkState (Nothing, 0) push close
+    where push (v, index) x = do v' <- case v of
+                                        Nothing -> M.new 10
+                                        Just vec -> return vec
+                                 let len = M.length v'
+                                 v'' <- if index >= len
+                                            then M.grow v' len
+                                            else return v'
+                                 M.write v'' index x
+                                 return $ StateProcessing (Just v'', index + 1)
+          close (Nothing, index) = return $ V.fromList []
+          close (Just v, index) = V.unsafeFreeze $ M.take index v
+
+-- | Consumes the first n values from a source and returns as an immutable
+-- vector.
+takeVector :: (PrimMonad m, V.Vector v a)
+              => Int -> Sink a m (v a)
+takeVector n = sinkState (Nothing, 0) push close
+    where push (v, index) x = do
+            v' <- case v of
+                    Nothing -> M.new n
+                    Just vec -> return vec
+            if index >= n
+                then do v'' <- V.unsafeFreeze v'
+                        return $ StateDone Nothing v''
+                else do M.write v' index x
+                        return $ StateProcessing (Just v', index + 1)
+          close (Nothing, index) = return $ V.fromList []
+          close (Just v, index) = V.unsafeFreeze v
+
+-- | Consumes all values from the stream and returns as a mutable vector.
+consumeMVector :: (PrimMonad m, M.MVector v a)
+                  => Sink a m (v (PrimState m) a)
+consumeMVector = sinkState (Nothing, 0) push close
+    where push (v, index) x = do v' <- case v of
+                                        Nothing -> M.new 10
+                                        Just vec -> return vec
+                                 let len = M.length v'
+                                 v'' <- if index >= len
+                                            then M.grow v' len
+                                            else return v'
+                                 M.write v'' index x
+                                 return $ StateProcessing (Just v'', index + 1)
+          close (Nothing, index) = M.new 0
+          close (Just v, index) = return $ M.take index v
+
+-- | Consumes the first n values from the stream and returns as a
+-- mutable vector.
+takeMVector :: (PrimMonad m, M.MVector v a)
+               => Int -> Sink a m (v (PrimState m) a)
+takeMVector n = sinkState (Nothing, 0) push close
+    where push (v, index) x =
+            do v' <- case v of
+                        Nothing -> M.new n
+                        Just vec -> return vec
+               if index >= n
+                    then return $ StateDone Nothing v'
+                    else do M.write v' index x
+                            return $ StateProcessing (Just v', index + 1)
+          close (Nothing, index) = M.new 0
+          close (Just v, index) = return v
+
+-- | Conduit which thaws immutable vectors into mutable vectors
+thawConduit :: (PrimMonad m, V.Vector v a)
+                => Conduit (v a) m (V.Mutable v (PrimState m) a)
+thawConduit = L.mapM V.unsafeThaw
+
+-- | Conduit which freezes mutable vectors into immutable vectors
+freezeConduit :: (PrimMonad m, V.Vector v a)
+                 => Conduit (V.Mutable v (PrimState m) a) m (v a)
+freezeConduit = L.mapM V.unsafeFreeze
diff --git a/Data/Vector/Conduit.hs b/Data/Vector/Conduit.hs
deleted file mode 100644
--- a/Data/Vector/Conduit.hs
+++ /dev/null
@@ -1,111 +0,0 @@
-{-# LANGUAGE Rank2Types, ImpredicativeTypes, FlexibleContexts #-}
-module Data.Vector.Conduit
-    (
-    sourceVector,
-    sourceMVector,
-    consumeVector,
-    consumeVectorN,
-    consumeMVector,
-    consumeMVectorN,
-    thawConduit,
-    freezeConduit
-    )
-where
-
-import Control.Monad.Primitive
-import Control.Monad.ST.Safe
-import Control.Monad.Trans.Class
-import Data.Conduit
-import qualified Data.Conduit.List as L
-import qualified Data.Vector.Generic as V
-import qualified Data.Vector.Generic.Mutable as M
-
--- | Use an immutable vector as a source.
-sourceVector :: (Resource m, V.Vector v a) => v a -> Source m a
-sourceVector v = sourceState 0 f
-    where f index | index == V.length v = return StateClosed
-                  | otherwise = return $ StateOpen (index + 1) (v V.! index)
-
--- | Use a mutable vector as a source in the ST or IO monad.
-sourceMVector :: (PrimMonad m, Resource m, M.MVector v a)
-                 => v (PrimState m) a
-                 -> Source m a
-sourceMVector v = sourceState 0 f
-    where f index | index == M.length v = return StateClosed
-                  | otherwise = do x <- lift $ M.read v index
-                                   return $ StateOpen (index + 1) x
-
--- | Consumes all values from the stream and return as an immutable vector.
-consumeVector :: (PrimMonad m, Resource m, V.Vector v a)
-                 => Sink a m (v a)
-consumeVector = sinkState (Nothing, 0) push close
-    where push (v, index) x = do v' <- case v of
-                                        Nothing -> lift $ M.new 10
-                                        Just vec -> return vec
-                                 let len = M.length v'
-                                 v'' <- if index >= len
-                                            then lift $ M.grow v' len
-                                            else return v'
-                                 lift $ M.write v'' index x
-                                 return $ StateProcessing (Just v'', index + 1)
-          close (Nothing, index) = return $ V.fromList []
-          close (Just v, index) = lift . V.unsafeFreeze $ M.take index v
-
--- | Consumes the first n values from a source and returns as an immutable
--- vector.
-consumeVectorN :: (PrimMonad m, Resource m, V.Vector v a)
-                  => Int -> Sink a m (v a)
-consumeVectorN n = sinkState (Nothing, 0) push close
-    where push (v, index) x = do
-            v' <- case v of
-                    Nothing -> lift $ M.new n
-                    Just vec -> return vec
-            if index >= n
-                then do v'' <- lift $ V.unsafeFreeze v'
-                        return $ StateDone Nothing v''
-                else do lift $ M.write v' index x
-                        return $ StateProcessing (Just v', index + 1)
-          close (Nothing, index) = return $ V.fromList []
-          close (Just v, index) = lift $ V.unsafeFreeze v
-
--- | Consumes all values from the stream and returns as a mutable vector.
-consumeMVector :: (PrimMonad m, Resource m, M.MVector v a)
-                  => Sink a m (v (PrimState m) a)
-consumeMVector = sinkState (Nothing, 0) push close
-    where push (v, index) x = do v' <- case v of
-                                        Nothing -> lift $ M.new 10
-                                        Just vec -> return vec
-                                 let len = M.length v'
-                                 v'' <- if index >= len
-                                            then lift $ M.grow v' len
-                                            else return v'
-                                 lift $ M.write v'' index x
-                                 return $ StateProcessing (Just v'', index + 1)
-          close (Nothing, index) = lift $ M.new 0
-          close (Just v, index) = return $ M.take index v
-
--- | Consumes the first n values from the stream and returns as a
--- mutable vector.
-consumeMVectorN :: (PrimMonad m, Resource m, M.MVector v a)
-                   => Int -> Sink a m (v (PrimState m) a)
-consumeMVectorN n = sinkState (Nothing, 0) push close
-    where push (v, index) x =
-            do v' <- case v of
-                        Nothing -> lift $ M.new n
-                        Just vec -> return vec
-               if index >= n
-                    then return $ StateDone Nothing v'
-                    else do lift $ M.write v' index x
-                            return $ StateProcessing (Just v', index + 1)
-          close (Nothing, index) = lift $ M.new 0
-          close (Just v, index) = return v
-
--- | Conduit which thaws immutable vectors into mutable vectors
-thawConduit :: (PrimMonad m, Resource m, V.Vector v a)
-                => Conduit (v a) m (V.Mutable v (PrimState m) a)
-thawConduit = L.mapM V.unsafeThaw
-
--- | Conduit which freezes mutable vectors into immutable vectors
-freezeConduit :: (PrimMonad m, Resource m, V.Vector v a)
-                 => Conduit (V.Mutable v (PrimState m) a) m (v a)
-freezeConduit = L.mapM V.unsafeFreeze
diff --git a/test/Main.hs b/test/Main.hs
--- a/test/Main.hs
+++ b/test/Main.hs
@@ -3,8 +3,8 @@
 
 import Control.Monad.ST
 import Data.Conduit
+import Data.Conduit.Vector
 import qualified Data.Vector as V
-import Data.Vector.Conduit
 import Test.QuickCheck
 import qualified Test.Framework as F
 import Test.Framework.Runners.Console (defaultMain)
@@ -12,19 +12,19 @@
 
 testInverse :: [Int] -> Bool
 testInverse l = runST $ do let v = V.fromList l
-                           v' <- runResourceT $ sourceVector v $$ consumeVector
+                           v' <- sourceVector v $$ consumeVector
                            return $ v == v'
 
 testInverse2 :: [Int] -> Bool
 testInverse2 l = runST $ do let v = V.fromList l
-                            v' <- runResourceT $ sourceVector v $$ consumeMVector
+                            v' <- sourceVector v $$ consumeMVector
                             v'' <- V.unsafeFreeze v'
                             return $ v == v''
 
 testInverse3 :: [[Int]]-> Bool
 testInverse3 ls = runST $ do let vs = map V.fromList ls
                              let v = V.fromList vs
-                             v' <- runResourceT $ sourceVector v $= thawConduit $= freezeConduit $$ consumeVector
+                             v' <- sourceVector v $= thawConduit $= freezeConduit $$ consumeVector
                              return $ v == v'
 
 tests :: [F.Test]
diff --git a/vector-conduit.cabal b/vector-conduit.cabal
--- a/vector-conduit.cabal
+++ b/vector-conduit.cabal
@@ -1,5 +1,5 @@
 name:                vector-conduit
-version:             0.2.1.0
+version:             0.3.0.0
 synopsis:            Conduit utilities for vectors
 description:         Provides sources and sinks for vectors.
 license:             GPL-3
@@ -13,10 +13,10 @@
 
 library
   exposed-modules:
-    Data.Vector.Conduit
+    Data.Conduit.Vector
   build-depends:
     base >= 4.0 && < 5.0,
-    conduit >= 0.2 && < 0.3,
+    conduit >= 0.3 && < 0.4,
     primitive >= 0.4 && < 0.5,
     transformers >= 0.2 && < 0.3,
     vector >= 0.9 && < 0.10
@@ -28,7 +28,7 @@
   build-depends:
     vector-conduit,
     base >= 4.0 && < 5.0,
-    conduit >= 0.2 && < 0.3,
+    conduit >= 0.3 && < 0.4,
     test-framework >= 0.5 && < 0.6,
     test-framework-quickcheck2 >= 0.2 && < 0.3,
     QuickCheck >= 2.4 && < 2.5,