diff --git a/Data/StorableVector/Base.hs b/Data/StorableVector/Base.hs
--- a/Data/StorableVector/Base.hs
+++ b/Data/StorableVector/Base.hs
@@ -56,7 +56,7 @@
 #if defined(__GLASGOW_HASKELL__)
 import Data.Generics            (Data(..), Typeable(..))
 import GHC.Base                 (realWorld#)
-import GHC.IOBase               (IO(IO), )
+import GHC.IO                   (IO(IO), )
 #endif
 
 import System.IO.Unsafe         (unsafePerformIO, )
diff --git a/Data/StorableVector/Cursor.hs b/Data/StorableVector/Cursor.hs
--- a/Data/StorableVector/Cursor.hs
+++ b/Data/StorableVector/Cursor.hs
@@ -31,7 +31,7 @@
 I hope that this is more efficient.
 With this restriction @s@ cannot be e.g. a function type
 but this would kill performance anyway.
-Functions that need this flexibility may fall back to other data structures
+Functions which need this flexibility may fall back to other data structures
 (lists or chunky StorableVectors) and convert to the Cursor structure later.
 -}
 -- | Cf. StreamFusion  Data.Stream
@@ -50,7 +50,7 @@
    Buffer {
        memory :: {-# UNPACK #-} !(ForeignPtr a),
        size   :: {-# UNPACK #-} !Int,  -- size of allocated memory, I think I only need it for debugging
-       gen    :: {-# UNPACK #-} !(Generator a),  -- we need this indirection for the existential type in Generator
+       gen    :: {-# UNPACK #-} !(Generator a),
        cursor :: {-# UNPACK #-} !(IORef Int)
    }
 
@@ -156,9 +156,6 @@
 {-# INLINE cons #-}
 {- |
 This is expensive and should not be used to construct lists iteratively!
-A recursion-enabling 'cons' would be 'consN'
-that allocates a buffer of given size,
-initializes the leading cell and sets the buffer pointer to the next cell.
 -}
 cons :: Storable a =>
    a -> Vector a -> Vector a
@@ -224,12 +221,6 @@
                         withForeignPtr p (\q -> pokeElemOff q c a) >>
                         return (Just a)
 
-{-
-It is tempting to turn this into a simple loop without the IORefs.
-This could be compiled to an efficient strict loop,
-but it would fail if the vector content depends on its own,
-like in @fix (consN 1000 'a')@.
--}
 -- | evaluate all values up to a given position
 evaluateToIO :: Storable a =>
    Int -> Buffer a -> IO ()
diff --git a/Data/StorableVector/Lazy.hs b/Data/StorableVector/Lazy.hs
--- a/Data/StorableVector/Lazy.hs
+++ b/Data/StorableVector/Lazy.hs
@@ -20,7 +20,7 @@
 import qualified Data.List.HT as ListHT
 import Data.Tuple.HT (mapPair, mapFst, mapSnd, )
 import Data.Maybe.HT (toMaybe, )
-import Data.Maybe (Maybe(Just), maybe, fromMaybe, )
+import Data.Maybe (fromMaybe, )
 
 import Foreign.Storable (Storable)
 
@@ -45,6 +45,7 @@
 
 import qualified Prelude as P
 {-
+import Data.Maybe (Maybe(Just), maybe, fromMaybe, )
 import Prelude
    (Int, IO, ($), (.), fst, snd, id, error,
     Char, Num, Show, showsPrec, FilePath,
diff --git a/Data/StorableVector/Lazy/Builder.hs b/Data/StorableVector/Lazy/Builder.hs
--- a/Data/StorableVector/Lazy/Builder.hs
+++ b/Data/StorableVector/Lazy/Builder.hs
@@ -18,9 +18,9 @@
 import qualified Data.StorableVector as SV
 import qualified Data.StorableVector.Lazy as SVL
 import qualified Data.StorableVector.ST.Strict as STV
-import qualified Data.StorableVector.ST.Lazy as STVL
+-- import qualified Data.StorableVector.ST.Lazy as STVL
 
-import Data.StorableVector.Lazy (ChunkSize(ChunkSize), )
+import Data.StorableVector.Lazy (ChunkSize, )
 import Control.Monad (liftM2, )
 import Control.Monad.ST.Strict (ST, runST, unsafeInterleaveST, )
 import Data.Monoid (Monoid(mempty, mappend), )
diff --git a/Data/StorableVector/Pointer.hs b/Data/StorableVector/Pointer.hs
--- a/Data/StorableVector/Pointer.hs
+++ b/Data/StorableVector/Pointer.hs
@@ -12,7 +12,7 @@
 import qualified Foreign.ForeignPtr as FPtr
 import Foreign.Marshal.Array (advancePtr, )
 import Foreign.Storable (Storable, peek, )
-import Foreign (Ptr, ForeignPtr, )
+import Foreign (Ptr, )
 -- import System.IO.Unsafe (unsafePerformIO, )
 
 
diff --git a/Data/StorableVector/ST/Private.hs b/Data/StorableVector/ST/Private.hs
--- a/Data/StorableVector/ST/Private.hs
+++ b/Data/StorableVector/ST/Private.hs
@@ -10,11 +10,9 @@
 module Data.StorableVector.ST.Private where
 
 import qualified Data.StorableVector.Base as V
-import qualified Data.StorableVector as VS
 
 import Data.StorableVector.Memory (mallocForeignPtrArray, )
 
-import qualified Control.Monad.ST.Strict as ST
 import Control.Monad.ST.Strict (ST, unsafeIOToST, )  -- stToIO,
 
 import Foreign.Ptr        (Ptr, )
diff --git a/Data/StorableVector/ST/Strict.hs b/Data/StorableVector/ST/Strict.hs
--- a/Data/StorableVector/ST/Strict.hs
+++ b/Data/StorableVector/ST/Strict.hs
@@ -37,7 +37,6 @@
 import qualified Data.StorableVector as VS
 import qualified Data.StorableVector.Lazy as VL
 
-import qualified Control.Monad.ST.Strict as ST
 import Control.Monad.ST.Strict (ST, unsafeIOToST, runST, )  -- stToIO,
 
 import Foreign.Ptr              (Ptr, )
diff --git a/storablevector.cabal b/storablevector.cabal
--- a/storablevector.cabal
+++ b/storablevector.cabal
@@ -1,5 +1,5 @@
 Name:                storablevector
-Version:             0.2.7.1
+Version:             0.2.7.2
 Category:            Data
 Synopsis:            Fast, packed, strict storable arrays with a list interface like ByteString
 Description:
@@ -51,7 +51,7 @@
 Source-Repository this
   type:     darcs
   location: http://code.haskell.org/storablevector/
-  tag:      0.2.7.1
+  tag:      0.2.7.2
 
 Library
   Build-Depends: