diff --git a/Data/VectorSpace/Free.hs b/Data/VectorSpace/Free.hs
--- a/Data/VectorSpace/Free.hs
+++ b/Data/VectorSpace/Free.hs
@@ -7,18 +7,26 @@
 -- Stability   : experimental
 -- Portability : portable
 -- 
-{-# LANGUAGE TypeFamilies      #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE FlexibleContexts  #-}
-{-# LANGUAGE CPP               #-}
+{-# LANGUAGE TypeFamilies         #-}
+{-# LANGUAGE FlexibleInstances    #-}
+{-# LANGUAGE FlexibleContexts     #-}
+{-# LANGUAGE CPP                  #-}
 
-module Data.VectorSpace.Free ( module Linear.V0
-                             , module Linear.V1
-                             , module Linear.V2
-                             , module Linear.V3
-                             , module Linear.V4
+module Data.VectorSpace.Free (
+                             -- * Supported types
+                             -- | These come from the <http://hackage.haskell.org/package/linear/ linear> package.
+                               V0
+                             , V1
+                             , V2
+                             , V3
+                             , V4
+                             -- * The vector-space type classes
+                             -- ** General
+                             -- | These come from the <http://hackage.haskell.org/package/vector-space/ vector-space> package.
                              , AffineSpace(..), AdditiveGroup(..)
-                             , VectorSpace(..), InnerSpace(..) 
+                             , VectorSpace(..), InnerSpace(..), HasBasis(..)
+                             -- ** Free
+                             , FiniteFreeSpace(..)
                              ) where
 
 import Data.AffineSpace
@@ -37,6 +45,8 @@
 
 import Control.Lens
 
+import qualified Data.Vector.Unboxed as UArr
+
 vDecomp :: FoldableWithIndex (L.E v) v => v s -> [(L.E v, s)]
 vDecomp = ifoldr (\b s l -> (b,s):l) []
 
@@ -104,3 +114,69 @@
   trie f = V4T $ V4 (f L.ex) (f L.ey) (f L.ez) (f L.ew)
   untrie (V4T v) (L.E i) = v^.i
   enumerate (V4T (V4 x y z w)) = [(L.ex, x), (L.ey, y), (L.ez, z), (L.ew, w)]
+
+
+
+
+
+class (VectorSpace v, Num (Scalar v)) => FiniteFreeSpace v where
+  {-# MINIMAL freeDimension, toFullUnboxVect, unsafeFromFullUnboxVect #-}
+  freeDimension :: Functor p => p v -> Int
+  toFullUnboxVect :: UArr.Unbox (Scalar v) => v -> UArr.Vector (Scalar v)
+  unsafeFromFullUnboxVect :: UArr.Unbox (Scalar v) => UArr.Vector (Scalar v) -> v
+  fromUnboxVect :: UArr.Unbox (Scalar v) => UArr.Vector (Scalar v) -> v
+  fromUnboxVect v = result
+   where result = case UArr.length v of
+           0        -> zeroV
+           n | n<d  -> unsafeFromFullUnboxVect $ v UArr.++ UArr.replicate (d-n) 0
+         d = freeDimension [result]
+
+
+instance FiniteFreeSpace Int where
+  freeDimension _ = 1
+  toFullUnboxVect = UArr.singleton
+  unsafeFromFullUnboxVect v = UArr.unsafeIndex v 0
+instance FiniteFreeSpace Float where
+  freeDimension _ = 1
+  toFullUnboxVect = UArr.singleton
+  unsafeFromFullUnboxVect v = UArr.unsafeIndex v 0
+instance FiniteFreeSpace Double where
+  freeDimension _ = 1
+  toFullUnboxVect = UArr.singleton
+  unsafeFromFullUnboxVect v = UArr.unsafeIndex v 0
+
+instance (FiniteFreeSpace u, FiniteFreeSpace v, Scalar u ~ Scalar v)
+      => FiniteFreeSpace (u,v) where
+  freeDimension puv = freeDimension (fmap fst puv) + freeDimension (fmap snd puv)
+  toFullUnboxVect (u,v) = toFullUnboxVect u UArr.++ toFullUnboxVect v
+  unsafeFromFullUnboxVect uv = (u,v)
+   where u = unsafeFromFullUnboxVect uv
+         v = unsafeFromFullUnboxVect $ UArr.drop du uv
+         du = freeDimension [u]
+
+instance Num s => FiniteFreeSpace (V0 s) where
+  freeDimension _ = 0
+  toFullUnboxVect _ = UArr.empty
+  unsafeFromFullUnboxVect _ = zeroV
+instance Num s => FiniteFreeSpace (V1 s) where
+  freeDimension _ = 1
+  toFullUnboxVect (V1 n) = UArr.singleton n
+  unsafeFromFullUnboxVect v = V1 $ UArr.unsafeIndex v 0
+instance Num s => FiniteFreeSpace (V2 s) where
+  freeDimension _ = 2
+  toFullUnboxVect (V2 x y) = UArr.fromListN 2 [x,y]
+  unsafeFromFullUnboxVect v = V2 (UArr.unsafeIndex v 0)
+                                 (UArr.unsafeIndex v 1)
+instance Num s => FiniteFreeSpace (V3 s) where
+  freeDimension _ = 3
+  toFullUnboxVect (V3 x y z) = UArr.fromListN 3 [x,y,z]
+  unsafeFromFullUnboxVect v = V3 (UArr.unsafeIndex v 0)
+                                 (UArr.unsafeIndex v 1)
+                                 (UArr.unsafeIndex v 2)
+instance Num s => FiniteFreeSpace (V4 s) where
+  freeDimension _ = 4
+  toFullUnboxVect (V4 x y z w) = UArr.fromListN 3 [x,y,z,w]
+  unsafeFromFullUnboxVect v = V4 (UArr.unsafeIndex v 0)
+                                 (UArr.unsafeIndex v 1)
+                                 (UArr.unsafeIndex v 2)
+                                 (UArr.unsafeIndex v 3)
diff --git a/free-vector-spaces.cabal b/free-vector-spaces.cabal
--- a/free-vector-spaces.cabal
+++ b/free-vector-spaces.cabal
@@ -2,7 +2,7 @@
 -- documentation, see http://haskell.org/cabal/users-guide/
 
 name:                free-vector-spaces
-version:             0.1.0.0
+version:             0.1.1.0
 synopsis:            Instantiate the classes from the vector-space package with types from linear
 description:         The <http://hackage.haskell.org/package/linear/ linear> package offers efficient
                      vector types — where vector means /element of a free vector space/, i.e.
@@ -10,10 +10,12 @@
                      this  concept of free vectors with a canonical coordinate representation.
                      .
                      While this is practically speaking often useful, it is also
+                     .
                      * Questionable in terms of conceptual elegance. The idea of a vector has
                        originally not much to do with number-arrays; in physics a vector is just
                        a quantity with /magnitude and direction/. Only by fixing a basis can
                        a coordinate representation arise from that.
+                     .
                      * Not as safe as we'd like. The typical linear-algebra languages like Matlab
                        or Fortran are notorious for hard-to spot mistakes that often arise from the 
                        total reliance on coordinate representations (every vector/linear map is just
@@ -52,7 +54,8 @@
                        vector-space >=0.8 && <0.13,
                        MemoTrie,
                        linear >=1.18 && <1.23,
-                       lens >= 4 && < 5
+                       lens >= 4 && < 5,
+                       vector
   ghc-options:         -O2
   -- hs-source-dirs:      
   default-language:    Haskell2010