diff --git a/Data/Iterable.hs b/Data/Iterable.hs
--- a/Data/Iterable.hs
+++ b/Data/Iterable.hs
@@ -2,16 +2,15 @@
 -- | Declares Iterable class for handling multi-level, heterogeneous, monomorphic collections that allow nested iteration.
 module Data.Iterable(Iterable(..)) where
 
-import Language.Haskell.TH.Syntax
 import Control.Monad.Identity(runIdentity,foldM)
 
 -- | Class for iterating all nested components `b` of type `a`.
 class Iterable a b where
-  imapM   :: (Monad m) => (b -> m b) -> a -> m a
-  imap    ::              (b ->   b) -> a ->   a
-  imap f e = runIdentity $ imapM (return . f) e
-  ifoldM  :: (Monad m) => (c -> b -> m c) -> c -> a -> m c
-  ifoldr  ::              (b -> c ->   c) -> c -> a ->   c
-  ifoldl  ::              (c -> b ->   c) -> c -> a ->   c
-  ifoldl' ::              (c -> b ->   c) -> c -> a ->   c
-  ilength :: b -> a -> Int -- NOTE: b is 'dummy' type argument to satisfy Iterable a b constraint
+  itmapM   :: (Monad m) => (b -> m b) -> a -> m a
+  itmap    ::              (b ->   b) -> a ->   a
+  itmap f e = runIdentity $ itmapM (return . f) e
+  itfoldM  :: (Monad m) => (c -> b -> m c) -> c -> a -> m c
+  itfoldr  ::              (b -> c ->   c) -> c -> a ->   c
+  itfoldl  ::              (c -> b ->   c) -> c -> a ->   c
+  itfoldl' ::              (c -> b ->   c) -> c -> a ->   c
+  itlength :: b -> a -> Int -- NOTE: b is 'dummy' type argument to satisfy Iterable a b constraint
diff --git a/Data/Iterable/Instantiate.hs b/Data/Iterable/Instantiate.hs
--- a/Data/Iterable/Instantiate.hs
+++ b/Data/Iterable/Instantiate.hs
@@ -10,24 +10,24 @@
 --self_iterable typA = gen_iterable typA typA [e| id |] [e| L.singleton |]
 self_iterable typA = 
   [d| instance Iterable $(typA) $(typA) where
-        imapM f a     = f a 
-        ifoldM  f e a = f e a
-        ifoldr  f e a = f a e
-        ifoldl  f e a = f e a 
-        ifoldl' f e a = f e a
-        ilength   d a = 1
+        itmapM f a     = f a 
+        itfoldM  f e a = f e a
+        itfoldr  f e a = f a e
+        itfoldl  f e a = f e a 
+        itfoldl' f e a = f e a
+        itlength   d a = 1
     |]
 
 -- | Generates a transitive instance of `Iterable` between $typA and $typC,
 --   assuming existence of `Iterable` $typA $typB, and `Iterable` $typB $typC.
 trans_iterable typA typB typC = 
   [d| instance Iterable $(typA) $(typC) where
-        imapM   f a   = (imapM   :: (Monad m) => ( $(typB) -> m $(typB) ) -> $(typA)   -> m $(typA) ) (imapM f) a 
-        imap    f a   = (imap    ::              ( $(typB) ->   $(typB) ) -> $(typA)   ->   $(typA) ) (imap  f) a 
-        ifoldM  f e a = (ifoldM  :: (Monad m) => (c -> $(typB)   -> m c) -> c   -> $(typA)   -> m c       ) (ifoldM  f) e a 
-        ifoldr  f e a = (ifoldr  ::              ($(typB) -> c   ->   c) -> c   -> $(typA)   ->   c       ) (\bb cc -> ifoldr  f cc bb) e a
-        ifoldl  f e a = (ifoldl  ::              (c -> $(typB)   ->   c) -> c   -> $(typA)   ->   c       ) (ifoldl  f) e a
-        ifoldl' f e a = (ifoldl' ::              (c -> $(typB)   ->   c) -> c   -> $(typA)   ->   c       ) (ifoldl' f) e a
-        ilength _   a = (ifoldl' ::              (c -> $(typB)   ->   c) -> c   -> $(typA)   ->   c       ) (\a b-> a + ilength (undefined :: $(typC)) b) 0 a
+        itmapM   f a   = (itmapM   :: (Monad m) => ( $(typB) -> m $(typB) ) -> $(typA)   -> m $(typA) ) (itmapM f) a 
+        itmap    f a   = (itmap    ::              ( $(typB) ->   $(typB) ) -> $(typA)   ->   $(typA) ) (itmap  f) a 
+        itfoldM  f e a = (itfoldM  :: (Monad m) => (c -> $(typB)   -> m c) -> c   -> $(typA)   -> m c       ) (itfoldM  f) e a 
+        itfoldr  f e a = (itfoldr  ::              ($(typB) -> c   ->   c) -> c   -> $(typA)   ->   c       ) (\bb cc -> itfoldr  f cc bb) e a
+        itfoldl  f e a = (itfoldl  ::              (c -> $(typB)   ->   c) -> c   -> $(typA)   ->   c       ) (itfoldl  f) e a
+        itfoldl' f e a = (itfoldl' ::              (c -> $(typB)   ->   c) -> c   -> $(typA)   ->   c       ) (itfoldl' f) e a
+        itlength _   a = (itfoldl' ::              (c -> $(typB)   ->   c) -> c   -> $(typA)   ->   c       ) (\a b-> a + itlength (undefined :: $(typC)) b) 0 a
     |]
 
diff --git a/Data/Iterable/Instantiate/Vector.hs b/Data/Iterable/Instantiate/Vector.hs
--- a/Data/Iterable/Instantiate/Vector.hs
+++ b/Data/Iterable/Instantiate/Vector.hs
@@ -4,7 +4,7 @@
 
 import           Language.Haskell.TH.Syntax
 import           Data.Iterable
-import qualified Data.Vector as L
+import qualified Data.Vector as V
 
 -- | Generates a direct instance of iterable between $typA and $typB with
 --   given names of getter and setter, so that:
@@ -12,13 +12,13 @@
 --   $setter :: $typB -> $typA -> $typA
 gen_vector_iterable typA typB getter setter = 
   [d| instance Iterable $(typA) $(typB) where
-        imapM f a =
-          do b' <- L.mapM f ( $(getter) a)
+        itmapM f a =
+          do b' <- V.mapM f ( $(getter) a)
              return $ $(setter) a b'
-        ifoldM  f e a  = do r <- L.foldM f e ( $(getter) a)
-                            return r
-        ifoldr  f e a = L.foldr  f e ( $(getter) a)
-        ifoldl  f e a = L.foldl  f e ( $(getter) a)
-        ifoldl' f e a = L.foldl' f e ( $(getter) a) 
-        ilength   d a = L.length ( $(getter) a)
+        itfoldM  f e a  = do r <- V.foldM f e ( $(getter) a)
+                             return r
+        itfoldr  f e a = V.foldr  f e ( $(getter) a)
+        itfoldl  f e a = V.foldl  f e ( $(getter) a)
+        itfoldl' f e a = V.foldl' f e ( $(getter) a) 
+        itlength   d a = V.length ( $(getter) a)
     |]
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -3,6 +3,8 @@
 Typeclass and TemplateHaskell instantiating methods for accessing data within multilevel,
 monomorphic, heterogeneous collections.
 
-Used as a main interface to Protein Databank structures parsed by hPDB library.
+[![Build Status](https://api.travis-ci.org/mgajda/iterable.png?branch=master)](https://www.travis-ci.org/mgajda/iterable)
+
+Used as a main interface to Protein Databank structures parsed by [hPDB](http://hackage.haskell.org/package/hPDB) library.
 
 Details on official releases are on [Hackage](http://hackage.haskell.org/package/iterable).
diff --git a/iterable.cabal b/iterable.cabal
--- a/iterable.cabal
+++ b/iterable.cabal
@@ -1,5 +1,5 @@
 name:                iterable
-version:             1.0
+version:             2.0
 stability:           stable
 homepage:            https://github.com/mgajda/iterable
 package-url:         http://hackage.haskell.org/package/iterable