diff --git a/ChangeLog b/ChangeLog
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,4 +1,12 @@
+Changes in 0.3.0.0
 
+  * HVector instances up to 32-element tuples
+
+  * `asCVec` function added
+
+  * `ContVec` reexported from Data.Vector.HFixed
+
+
 Changes in 0.2.0.0
 
   * Type changing lenses added
@@ -6,3 +14,4 @@
   * zipMonoF added
 
   * types of monomorphize and monomorphizeF corrected
+
diff --git a/Data/Vector/HFixed.hs b/Data/Vector/HFixed.hs
--- a/Data/Vector/HFixed.hs
+++ b/Data/Vector/HFixed.hs
@@ -20,6 +20,8 @@
   , HVectorF(..)
   , Wrap
   , Proxy(..)
+  , ContVec
+  , asCVec
     -- * Position based functions
   , convert
   , head
@@ -80,8 +82,8 @@
                                        
 import Data.Functor.Compose (Compose)
 import Data.Monoid          (Monoid,All(..))
-import Prelude hiding
-  (head,tail,concat,sequence,map,zipWith,replicate,foldr,foldl,mapM_,compare)
+import Prelude (Functor(..),Monad(..),Eq(..),Ord,Bool,Ordering,
+                id,(.),($),undefined,seq)
 import qualified Prelude
 
 import Data.Vector.HFixed.Class hiding (cons,consF)
@@ -92,6 +94,21 @@
 ----------------------------------------------------------------
 -- Generic API
 ----------------------------------------------------------------
+
+-- | Restrict type of vector to 'ContVec'. This function is useful for
+--   resolving type ambiguity when composing functions. For example
+--   following code would not compile because intermediate type is
+--   ambiguous:
+--
+-- > cons 'a' . tail
+--
+--   GHC cannot guess what type should be produced by @tail@. However
+--   we can fix type of intermediate vector with @asCVec@, so code
+--   below will work just fine:
+--
+-- > cons 'a' . asCVec . tail
+asCVec :: ContVec xs -> ContVec xs
+asCVec = id
 
 -- | We can convert between any two vector which have same
 --   structure but different representations.
diff --git a/Data/Vector/HFixed/Class.hs b/Data/Vector/HFixed/Class.hs
--- a/Data/Vector/HFixed/Class.hs
+++ b/Data/Vector/HFixed/Class.hs
@@ -759,7 +759,213 @@
   {-# INLINE construct #-}
   {-# INLINE inspect   #-}
 
+instance HVector (a,b,c,d,e,f,g,h) where
+  type Elems (a,b,c,d,e,f,g,h) = '[a,b,c,d,e,f,g,h]
+  construct = Fun (,,,,,,,)
+  inspect (a,b,c,d,e,f,g,h) (Fun fun) = fun a b c d e f g h
+  {-# INLINE construct #-}
+  {-# INLINE inspect   #-}
 
+instance HVector (a,b,c,d,e,f,g,h,i) where
+  type Elems (a,b,c,d,e,f,g,h,i) = '[a,b,c,d,e,f,g,h,i]
+  construct = Fun (,,,,,,,,)
+  inspect (a,b,c,d,e,f,g,h,i) (Fun fun) = fun a b c d e f g h i
+  {-# INLINE construct #-}
+  {-# INLINE inspect   #-}
+
+instance HVector (a,b,c,d,e,f,g,h,i,j) where
+  type Elems (a,b,c,d,e,f,g,h,i,j) = '[a,b,c,d,e,f,g,h,i,j]
+  construct = Fun (,,,,,,,,,)
+  inspect (a,b,c,d,e,f,g,h,i,j) (Fun fun) = fun a b c d e f g h i j
+  {-# INLINE construct #-}
+  {-# INLINE inspect   #-}
+
+instance HVector (a,b,c,d,e,f,g,h,i,j,k) where
+  type Elems (a,b,c,d,e,f,g,h,i,j,k) = '[a,b,c,d,e,f,g,h,i,j,k]
+  construct = Fun (,,,,,,,,,,)
+  inspect (a,b,c,d,e,f,g,h,i,j,k) (Fun fun) = fun a b c d e f g h i j k
+  {-# INLINE construct #-}
+  {-# INLINE inspect   #-}
+
+instance HVector (a,b,c,d,e,f,g,h,i,j,k,l) where
+  type Elems (a,b,c,d,e,f,g,h,i,j,k,l) = '[a,b,c,d,e,f,g,h,i,j,k,l]
+  construct = Fun (,,,,,,,,,,,)
+  inspect (a,b,c,d,e,f,g,h,i,j,k,l) (Fun fun) = fun a b c d e f g h i j k l
+  {-# INLINE construct #-}
+  {-# INLINE inspect   #-}
+
+instance HVector (a,b,c,d,e,f,g,h,i,j,k,l,m) where
+  type Elems (a,b,c,d,e,f,g,h,i,j,k,l,m) = '[a,b,c,d,e,f,g,h,i,j,k,l,m]
+  construct = Fun (,,,,,,,,,,,,)
+  inspect (a,b,c,d,e,f,g,h,i,j,k,l,m) (Fun fun) = fun a b c d e f g h i j k l m
+  {-# INLINE construct #-}
+  {-# INLINE inspect   #-}
+
+instance HVector (a,b,c,d,e,f,g,h,i,j,k,l,m,n) where
+  type Elems (a,b,c,d,e,f,g,h,i,j,k,l,m,n) = '[a,b,c,d,e,f,g,h,i,j,k,l,m,n]
+  construct = Fun (,,,,,,,,,,,,,)
+  inspect (a,b,c,d,e,f,g,h,i,j,k,l,m,n) (Fun fun) =
+    fun a b c d e f g h i j k l m n
+  {-# INLINE construct #-}
+  {-# INLINE inspect   #-}
+
+instance HVector (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) where
+  type Elems (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) = '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o]
+  construct = Fun (,,,,,,,,,,,,,,)
+  inspect (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) (Fun fun) =
+    fun a b c d e f g h i j k l m n o
+  {-# INLINE construct #-}
+  {-# INLINE inspect   #-}
+
+instance HVector (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) where
+  type Elems (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) =
+    '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p]
+  construct = Fun (,,,,,,,,,,,,,,,)
+  inspect (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) (Fun fun) =
+    fun a b c d e f g h i j k l m n o p
+  {-# INLINE construct #-}
+  {-# INLINE inspect   #-}
+
+instance HVector (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) where
+  type Elems (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) =
+    '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q]
+  construct = Fun (,,,,,,,,,,,,,,,,)
+  inspect (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) (Fun fun) =
+    fun a b c d e f g h i j k l m n o p q
+  {-# INLINE construct #-}
+  {-# INLINE inspect   #-}
+
+instance HVector (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) where
+  type Elems (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) =
+    '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r]
+  construct = Fun (,,,,,,,,,,,,,,,,,)
+  inspect (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) (Fun fun) =
+    fun a b c d e f g h i j k l m n o p q r
+  {-# INLINE construct #-}
+  {-# INLINE inspect   #-}
+
+instance HVector (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) where
+  type Elems (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) =
+    '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s]
+  construct = Fun (,,,,,,,,,,,,,,,,,,)
+  inspect (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) (Fun fun) =
+    fun a b c d e f g h i j k l m n o p q r s
+  {-# INLINE construct #-}
+  {-# INLINE inspect   #-}
+
+instance HVector (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) where
+  type Elems (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) =
+    '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t]
+  construct = Fun (,,,,,,,,,,,,,,,,,,,)
+  inspect (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) (Fun fun) =
+    fun a b c d e f g h i j k l m n o p q r s t
+  {-# INLINE construct #-}
+  {-# INLINE inspect   #-}
+
+instance HVector (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) where
+  type Elems (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) =
+    '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u]
+  construct = Fun (,,,,,,,,,,,,,,,,,,,,)
+  inspect (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u) (Fun fun) =
+    fun a b c d e f g h i j k l m n o p q r s t u
+  {-# INLINE construct #-}
+  {-# INLINE inspect   #-}
+
+instance HVector (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) where
+  type Elems (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) =
+    '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v]
+  construct = Fun (,,,,,,,,,,,,,,,,,,,,,)
+  inspect (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v) (Fun fun) =
+    fun a b c d e f g h i j k l m n o p q r s t u v
+  {-# INLINE construct #-}
+  {-# INLINE inspect   #-}
+
+instance HVector (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) where
+  type Elems (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) =
+    '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w]
+  construct = Fun (,,,,,,,,,,,,,,,,,,,,,,)
+  inspect (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w) (Fun fun) =
+    fun a b c d e f g h i j k l m n o p q r s t u v w
+  {-# INLINE construct #-}
+  {-# INLINE inspect   #-}
+
+instance HVector (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) where
+  type Elems (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) =
+    '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x]
+  construct = Fun (,,,,,,,,,,,,,,,,,,,,,,,)
+  inspect (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x) (Fun fun) =
+    fun a b c d e f g h i j k l m n o p q r s t u v w x
+  {-# INLINE construct #-}
+  {-# INLINE inspect   #-}
+
+instance HVector (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) where
+  type Elems (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) =
+    '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y]
+  construct = Fun (,,,,,,,,,,,,,,,,,,,,,,,,)
+  inspect (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y) (Fun fun) =
+    fun a b c d e f g h i j k l m n o p q r s t u v w x y
+  {-# INLINE construct #-}
+  {-# INLINE inspect   #-}
+
+
+instance HVector (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z) where
+  type Elems (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z) =
+    '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z]
+  construct = Fun (,,,,,,,,,,,,,,,,,,,,,,,,,)
+  inspect (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z) (Fun fun) =
+    fun a b c d e f g h i j k l m n o p q r s t u v w x y z
+  {-# INLINE construct #-}
+  {-# INLINE inspect   #-}
+
+
+instance HVector (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a') where
+  type Elems (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a') =
+    '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a']
+  construct = Fun (,,,,,,,,,,,,,,,,,,,,,,,,,,)
+  inspect (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a') (Fun fun) =
+    fun a b c d e f g h i j k l m n o p q r s t u v w x y z a'
+  {-# INLINE construct #-}
+  {-# INLINE inspect   #-}
+
+instance HVector (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a',b') where
+  type Elems (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a',b') =
+    '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a',b']
+  construct = Fun (,,,,,,,,,,,,,,,,,,,,,,,,,,,)
+  inspect (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a',b') (Fun fun) = fun a b c d e f g h i j k l m n o p q r s t u v w x y z a' b'
+  {-# INLINE construct #-}
+  {-# INLINE inspect   #-}
+
+instance HVector (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a',b',c') where
+  type Elems (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a',b',c') =
+    '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a',b',c']
+  construct = Fun (,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
+  inspect (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a',b',c') (Fun fun) = fun a b c d e f g h i j k l m n o p q r s t u v w x y z a' b' c'
+  {-# INLINE construct #-}
+  {-# INLINE inspect   #-}
+
+instance HVector (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a',b',c',d') where
+  type Elems (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a',b',c',d') =
+    '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a',b',c',d']
+  construct = Fun (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
+  inspect (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a',b',c',d') (Fun fun) = fun a b c d e f g h i j k l m n o p q r s t u v w x y z a' b' c' d'
+  {-# INLINE construct #-}
+  {-# INLINE inspect   #-}
+
+instance HVector (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a',b',c',d',e') where
+  type Elems (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a',b',c',d',e') = '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a',b',c',d',e']
+  construct = Fun (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
+  inspect (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a',b',c',d',e') (Fun fun) =
+    fun a b c d e f g h i j k l m n o p q r s t u v w x y z a' b' c' d' e'
+  {-# INLINE construct #-}
+  {-# INLINE inspect   #-}
+
+instance HVector (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a',b',c',d',e',f') where
+  type Elems (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a',b',c',d',e',f') = '[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a',b',c',d',e',f']
+  construct = Fun (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)
+  inspect (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a',b',c',d',e',f') (Fun fun) =
+    fun a b c d e f g h i j k l m n o p q r s t u v w x y z a' b' c' d' e' f'
+  {-# INLINE construct #-}
+  {-# INLINE inspect   #-}
 
 ----------------------------------------------------------------
 -- Generics
diff --git a/Data/Vector/HFixed/Cont.hs b/Data/Vector/HFixed/Cont.hs
--- a/Data/Vector/HFixed/Cont.hs
+++ b/Data/Vector/HFixed/Cont.hs
@@ -81,9 +81,7 @@
 import Data.Monoid           (Monoid(..),(<>))
 import Data.Functor.Compose  (Compose(..))
 import qualified Data.Vector.Fixed.Cont as F
-import Prelude hiding
-  (head,tail,concat,sequence,sequence_,map,zipWith,
-   replicate,foldr,foldl)
+import Prelude (Functor(..),Monad(..),id,(.),($),flip)
 
 import Data.Vector.HFixed.Class
 
diff --git a/fixed-vector-hetero.cabal b/fixed-vector-hetero.cabal
--- a/fixed-vector-hetero.cabal
+++ b/fixed-vector-hetero.cabal
@@ -1,5 +1,5 @@
 Name:           fixed-vector-hetero
-Version:        0.2.0.0
+Version:        0.3.0.0
 Synopsis:       Generic heterogeneous vectors
 Description:
   Generic heterogeneous vectors
@@ -23,13 +23,15 @@
   location: http://bitbucket.org/Shimuuar/fixed-vector-hetero
 
 Library
-  Ghc-options:          -Wall
+  -- Bigger context stack needed for HVector instances for large
+  -- tuples
+  Ghc-options:          -Wall -fcontext-stack=50
   Build-Depends:
     base          >=4.6 && <5,
     deepseq,
     transformers,
     ghc-prim,
-    fixed-vector  >= 0.7.0.0,
+    fixed-vector  >= 0.7.0.3,
     primitive
   Exposed-modules:      
     Data.Vector.HFixed