diff --git a/hw-prim.cabal b/hw-prim.cabal
--- a/hw-prim.cabal
+++ b/hw-prim.cabal
@@ -1,5 +1,5 @@
 name:                   hw-prim
-version:                0.0.3.1
+version:                0.0.3.2
 synopsis:               Primitive functions and data types
 description:            Please see README.md
 homepage:               http://github.com/haskell-works/hw-prim#readme
@@ -36,9 +36,9 @@
                       , HaskellWorks.Data.Vector.StorableVectorLike
                       , HaskellWorks.Data.Vector.VectorLike
   build-depends:        base                          >= 4          && < 5
-                      , vector
                       , bytestring
                       , random
+                      , vector
 
   default-language:     Haskell2010
   ghc-options:          -Wall -O2 -msse4.2
@@ -49,8 +49,12 @@
   main-is:              Spec.hs
   other-modules:        HaskellWorks.Data.SearchSpec
   build-depends:        base                          >= 4          && < 5
+                      , bytestring
                       , hspec
+                      , hw-prim
                       , QuickCheck
+                      , random
+                      , vector
   ghc-options:          -threaded -rtsopts -with-rtsopts=-N -Wall
   default-language:     Haskell2010
 
diff --git a/src/HaskellWorks/Data/FromByteString.hs b/src/HaskellWorks/Data/FromByteString.hs
--- a/src/HaskellWorks/Data/FromByteString.hs
+++ b/src/HaskellWorks/Data/FromByteString.hs
@@ -1,10 +1,66 @@
+{-# LANGUAGE FlexibleInstances  #-}
+{-# LANGUAGE InstanceSigs       #-}
+
 module HaskellWorks.Data.FromByteString
   ( FromByteString(..)
   ) where
 
-import           Data.ByteString.Internal
+import           Data.Bits
+import qualified Data.ByteString            as BS
+import qualified Data.Vector.Storable       as DVS
+import           Data.Word
 
 -- | Class for byte-string-like datastructures
 class FromByteString a where
   -- | Convert a byte string to a value of type @a
-  fromByteString :: ByteString -> a
+  fromByteString :: BS.ByteString -> a
+
+instance FromByteString (DVS.Vector Word8) where
+  fromByteString :: BS.ByteString -> DVS.Vector Word8
+  fromByteString bs = DVS.unfoldrN (BS.length bs) gen bs
+    where gen :: BS.ByteString -> Maybe (Word8, BS.ByteString)
+          gen cs = case BS.uncons cs of
+            Just (d, ds)  -> Just (d, ds)
+            Nothing       -> Nothing
+
+instance FromByteString (DVS.Vector Word16) where
+  fromByteString :: BS.ByteString -> DVS.Vector Word16
+  fromByteString bs = DVS.unfoldrN (BS.length bs `div` 2 + 2) gen bs
+    where gen :: BS.ByteString -> Maybe (Word16, BS.ByteString)
+          gen cs = case BS.uncons cs of
+            Just (d, ds)  -> gen' 8 (fromIntegral d) ds
+            Nothing       -> Nothing
+          gen' :: Int -> Word16 -> BS.ByteString -> Maybe (Word16, BS.ByteString)
+          gen' n w cs
+            | n >= 16   = Just (w, cs)
+            | otherwise = case BS.uncons cs of
+                Just (d, ds)  -> gen' (n + 8) (w .|. (fromIntegral d `shiftL` fromIntegral n)) ds
+                Nothing       -> Just (w, cs)
+
+instance FromByteString (DVS.Vector Word32) where
+  fromByteString :: BS.ByteString -> DVS.Vector Word32
+  fromByteString bs = DVS.unfoldrN (BS.length bs `div` 4 + 4) gen bs
+    where gen :: BS.ByteString -> Maybe (Word32, BS.ByteString)
+          gen cs = case BS.uncons cs of
+            Just (d, ds)  -> gen' 8 (fromIntegral d) ds
+            Nothing       -> Nothing
+          gen' :: Int -> Word32 -> BS.ByteString -> Maybe (Word32, BS.ByteString)
+          gen' n w cs
+            | n >= 32   = Just (w, cs)
+            | otherwise = case BS.uncons cs of
+                Just (d, ds)  -> gen' (n + 8) (w .|. (fromIntegral d `shiftL` fromIntegral n)) ds
+                Nothing       -> Just (w, cs)
+
+instance FromByteString (DVS.Vector Word64) where
+  fromByteString :: BS.ByteString -> DVS.Vector Word64
+  fromByteString bs = DVS.unfoldrN (BS.length bs `div` 8 + 8) gen bs
+    where gen :: BS.ByteString -> Maybe (Word64, BS.ByteString)
+          gen cs = case BS.uncons cs of
+            Just (d, ds)  -> gen' 8 (fromIntegral d) ds
+            Nothing       -> Nothing
+          gen' :: Int -> Word64 -> BS.ByteString -> Maybe (Word64, BS.ByteString)
+          gen' n w cs
+            | n >= 64   = Just (w, cs)
+            | otherwise = case BS.uncons cs of
+                Just (d, ds)  -> gen' (n + 8) (w .|. (fromIntegral d `shiftL` fromIntegral n)) ds
+                Nothing       -> Just (w, cs)