diff --git a/Data/Vector/Fixed.hs b/Data/Vector/Fixed.hs
--- a/Data/Vector/Fixed.hs
+++ b/Data/Vector/Fixed.hs
@@ -1,4 +1,10 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
+{-# LANGUAGE TypeFamilies      #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE GADTs               #-}
+{-# LANGUAGE DeriveDataTypeable  #-}
 -- |
 -- Generic API for vectors with fixed length.
 --
@@ -25,6 +31,7 @@
   , Fun(..)
   , length
     -- * Constructors
+    -- $construction
     -- ** Small dimensions
     -- $smallDim
   , mk1
@@ -60,6 +67,8 @@
   , imapM_
   , sequence
   , sequence_
+  , sequenceA
+  , traverse
     -- * Folding
   , foldl
   , foldr
@@ -86,11 +95,16 @@
   , toList
   , fromList
     -- * Data types
-  , VecList
+  , VecList(..)
   ) where
 
+import Control.Applicative (Applicative(..))
+import Data.Typeable       (Typeable)
+import qualified Data.Foldable    as F
+import qualified Data.Traversable as T
+
 import Data.Vector.Fixed.Internal.Arity
-import Data.Vector.Fixed.Cont     (VecList,Vector(..),VectorN,Dim,length)
+import Data.Vector.Fixed.Cont     (Vector(..),VectorN,Dim,length)
 import qualified Data.Vector.Fixed.Cont as C
 import Data.Vector.Fixed.Internal
 
@@ -100,6 +114,21 @@
                       , head,tail,mapM,mapM_,sequence,sequence_
                       )
 
+
+-- $construction
+--
+-- In addition to functions list above it's possible to use tuples in
+-- conjunction with 'convert' function to create vectors. For example:
+--
+-- v = convert (x,y,z)
+--
+-- It will work on if type of @v@ is know from elsewhere. Same trick
+-- could be used to pattern match on the vector with opaque
+-- representation using view patterns
+--
+-- > function :: Vec N3 Double -> ...
+-- > function (convert -> (x,y,z)) = ...
+
 -- $smallDim
 --
 -- Constructors for vectors with small dimensions.
@@ -128,3 +157,48 @@
 "fixed-vector:index/basicIndex"[1] forall vv i.
   runIndex i (C.cvec vv) = C.basicIndex vv i
  #-}
+
+
+-- | Vector based on the lists. Not very useful by itself but is
+--   necessary for implementation.
+data VecList n a where
+  Nil  :: VecList Z a
+  Cons :: a -> VecList n a -> VecList (S n) a
+  deriving (Typeable)
+
+-- Vector instance
+type instance Dim (VecList n) = n
+
+instance Arity n => Vector (VecList n) a where
+  construct = Fun $ accum
+    (\(T_List f) a -> T_List (f . Cons a))
+    (\(T_List f)   -> f Nil)
+    (T_List id :: T_List a n n)
+  inspect v (Fun f) = apply step (Flip v) f
+    where
+      step :: Flip VecList a (S k)  -> (a, Flip VecList a k)
+      step (Flip (Cons a xs)) = (a, Flip xs)
+  {-# INLINE construct #-}
+  {-# INLINE inspect   #-}
+instance Arity n => VectorN VecList n a
+
+newtype Flip f a n = Flip (f n a)
+
+newtype T_List a n k = T_List (VecList k a -> VecList n a)
+
+
+-- Standard instances
+instance (Show a, Arity n) => Show (VecList n a) where
+  show = show . foldr (:) []
+instance (Eq a, Arity n) => Eq (VecList n a) where
+  (==) = eq
+instance Arity n => Functor (VecList n) where
+  fmap = map
+instance Arity n => Applicative (VecList n) where
+  pure  = replicate
+  (<*>) = zipWith ($)
+instance Arity n => F.Foldable (VecList n) where
+  foldr = foldr
+instance Arity n => T.Traversable (VecList n) where
+  sequenceA = sequenceA
+  traverse  = traverse
diff --git a/Data/Vector/Fixed/Boxed.hs b/Data/Vector/Fixed/Boxed.hs
--- a/Data/Vector/Fixed/Boxed.hs
+++ b/Data/Vector/Fixed/Boxed.hs
@@ -1,7 +1,8 @@
 {-# LANGUAGE TypeFamilies          #-}
 {-# LANGUAGE FlexibleInstances     #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE ScopedTypeVariables   #-}
+{-# LANGUAGE DeriveDataTypeable    #-}
 -- |
 -- Boxed vector.
 module Data.Vector.Fixed.Boxed (
@@ -9,13 +10,18 @@
     Vec
   , Vec2
   , Vec3
+  , Vec4
+  , Vec5
     -- * Mutable
   , MVec
   ) where
 
-import Control.Monad
+import Control.Applicative  (Applicative(..))
 import Data.Primitive.Array
-import Prelude hiding (length,replicate,zipWith,map,foldl)
+import Data.Typeable        (Typeable)
+import qualified Data.Foldable    as F
+import qualified Data.Traversable as T
+import Prelude hiding (length,replicate,zipWith,map,foldl,foldr)
 
 import Data.Vector.Fixed
 import Data.Vector.Fixed.Internal.Arity
@@ -29,12 +35,16 @@
 
 -- | Vector with fixed length which can hold any value.
 newtype Vec n a = Vec (Array a)
+                  deriving (Typeable)
 
 -- | Mutable unboxed vector with fixed length
 newtype MVec n s a = MVec (MutableArray s a)
+                     deriving (Typeable)
 
 type Vec2 = Vec (S (S Z))
 type Vec3 = Vec (S (S (S Z)))
+type Vec4 = Vec (S (S (S (S Z))))
+type Vec5 = Vec (S (S (S (S (S Z)))))
 
 
 
@@ -90,6 +100,25 @@
   (==) = eq
   {-# INLINE (==) #-}
 
+instance Arity n => Functor (Vec n) where
+  {-# INLINE fmap #-}
+  fmap = map
+
+instance Arity n => Applicative (Vec n) where
+  pure  = replicate
+  (<*>) = zipWith ($)
+  {-# INLINE pure  #-}
+  {-# INLINE (<*>) #-}
+
+instance Arity n => F.Foldable (Vec n) where
+  foldr = foldr
+  {-# INLINE foldr #-}
+
+instance Arity n => T.Traversable (Vec n) where
+  sequenceA = sequenceA
+  traverse  = traverse
+  {-# INLINE sequenceA #-}
+  {-# INLINE traverse #-}
 
 uninitialised :: a
 uninitialised = error "Data.Vector.Fixed.Boxed: uninitialised element"
diff --git a/Data/Vector/Fixed/Cont.hs b/Data/Vector/Fixed/Cont.hs
--- a/Data/Vector/Fixed/Cont.hs
+++ b/Data/Vector/Fixed/Cont.hs
@@ -13,7 +13,7 @@
   , VectorN
   , length
     -- * Vector as continuation
-  , ContVecT
+  , ContVecT(..)
   , ContVec
     -- ** Synonyms for small numerals
   , N1
@@ -24,6 +24,7 @@
   , N6
     -- * Construction of ContVec
   , cvec
+  , empty
   , fromList
   , replicate
   , replicateM
@@ -77,12 +78,10 @@
   , or
   , all
   , any
-    -- * Data types
-  , VecList
   ) where
 
-import Control.Applicative
-import Data.Complex (Complex(..))
+import Control.Applicative (Applicative(..))
+import Data.Complex        (Complex(..))
 import Data.Vector.Fixed.Internal.Arity
 import Data.Vector.Fixed.Internal.Id
 import Prelude hiding ( replicate,map,zipWith,maximum,minimum,and,or,any,all
@@ -98,7 +97,11 @@
 -- | Size of vector expressed as type-level natural.
 type family Dim (v :: * -> *)
 
--- | Type class for vectors with fixed length.
+-- | Type class for vectors with fixed length. Instance should provide
+-- two functions: one to create vector and another for vector
+-- deconstruction. They must obey following law:
+--
+-- > inspect v construct = v
 class Arity (Dim v) => Vector v a where
   -- | N-ary function for creation of vectors.
   construct :: Fun (Dim v) a (v a)
@@ -145,7 +148,7 @@
   {-# INLINE (<*>) #-}
 
 -- | Change monad type for the continuation vector.
-changeMonad :: (Monad p, Monad m, Arity n)
+changeMonad :: (Monad p, Arity n)
             => (forall x. p x -> x) -- ^ Function to extract result from monad
             -> ContVecT p n a -> ContVecT m n a
 {-# INLINE changeMonad #-}
@@ -172,6 +175,11 @@
 cvec v = ContVecT (inspect v)
 {-# INLINE[0] cvec #-}
 
+-- | Create empty vector.
+empty :: ContVecT m Z a
+{-# INLINE empty #-}
+empty = ContVecT (\(Fun r) -> r)
+
 -- | Convert list to continuation-based vector. Will throw error if
 --   list is shorter than resulting vector.
 fromList :: forall m n a. Arity n => [a] -> ContVecT m n a
@@ -359,34 +367,43 @@
 
 
 
--- FIXME: explain function
 izipWithF :: forall n a b c r. (Arity n)
           => (Int -> a -> b -> c) -> Fun n c r -> Fun n a (Fun n b r)
 {-# INLINE izipWithF #-}
 izipWithF f (Fun g0) =
   fmap (\v -> Fun $ accum
-              (\(T_izip i (VecList (a:as)) g) b -> T_izip (i+1) (VecList as) (g $ f i a b)
+              (\(T_izip i (a:as) g) b -> T_izip (i+1) as (g $ f i a b)
               )
               (\(T_izip _ _ x) -> x)
               (T_izip 0 v g0 :: (T_izip a c r n))
-       ) construct
+       ) makeList
 
 izipWithFM :: forall m n a b c r. (Arity n, Monad m)
            => (Int -> a -> b -> m c) -> Fun n c (m r) -> Fun n a (Fun n b (m r))
 {-# INLINE izipWithFM #-}
 izipWithFM f (Fun g0) =
   fmap (\v -> Fun $ accumM
-              (\(T_izip i (VecList (a:as)) g) b -> do x <- f i a b
-                                                      return $ T_izip (i+1) (VecList as) (g x)
+              (\(T_izip i (a:as) g) b -> do x <- f i a b
+                                            return $ T_izip (i+1) as (g x)
               )
               (\(T_izip _ _ x) -> x)
               (return $ T_izip 0 v g0 :: m (T_izip a c (m r) n))
-       ) construct
+       ) makeList
 
-data T_izip a c r n = T_izip Int (VecList n a) (Fn n c r)
 
+makeList :: forall n a. Arity n => Fun n a [a]
+{-# INLINE makeList #-}
+makeList = Fun $ accum
+    (\(T_mkList xs) x -> T_mkList (xs . (x:)))
+    (\(T_mkList xs) -> xs [])
+    (T_mkList id :: T_mkList a n)
 
+newtype T_mkList a n = T_mkList ([a] -> [a])
 
+data T_izip a c r n = T_izip Int [a] (Fn n c r)
+
+
+
 ----------------------------------------------------------------
 -- Running vector
 ----------------------------------------------------------------
@@ -595,36 +612,7 @@
   cvec (vector v) = changeMonad runID v
   #-}
 
-----------------------------------------------------------------
--- VecList
-----------------------------------------------------------------
-
--- | Vector based on the lists. Not very useful by itself but is
---   necessary for implementation.
-newtype VecList n a = VecList [a]
-                      deriving (Show,Eq)
-
-type instance Dim (VecList n) = n
-
-newtype Flip f a n = Flip (f n a)
-
-newtype T_list a n = T_list ([a] -> [a])
-
--- It's vital to avoid 'reverse' and build list using [a]->[a]
--- functions. Reverse is recursive and interferes with inlining.
-instance Arity n => Vector (VecList n) a where
-  construct = Fun $ accum
-    (\(T_list xs) x -> T_list (xs . (x:)))
-    (\(T_list xs) -> VecList (xs []) :: VecList n a)
-    (T_list id :: T_list a n)
-  inspect v (Fun f) = apply
-    (\(Flip (VecList (x:xs))) -> (x, Flip (VecList xs)))
-    (Flip v)
-    f
-  {-# INLINE construct #-}
-  {-# INLINE inspect   #-}
-instance Arity n => VectorN VecList n a
-
+ 
 ----------------------------------------------------------------
 -- Instances
 ----------------------------------------------------------------
diff --git a/Data/Vector/Fixed/Internal.hs b/Data/Vector/Fixed/Internal.hs
--- a/Data/Vector/Fixed/Internal.hs
+++ b/Data/Vector/Fixed/Internal.hs
@@ -5,10 +5,12 @@
 -- Implementation of fixed-vectors
 module Data.Vector.Fixed.Internal where
 
+import Control.Applicative (Applicative)
+import qualified Data.Traversable as T
+
 import Data.Vector.Fixed.Internal.Arity
 import Data.Vector.Fixed.Cont     (Vector(..),Dim)
 import qualified Data.Vector.Fixed.Cont as C
-
 import qualified Prelude as P
 import Prelude hiding ( replicate,map,zipWith,maximum,minimum,and,or,all,any
                       , foldl,foldr,foldl1,length,sum
@@ -211,7 +213,7 @@
 foldl f x = C.runContVec (C.foldl f x)
           . C.cvec
 
--- | Left fold over vector
+-- | Right fold over vector
 foldr :: Vector v a => (a -> b -> b) -> b -> v a -> b
 {-# INLINE foldr #-}
 foldr f x = C.runContVec (C.foldr f x)
@@ -381,6 +383,18 @@
 {-# INLINE imapM_ #-}
 imapM_ f = ifoldl (\m i a -> m >> f i a >> return ()) (return ())
 
+
+-- | Analog of 'T.sequenceA' from 'T.Traversable'.
+sequenceA :: (Vector v a, Vector v (f a), Applicative f)
+          => v (f a) -> f (v a)
+{-# INLINE sequenceA #-}
+sequenceA = fmap fromList . T.sequenceA . toList
+
+-- | Analog of 'T.traverse' from 'T.Traversable'.
+traverse :: (Vector v a, Vector v b, Applicative f)
+          => (a -> f b) -> v a -> f (v b)
+{-# INLINE traverse #-}
+traverse f = fmap fromList . T.traverse f . toList
 
 ----------------------------------------------------------------
 
diff --git a/Data/Vector/Fixed/Monomorphic.hs b/Data/Vector/Fixed/Monomorphic.hs
new file mode 100644
--- /dev/null
+++ b/Data/Vector/Fixed/Monomorphic.hs
@@ -0,0 +1,362 @@
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE TypeFamilies #-}
+-- |
+-- Wrapper function for working with monomorphic vectors. Standard API
+-- require vector to be parametric in their element type making it
+-- impossible to work with vectors like
+--
+-- > data Vec3 = Vec3 Double Double Double
+--
+-- This module provides newtype wrapper which allows use of functions
+-- from "Data.Vector.Fixed" with such data types and function which
+-- works with such vectors.
+--
+-- Functions have same meaning as ones from "Data.Vector.Fixed" and
+-- documented there.
+module Data.Vector.Fixed.Monomorphic (
+    -- * Vector type class
+    -- ** Vector size
+    DimMono
+  , Z
+  , S
+    -- ** Synonyms for small numerals
+  , F.N1
+  , F.N2
+  , F.N3
+  , F.N4
+  , F.N5
+  , F.N6
+    -- ** Type class
+  , VectorMono(..)
+  , Arity
+  , Fun(..)
+  , length
+    -- * Constructors
+    -- $construction
+    -- ** Small dimensions
+    -- $smallDim
+  , mk1
+  , mk2
+  , mk3
+  , mk4
+  , mk5
+    -- ** Functions
+  , replicate
+  , replicateM
+  , generate
+  , generateM
+  , unfoldr
+  , basis
+    -- * Modifying vectors
+    -- ** Transformations
+  , head
+  , tail
+  , (!)
+    -- ** Comparison
+  , eq
+    -- ** Maps
+  , map
+  , mapM
+  , mapM_
+  , imap
+  , imapM
+  , imapM_
+    -- * Folding
+  , foldl
+  , foldr
+  , foldl1
+  , ifoldl
+  , ifoldr
+  , foldM
+  , ifoldM
+    -- ** Special folds
+  , sum
+  , maximum
+  , minimum
+  , and
+  , or
+  , all
+  , any
+    -- * Zips
+  , zipWith
+  , zipWithM
+  , izipWith
+  , izipWithM
+    -- * Conversion
+  , convert
+  , toList
+  , fromList
+  ) where
+
+import Control.Monad (liftM)
+import Data.Vector.Fixed.Internal.Arity
+import qualified Data.Vector.Fixed as F
+import Prelude hiding ( replicate,map,zipWith,maximum,minimum,and,or,all,any
+                      , foldl,foldr,foldl1,length,sum
+                      , head,tail,mapM,mapM_,sequence,sequence_
+                      )
+
+
+----------------------------------------------------------------
+-- Wrappers for monomorphic vectors
+----------------------------------------------------------------
+
+-- | Wrapper for monomorphic vectors it provides 'Vector' instance for
+--   monomorphic vectors. Trick is to restrict type parameter @a@ to
+--   single possible value.
+newtype Mono v a = Mono { getMono :: v }
+
+type instance F.Dim (Mono v) = DimMono v
+
+instance (VectorMono v, a ~ VectorElm v, Arity (DimMono v)) => F.Vector (Mono v) a where
+  construct  = fmap Mono construct
+  inspect    = inspect . getMono
+  basicIndex = basicIndex . getMono
+  {-# INLINE construct  #-}
+  {-# INLINE inspect    #-}
+  {-# INLINE basicIndex #-}
+
+
+-- | Dimensions of monomorphic vector.
+type family DimMono v :: *
+
+-- | Counterpart of 'Vector' type class for monomorphic vectors.
+class Arity (DimMono v) => VectorMono v where
+  -- | Type of vector elements.
+  type VectorElm v :: *
+  -- | Construct vector
+  construct :: Fun (DimMono v) (VectorElm v) v
+  -- | Inspect vector
+  inspect   :: v -> Fun (DimMono v) (VectorElm v) r -> r
+  -- | Optional more efficient implementation of indexing
+  basicIndex :: v -> Int -> VectorElm v
+  basicIndex v i = Mono v F.! i
+  {-# INLINE basicIndex #-}
+
+-- | Length of vector
+length :: Arity (DimMono v) => v -> Int
+length = F.length . Mono
+{-# INLINE length #-}
+
+
+----------------------------------------------------------------
+--
+----------------------------------------------------------------
+
+mk1 :: (VectorMono v, VectorElm v ~ a, DimMono v ~ F.N1)
+    => a -> v
+mk1 a1 = getMono $ F.mk1 a1
+{-# INLINE mk1 #-}
+
+mk2 :: (VectorMono v, VectorElm v ~ a, DimMono v ~ F.N2)
+    => a -> a-> v
+mk2 a1 a2 = getMono $ F.mk2 a1 a2
+{-# INLINE mk2 #-}
+
+mk3 :: (VectorMono v, VectorElm v ~ a, DimMono v ~ F.N3)
+    => a -> a-> a -> v
+mk3 a1 a2 a3 = getMono $ F.mk3 a1 a2 a3
+{-# INLINE mk3 #-}
+
+mk4 :: (VectorMono v, VectorElm v ~ a, DimMono v ~ F.N4)
+    => a -> a-> a -> a -> v
+mk4 a1 a2 a3 a4 = getMono $ F.mk4 a1 a2 a3 a4
+{-# INLINE mk4 #-}
+
+mk5 :: (VectorMono v, VectorElm v ~ a, DimMono v ~ F.N5)
+    => a -> a-> a -> a -> a -> v
+mk5 a1 a2 a3 a4 a5 = getMono $ F.mk5 a1 a2 a3 a4 a5
+{-# INLINE mk5 #-}
+
+replicate :: (VectorMono v, VectorElm v ~ a) => a -> v
+{-# INLINE replicate #-}
+replicate = getMono . F.replicate
+
+replicateM :: (VectorMono v, VectorElm v ~ a, Monad m) => m a -> m v
+{-# INLINE replicateM #-}
+replicateM a = getMono `liftM` F.replicateM a
+
+basis :: (VectorMono v, VectorElm v ~ a, Num a) => Int -> v
+{-# INLINE basis #-}
+basis = getMono . F.basis
+
+unfoldr :: (VectorMono v, VectorElm v ~ a) => (b -> (a,b)) -> b -> v
+{-# INLINE unfoldr #-}
+unfoldr f = getMono . F.unfoldr f
+
+generate :: (VectorMono v, VectorElm v ~ a) => (Int -> a) -> v
+{-# INLINE generate #-}
+generate = getMono . F.generate
+
+generateM :: (Monad m, VectorMono v, VectorElm v ~ a) => (Int -> m a) -> m v
+{-# INLINE generateM #-}
+generateM f = getMono `liftM` F.generateM f
+
+
+
+----------------------------------------------------------------
+
+head :: (VectorMono v, VectorElm v ~ a, DimMono v ~ S n) => v -> a
+{-# INLINE head #-}
+head = F.head . Mono
+
+tail :: ( VectorMono v, VectorElm v ~ a
+        , VectorMono w, VectorElm w ~ a
+        , DimMono v ~ S (DimMono w))
+     => v -> w
+{-# INLINE tail #-}
+tail v = getMono $ F.tail $ Mono v
+
+
+(!) :: (VectorMono v, VectorElm v ~ a) => v -> Int -> a
+{-# INLINE (!) #-}
+v ! n = Mono v F.! n
+
+foldl :: (VectorMono v, VectorElm v ~ a)
+      => (b -> a -> b) -> b -> v -> b
+{-# INLINE foldl #-}
+foldl f x = F.foldl f x . Mono
+
+foldr :: (VectorMono v, VectorElm v ~ a)
+      => (a -> b -> b) -> b -> v -> b
+{-# INLINE foldr #-}
+foldr f x = F.foldr f x . Mono
+
+
+foldl1 :: (VectorMono v, VectorElm v ~ a, DimMono v ~ S n)
+       => (a -> a -> a) -> v -> a
+{-# INLINE foldl1 #-}
+foldl1 f = F.foldl1 f . Mono
+
+ifoldr :: (VectorMono v, VectorElm v ~ a)
+       => (Int -> a -> b -> b) -> b -> v -> b
+{-# INLINE ifoldr #-}
+ifoldr f x = F.ifoldr f x . Mono
+
+ifoldl :: (VectorMono v, VectorElm v ~ a)
+       => (b -> Int -> a -> b) -> b -> v -> b
+{-# INLINE ifoldl #-}
+ifoldl f z = F.ifoldl f z . Mono
+
+-- | Monadic fold over vector.
+foldM :: (VectorMono v, VectorElm v ~ a, Monad m)
+      => (b -> a -> m b) -> b -> v -> m b
+{-# INLINE foldM #-}
+foldM f x = F.foldM f x . Mono
+
+ifoldM :: (VectorMono v, VectorElm v ~ a, Monad m) => (b -> Int -> a -> m b) -> b -> v -> m b
+{-# INLINE ifoldM #-}
+ifoldM f x = F.ifoldM f x . Mono
+
+
+
+----------------------------------------------------------------
+
+sum :: (VectorMono v, VectorElm v ~ a, Num a) => v -> a
+sum = F.sum . Mono
+{-# INLINE sum #-}
+
+maximum :: (VectorMono v, VectorElm v ~ a, DimMono v ~ S n, Ord a) => v -> a
+maximum = F.maximum . Mono
+{-# INLINE maximum #-}
+
+minimum :: (VectorMono v, VectorElm v ~ a, DimMono v ~ S n, Ord a) => v -> a
+minimum = F.minimum . Mono
+{-# INLINE minimum #-}
+
+and :: (VectorMono v, VectorElm v ~ Bool) => v -> Bool
+and = F.and . Mono
+{-# INLINE and #-}
+
+or :: (VectorMono v, VectorElm v ~ Bool) => v -> Bool
+or = F.or . Mono
+{-# INLINE or #-}
+
+all :: (VectorMono v, VectorElm v ~ a) => (a -> Bool) -> v -> Bool
+all f = F.all f . Mono
+{-# INLINE all #-}
+
+any :: (VectorMono v, VectorElm v ~ a) => (a -> Bool) -> v -> Bool
+any f = F.any f . Mono
+{-# INLINE any #-}
+
+
+----------------------------------------------------------------
+
+eq :: (VectorMono v, VectorElm v ~ a, Eq a) => v -> v -> Bool
+{-# INLINE eq #-}
+eq v w = F.eq (Mono v) (Mono w)
+
+
+----------------------------------------------------------------
+
+map :: (VectorMono v, VectorElm v ~ a) => (a -> a) -> v -> v
+{-# INLINE map #-}
+map f = getMono . F.map f . Mono
+
+mapM :: (VectorMono v, VectorElm v ~ a, Monad m)
+     => (a -> m a) -> v -> m v
+{-# INLINE mapM #-}
+mapM f v = getMono `liftM` F.mapM f (Mono v)
+
+mapM_ :: (VectorMono v, VectorElm v ~ a, Monad m) => (a -> m b) -> v -> m ()
+{-# INLINE mapM_ #-}
+mapM_ f = F.mapM_ f . Mono
+
+
+imap :: (VectorMono v, VectorElm v ~ a) =>
+    (Int -> a -> a) -> v -> v
+{-# INLINE imap #-}
+imap f = getMono . F.imap f . Mono
+
+imapM :: (VectorMono v, VectorElm v ~ a, Monad m)
+      => (Int -> a -> m a) -> v -> m v
+{-# INLINE imapM #-}
+imapM f v = getMono `liftM` F.imapM f (Mono v)
+
+imapM_ :: (VectorMono v, VectorElm v ~ a, Monad m) => (Int -> a -> m b) -> v -> m ()
+{-# INLINE imapM_ #-}
+imapM_ f = F.imapM_ f . Mono
+
+
+----------------------------------------------------------------
+
+zipWith :: (VectorMono v, VectorElm v ~ a)
+        => (a -> a -> a) -> v -> v -> v
+{-# INLINE zipWith #-}
+zipWith f v u = getMono $ F.zipWith f (Mono v) (Mono u)
+
+
+zipWithM :: (VectorMono v, VectorElm v ~ a, Monad m)
+         => (a -> a -> m a) -> v -> v -> m v
+{-# INLINE zipWithM #-}
+zipWithM f v u = getMono `liftM` F.zipWithM f (Mono v) (Mono u)
+
+izipWith :: (VectorMono v, VectorElm v ~ a)
+         => (Int -> a -> a -> a) -> v -> v -> v
+{-# INLINE izipWith #-}
+izipWith f v u = getMono $ F.izipWith f (Mono v) (Mono u)
+
+izipWithM :: (VectorMono v, VectorElm v ~ a, Monad m)
+          => (Int -> a -> a -> m a) -> v -> v -> m v
+{-# INLINE izipWithM #-}
+izipWithM f v u = getMono `liftM` F.izipWithM f (Mono v) (Mono u)
+
+
+
+----------------------------------------------------------------
+
+convert :: (VectorMono v, VectorMono w, VectorElm v ~ VectorElm w, DimMono v ~ DimMono w)
+        => v -> w
+{-# INLINE convert #-}
+convert = getMono . F.convert . Mono
+
+toList :: (VectorMono v, VectorElm v ~ a) => v -> [a]
+toList = foldr (:) []
+
+fromList :: (VectorMono v, VectorElm v ~ a) => [a] -> v
+{-# INLINE fromList #-}
+fromList = getMono . F.fromList
+
diff --git a/Data/Vector/Fixed/Primitive.hs b/Data/Vector/Fixed/Primitive.hs
--- a/Data/Vector/Fixed/Primitive.hs
+++ b/Data/Vector/Fixed/Primitive.hs
@@ -2,6 +2,7 @@
 {-# LANGUAGE FlexibleInstances     #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE ScopedTypeVariables   #-}
+{-# LANGUAGE DeriveDataTypeable    #-}
 -- |
 -- Unboxed vectors with fixed length. Vectors from
 -- "Data.Vector.Fixed.Unboxed" provide more flexibility at no
@@ -11,6 +12,8 @@
     Vec
   , Vec2
   , Vec3
+  , Vec4
+  , Vec5
     -- * Mutable
   , MVec
     -- * Type classes
@@ -18,6 +21,7 @@
   ) where
 
 import Control.Monad
+import Data.Typeable            (Typeable)
 import Data.Primitive.ByteArray
 import Data.Primitive
 import Prelude hiding (length,replicate,zipWith,map,foldl)
@@ -34,12 +38,16 @@
 
 -- | Unboxed vector with fixed length
 newtype Vec n a = Vec ByteArray
+                  deriving (Typeable)
 
 -- | Mutable unboxed vector with fixed length
 newtype MVec n s a = MVec (MutableByteArray s)
+                     deriving (Typeable)
 
 type Vec2 = Vec (S (S Z))
 type Vec3 = Vec (S (S (S Z)))
+type Vec4 = Vec (S (S (S (S Z))))
+type Vec5 = Vec (S (S (S (S (S Z)))))
 
 
 
diff --git a/Data/Vector/Fixed/Storable.hs b/Data/Vector/Fixed/Storable.hs
--- a/Data/Vector/Fixed/Storable.hs
+++ b/Data/Vector/Fixed/Storable.hs
@@ -2,6 +2,7 @@
 {-# LANGUAGE FlexibleInstances     #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE ScopedTypeVariables   #-}
+{-# LANGUAGE DeriveDataTypeable    #-}
 -- |
 -- Storable-based unboxed vectors.
 module Data.Vector.Fixed.Storable (
@@ -9,6 +10,8 @@
     Vec
   , Vec2
   , Vec3
+  , Vec4
+  , Vec5
     -- * Raw pointers
   , unsafeFromForeignPtr
   , unsafeToForeignPtr
@@ -20,6 +23,7 @@
   ) where
 
 import Control.Monad.Primitive
+import Data.Typeable         (Typeable)
 import Foreign.Storable
 import Foreign.ForeignPtr
 import Foreign.Marshal.Array ( advancePtr, copyArray, moveArray )
@@ -40,12 +44,16 @@
 
 -- | Storable-based vector with fixed length
 newtype Vec n a = Vec (ForeignPtr a)
+                  deriving (Typeable)
 
 -- | Storable-based mutable vector with fixed length
 newtype MVec n s a = MVec (ForeignPtr a)
+                     deriving (Typeable)
 
 type Vec2 = Vec (S (S Z))
 type Vec3 = Vec (S (S (S Z)))
+type Vec4 = Vec (S (S (S (S Z))))
+type Vec5 = Vec (S (S (S (S (S Z)))))
 
 
 
diff --git a/Data/Vector/Fixed/Unboxed.hs b/Data/Vector/Fixed/Unboxed.hs
--- a/Data/Vector/Fixed/Unboxed.hs
+++ b/Data/Vector/Fixed/Unboxed.hs
@@ -5,6 +5,8 @@
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE ScopedTypeVariables   #-}
 {-# LANGUAGE UndecidableInstances  #-}
+{-# LANGUAGE StandaloneDeriving #-}
+{-# LANGUAGE DeriveDataTypeable #-}
 -- |
 -- Unboxed vectors with fixed length.
 module Data.Vector.Fixed.Unboxed(
@@ -12,6 +14,8 @@
     Vec
   , Vec2
   , Vec3
+  , Vec4
+  , Vec5
     -- * Mutable
   , MVec
     -- * Type classes
@@ -20,6 +24,7 @@
 
 import Control.Monad
 import Data.Complex
+import Data.Typeable (Typeable2,Typeable3)
 import Data.Int  (     Int8, Int16, Int32, Int64 )
 import Data.Word (Word,Word8,Word16,Word32,Word64)
 import Prelude hiding (length,replicate,zipWith,map,foldl)
@@ -36,8 +41,13 @@
 data family Vec  n a
 data family MVec n s a
 
+deriving instance Typeable2 Vec
+deriving instance Typeable3 MVec
+
 type Vec2 = Vec (S (S Z))
 type Vec3 = Vec (S (S (S Z)))
+type Vec4 = Vec (S (S (S (S Z))))
+type Vec5 = Vec (S (S (S (S (S Z)))))
 
 class (IVector (Vec n) a, MVector (MVec n) a) => Unbox n a
 
diff --git a/fixed-vector.cabal b/fixed-vector.cabal
--- a/fixed-vector.cabal
+++ b/fixed-vector.cabal
@@ -1,5 +1,5 @@
 Name:           fixed-vector
-Version:        0.3.0.1
+Version:        0.4.0.0
 Synopsis:       Generic vectors with statically known size.
 Description:
   Generic library for vectors with statically known
@@ -42,8 +42,28 @@
   [@Data.Vector.Fixed.Primitive@]
   Unboxed vectors based on pritimive package.
   .
+  [@Data.Vector.Fixed.Monomorphic@]
+  Wrappers for monomorphic vectors
+  .
+  Changes in 0.4.0.0
+  .
+  * Wrapper for monomorphics vectors is added.
+  .
+  * @VecList@ is reimplemented as GADT and constructors are exported.
+  .
+  * Constructor of ContVecT is exported
+  .
+  * Empty @ContVecT@ is implemented as @empty@.
+  .
+  * @Typeable@, @Foldable@ and @Traversable@ instances are added where
+    appropriate
+  .
   Changes in 0.3.0.0
   .
+  * Wrappers for monomorphic types added.
+  .
+  Changes in 0.3.0.0
+  .
   * @Vector@ type class definition is moved to the @D.V.F.Cont@ module.
   .
   * Indexing function restored.
@@ -101,6 +121,7 @@
     Data.Vector.Fixed.Internal.Id
     Data.Vector.Fixed.Cont
     Data.Vector.Fixed
+    Data.Vector.Fixed.Monomorphic
     -- Arrays
     Data.Vector.Fixed.Mutable
     Data.Vector.Fixed.Boxed