diff --git a/bench/Main.hs b/bench/Main.hs
deleted file mode 100644
--- a/bench/Main.hs
+++ /dev/null
@@ -1,53 +0,0 @@
-{-# LANGUAGE BangPatterns        #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-
-module Main where
-
-import Criterion.Main
-import Data.Monoid
-import Data.Word
-import Foreign
-import HaskellWorks.Data.FromForeignRegion
-
-import qualified Data.ByteString          as BS
-import qualified Data.ByteString.Internal as BSI
-import qualified Data.Vector.Storable     as DVS
-import qualified System.IO                as IO
-import qualified System.IO.MMap           as IO
-
-setupEnvByteString :: FilePath -> IO BS.ByteString
-setupEnvByteString filepath = do
-  (fptr :: ForeignPtr Word8, offset, size) <- IO.mmapFileForeignPtr filepath IO.ReadOnly Nothing
-  let !bs = BSI.fromForeignPtr (castForeignPtr fptr) offset size
-  return bs
-
-mmapVectorLike :: FromForeignRegion a => FilePath -> IO a
-mmapVectorLike filePath = do
-  region <- IO.mmapFileForeignPtr filePath IO.ReadOnly Nothing
-  let !bs = fromForeignRegion region
-  return bs
-
-sumFileByteString :: FilePath -> IO ()
-sumFileByteString filePath = do
-  !(bs :: BS.ByteString) <- mmapVectorLike filePath
-  IO.hPutStrLn IO.stderr $ "Length ByteString: " <> show (BS.length bs)
-  let !_ = BS.foldl' (+) 0 bs
-  return ()
-
-sumFileVectorWord64 :: FilePath -> IO ()
-sumFileVectorWord64 filePath = do
-  !(v :: DVS.Vector Word64) <- mmapVectorLike filePath
-  IO.hPutStrLn IO.stderr $ "Length Vector: " <> show (DVS.length v)
-  let !_ = DVS.foldl' (+) 0 v
-  return ()
-
-benchRankJson40Conduits :: [Benchmark]
-benchRankJson40Conduits =
-  [ env (return ()) $ \_ -> bgroup "medium.csv"
-    [ bench "Foldl' over ByteString"    (whnfIO (sumFileByteString   "corpus/medium.csv"))
-    , bench "Foldl' over Vector Word64" (whnfIO (sumFileVectorWord64 "corpus/medium.csv"))
-    ]
-  ]
-
-main :: IO ()
-main = defaultMain benchRankJson40Conduits
diff --git a/hw-prim.cabal b/hw-prim.cabal
--- a/hw-prim.cabal
+++ b/hw-prim.cabal
@@ -1,111 +1,64 @@
--- This file has been generated from package.yaml by hpack version 0.20.0.
---
--- see: https://github.com/sol/hpack
---
--- hash: 5f0d8912b294f5b5be8549239e1bc23d7911505275f8894882eaafa4bf683b5a
-
-name:           hw-prim
-version:        0.4.0.7
-synopsis:       Primitive functions and data types
-description:    Please see README.md
-category:       Data
-stability:      Experimental
-homepage:       http://github.com/haskell-works/hw-prim#readme
-bug-reports:    https://github.com/haskell-works/hw-prim/issues
-author:         John Ky
-maintainer:     newhoggy@gmail.com
-copyright:      2016-2018 John Ky
-license:        BSD3
-license-file:   LICENSE
-build-type:     Simple
-cabal-version:  >= 1.10
-
-extra-source-files:
-    README.md
-
-source-repository head
-  type: git
-  location: https://github.com/haskell-works/hw-prim
+name:                   hw-prim
+version:                0.5.0.0
+synopsis:               Primitive functions and data types
+description:            Please see README.md
+homepage:               http://github.com/haskell-works/hw-prim#readme
+license:                BSD3
+license-file:           LICENSE
+author:                 John Ky
+maintainer:             newhoggy@gmail.com
+copyright:              2016 John Ky
+category:               Data
+stability:              Experimental
+build-type:             Simple
+extra-source-files:     README.md
+cabal-version:          >= 1.22
 
 library
-  hs-source-dirs:
-      src
-  ghc-options: -Wall -O2 -msse4.2
-  build-depends:
-      base >=4 && <5
-    , bytestring
-    , mmap
-    , vector
-  exposed-modules:
-      HaskellWorks.Data.AtIndex
-      HaskellWorks.Data.ByteString
-      HaskellWorks.Data.Char.IsChar
-      HaskellWorks.Data.Concat
-      HaskellWorks.Data.Container
-      HaskellWorks.Data.Decode
-      HaskellWorks.Data.Drop
-      HaskellWorks.Data.Empty
-      HaskellWorks.Data.Filter
-      HaskellWorks.Data.FromByteString
-      HaskellWorks.Data.FromForeignRegion
-      HaskellWorks.Data.Generate
-      HaskellWorks.Data.Head
-      HaskellWorks.Data.Length
-      HaskellWorks.Data.Naive
-      HaskellWorks.Data.Positioning
-      HaskellWorks.Data.Search
-      HaskellWorks.Data.Sign
-      HaskellWorks.Data.Snoc
-      HaskellWorks.Data.Take
-      HaskellWorks.Data.TreeCursor
-      HaskellWorks.Data.Uncons
-      HaskellWorks.Data.Unsign
-      HaskellWorks.Data.Vector.AsVector64
-      HaskellWorks.Data.Vector.BoxedVectorLike
-      HaskellWorks.Data.Vector.StorableVectorLike
-  other-modules:
-      HaskellWorks.Data.Char
-      Paths_hw_prim
-  default-language: Haskell2010
+  hs-source-dirs:       src
+  exposed-modules:      HaskellWorks.Data.AtIndex
+                      , HaskellWorks.Data.ByteString
+                      , HaskellWorks.Data.Char.IsChar
+                      , HaskellWorks.Data.Concat
+                      , HaskellWorks.Data.Container
+                      , HaskellWorks.Data.Drop
+                      , HaskellWorks.Data.Empty
+                      , HaskellWorks.Data.Filter
+                      , HaskellWorks.Data.FromByteString
+                      , HaskellWorks.Data.FromForeignRegion
+                      , HaskellWorks.Data.Generate
+                      , HaskellWorks.Data.Head
+                      , HaskellWorks.Data.Length
+                      , HaskellWorks.Data.Naive
+                      , HaskellWorks.Data.Positioning
+                      , HaskellWorks.Data.Search
+                      , HaskellWorks.Data.Take
+                      , HaskellWorks.Data.TreeCursor
+                      , HaskellWorks.Data.Uncons
+                      , HaskellWorks.Data.Unsign
+                      , HaskellWorks.Data.Vector.AsVector64
+  build-depends:        base                          >= 4          && < 5
+                      , bytestring
+                      , vector
 
+  default-language:     Haskell2010
+  ghc-options:          -Wall -O2 -msse4.2
+
 test-suite hw-prim-test
-  type: exitcode-stdio-1.0
-  main-is: Spec.hs
-  hs-source-dirs:
-      test
-  ghc-options: -Wall -threaded -rtsopts -with-rtsopts=-N
-  build-depends:
-      QuickCheck
-    , base >=4 && <5
-    , bytestring
-    , directory
-    , exceptions
-    , hedgehog
-    , hspec
-    , hw-hspec-hedgehog
-    , hw-prim
-    , mmap
-    , vector
-  other-modules:
-      HaskellWorks.Data.FromByteStringSpec
-      HaskellWorks.Data.FromForeignRegionSpec
-      HaskellWorks.Data.SearchSpec
-      Paths_hw_prim
-  default-language: Haskell2010
+  type:                 exitcode-stdio-1.0
+  hs-source-dirs:       test
+  main-is:              Spec.hs
+  other-modules:        HaskellWorks.Data.FromByteStringSpec
+                      , HaskellWorks.Data.SearchSpec
+  build-depends:        base                          >= 4          && < 5
+                      , bytestring
+                      , hspec
+                      , hw-prim
+                      , QuickCheck
+                      , vector
+  ghc-options:          -threaded -rtsopts -with-rtsopts=-N -Wall
+  default-language:     Haskell2010
 
-benchmark bench
-  type: exitcode-stdio-1.0
-  main-is: Main.hs
-  hs-source-dirs:
-      bench
-  ghc-options: -Wall -O2 -msse4.2
-  build-depends:
-      base >=4 && <5
-    , bytestring
-    , criterion
-    , hw-prim
-    , mmap
-    , vector
-  other-modules:
-      Paths_hw_prim
-  default-language: Haskell2010
+source-repository head
+  type:     git
+  location: https://github.com/haskell-works/hw-prim
diff --git a/src/HaskellWorks/Data/AtIndex.hs b/src/HaskellWorks/Data/AtIndex.hs
--- a/src/HaskellWorks/Data/AtIndex.hs
+++ b/src/HaskellWorks/Data/AtIndex.hs
@@ -1,23 +1,27 @@
-{-# LANGUAGE FlexibleInstances   #-}
+{-# LANGUAGE FlexibleInstances     #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies        #-}
+{-# LANGUAGE TypeFamilies          #-}
 
 module HaskellWorks.Data.AtIndex
-    ( Container(..)
-    , AtIndex(..)
+    ( AtIndex(..)
+    , Container(..)
     , Length(..)
     ) where
 
-import qualified Data.ByteString               as BS
-import           Data.Int
-import qualified Data.Vector                   as DV
-import qualified Data.Vector.Storable          as DVS
-import           Data.Word
-import           HaskellWorks.Data.Length
-import           HaskellWorks.Data.Positioning
+import Data.Int
+import Data.Word
+import HaskellWorks.Data.Length
+import HaskellWorks.Data.Positioning
 
+import qualified Data.ByteString      as BS
+import qualified Data.Vector          as DV
+import qualified Data.Vector.Storable as DVS
+
 class Length v => AtIndex v where
+  -- | Element at the given index
   (!!!)   :: v -> Position -> Elem v
+
+  -- | Element at the given index
   atIndex :: v -> Position -> Elem v
 
 instance AtIndex [a] where
diff --git a/src/HaskellWorks/Data/Char.hs b/src/HaskellWorks/Data/Char.hs
deleted file mode 100644
--- a/src/HaskellWorks/Data/Char.hs
+++ /dev/null
@@ -1,5 +0,0 @@
-module HaskellWorks.Data.Char
-  ( module X
-  ) where
-
-import HaskellWorks.Data.Char.IsChar as X
diff --git a/src/HaskellWorks/Data/Concat.hs b/src/HaskellWorks/Data/Concat.hs
--- a/src/HaskellWorks/Data/Concat.hs
+++ b/src/HaskellWorks/Data/Concat.hs
@@ -6,15 +6,16 @@
   ( Concat(..)
   ) where
 
-import qualified Data.ByteString               as BS
-import           Data.Int
-import qualified Data.List                     as L
-import qualified Data.Vector                   as DV
-import qualified Data.Vector.Storable          as DVS
-import           Data.Word
+import Data.Int
+import Data.Word
 
--- | Class of values that support vector like operations
+import qualified Data.ByteString      as BS
+import qualified Data.List            as L
+import qualified Data.Vector          as DV
+import qualified Data.Vector.Storable as DVS
+
 class Concat v where
+  -- | Concatenate list of values
   concat :: [v] -> v
 
 instance Concat [a] where
diff --git a/src/HaskellWorks/Data/Container.hs b/src/HaskellWorks/Data/Container.hs
--- a/src/HaskellWorks/Data/Container.hs
+++ b/src/HaskellWorks/Data/Container.hs
@@ -6,13 +6,15 @@
     ( Container(..)
     ) where
 
-import qualified Data.ByteString               as BS
-import           Data.Int
-import qualified Data.Vector                   as DV
-import qualified Data.Vector.Storable          as DVS
-import           Data.Word
+import Data.Int
+import Data.Word
 
+import qualified Data.ByteString      as BS
+import qualified Data.Vector          as DV
+import qualified Data.Vector.Storable as DVS
+
 class Container a where
+  -- | Element type of a container
   type Elem a
 
 instance Container [a] where
diff --git a/src/HaskellWorks/Data/Decode.hs b/src/HaskellWorks/Data/Decode.hs
deleted file mode 100644
--- a/src/HaskellWorks/Data/Decode.hs
+++ /dev/null
@@ -1,11 +0,0 @@
-{-# LANGUAGE MultiParamTypeClasses #-}
-
-module HaskellWorks.Data.Decode
-  ( Decode(..)
-  , DecodeError(..)
-  ) where
-
-data DecodeError = DecodeError String deriving (Eq, Show)
-
-class Decode s t where
-  decode :: s -> Either DecodeError t
diff --git a/src/HaskellWorks/Data/Drop.hs b/src/HaskellWorks/Data/Drop.hs
--- a/src/HaskellWorks/Data/Drop.hs
+++ b/src/HaskellWorks/Data/Drop.hs
@@ -7,17 +7,19 @@
     , Drop(..)
     ) where
 
-import qualified Data.ByteString               as BS
-import           Data.Int
-import qualified Data.List                     as L
-import qualified Data.Vector                   as DV
-import qualified Data.Vector.Storable          as DVS
-import           Data.Word
-import           HaskellWorks.Data.Container
-import           HaskellWorks.Data.Positioning
-import           Prelude hiding (drop)
+import Data.Int
+import Data.Word
+import HaskellWorks.Data.Container
+import HaskellWorks.Data.Positioning
+import Prelude                       hiding (drop)
 
+import qualified Data.ByteString      as BS
+import qualified Data.List            as L
+import qualified Data.Vector          as DV
+import qualified Data.Vector.Storable as DVS
+
 class Container v => Drop v where
+  -- | Drop the first element from the container
   drop :: Count -> v -> v
 
 instance Drop [a] where
diff --git a/src/HaskellWorks/Data/Empty.hs b/src/HaskellWorks/Data/Empty.hs
--- a/src/HaskellWorks/Data/Empty.hs
+++ b/src/HaskellWorks/Data/Empty.hs
@@ -7,14 +7,16 @@
     ( Empty(..)
     ) where
 
-import qualified Data.ByteString               as BS
-import           Data.Int
-import qualified Data.Vector                   as DV
-import qualified Data.Vector.Storable          as DVS
-import           Data.Word
-import           HaskellWorks.Data.Container
+import Data.Int
+import Data.Word
+import HaskellWorks.Data.Container
 
+import qualified Data.ByteString      as BS
+import qualified Data.Vector          as DV
+import qualified Data.Vector.Storable as DVS
+
 class Container a => Empty a where
+  -- | Empty container
   empty :: a
 
 instance Empty [a] where
diff --git a/src/HaskellWorks/Data/Filter.hs b/src/HaskellWorks/Data/Filter.hs
--- a/src/HaskellWorks/Data/Filter.hs
+++ b/src/HaskellWorks/Data/Filter.hs
@@ -15,8 +15,8 @@
 import           Data.Word
 import           HaskellWorks.Data.Container
 
--- | Class of values that support vector like operations
 class Container v => Filter v where
+  -- | Filter the element of a container with the given predicate
   filter :: (Elem v -> Bool) -> v -> v
 
 instance Filter String where
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,16 +1,16 @@
-{-# LANGUAGE FlexibleInstances  #-}
-{-# LANGUAGE InstanceSigs       #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE InstanceSigs      #-}
 
 module HaskellWorks.Data.FromByteString
   ( FromByteString(..)
   ) where
 
-import           Data.Bits
-import qualified Data.ByteString            as BS
-import qualified Data.Vector.Storable       as DVS
-import           Data.Word
+import Data.Bits
+import Data.Word
 
--- | Class for byte-string-like datastructures
+import qualified Data.ByteString      as BS
+import qualified Data.Vector.Storable as DVS
+
 class FromByteString a where
   -- | Convert a byte string to a value of type @a
   fromByteString :: BS.ByteString -> a
@@ -20,47 +20,47 @@
   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
+            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
+            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)
+                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
+            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)
+                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
+            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)
+                Just (d, ds) -> gen' (n + 8) (w .|. (fromIntegral d `shiftL` fromIntegral n)) ds
+                Nothing      -> Just (w, cs)
diff --git a/src/HaskellWorks/Data/FromForeignRegion.hs b/src/HaskellWorks/Data/FromForeignRegion.hs
--- a/src/HaskellWorks/Data/FromForeignRegion.hs
+++ b/src/HaskellWorks/Data/FromForeignRegion.hs
@@ -1,23 +1,17 @@
-{-# LANGUAGE BangPatterns      #-}
 {-# LANGUAGE FlexibleInstances #-}
 
-module HaskellWorks.Data.FromForeignRegion
-  ( FromForeignRegion(..)
-  , ForeignRegion
-  , mmapFromForeignRegion
-  ) where
+module HaskellWorks.Data.FromForeignRegion where
 
 import Data.Word
 import Foreign.ForeignPtr
+import HaskellWorks.Data.FromByteString
 
 import qualified Data.ByteString          as BS
 import qualified Data.ByteString.Internal as BSI
 import qualified Data.Vector.Storable     as DVS
-import qualified System.IO.MMap           as IO
 
 type ForeignRegion = (ForeignPtr Word8, Int, Int)
 
--- | Class for datastructures that can be created from a foreign region
 class FromForeignRegion a where
   -- | Create a value of type @a from a foreign region.
   fromForeignRegion :: ForeignRegion -> a
@@ -26,19 +20,13 @@
   fromForeignRegion (fptr, offset, size) = BSI.fromForeignPtr (castForeignPtr fptr) offset size
 
 instance FromForeignRegion (DVS.Vector Word8) where
-  fromForeignRegion (fptr, offset, size) = DVS.unsafeFromForeignPtr (castForeignPtr fptr) offset size
+  fromForeignRegion = fromByteString . fromForeignRegion
 
 instance FromForeignRegion (DVS.Vector Word16) where
-  fromForeignRegion (fptr, offset, size) = DVS.unsafeFromForeignPtr (castForeignPtr fptr) offset ((size + 1) `div` 2)
+  fromForeignRegion = fromByteString . fromForeignRegion
 
 instance FromForeignRegion (DVS.Vector Word32) where
-  fromForeignRegion (fptr, offset, size) = DVS.unsafeFromForeignPtr (castForeignPtr fptr) offset ((size + 3) `div` 4)
+  fromForeignRegion = fromByteString . fromForeignRegion
 
 instance FromForeignRegion (DVS.Vector Word64) where
-  fromForeignRegion (fptr, offset, size) = DVS.unsafeFromForeignPtr (castForeignPtr fptr) offset ((size + 7) `div` 8)
-
-mmapFromForeignRegion :: FromForeignRegion a => FilePath -> IO a
-mmapFromForeignRegion filePath = do
-  region <- IO.mmapFileForeignPtr filePath IO.ReadOnly Nothing
-  let !bs = fromForeignRegion region
-  return bs
+  fromForeignRegion = fromByteString . fromForeignRegion
diff --git a/src/HaskellWorks/Data/Generate.hs b/src/HaskellWorks/Data/Generate.hs
--- a/src/HaskellWorks/Data/Generate.hs
+++ b/src/HaskellWorks/Data/Generate.hs
@@ -7,15 +7,17 @@
   , Generate(..)
   ) where
 
-import qualified Data.ByteString               as BS
 import           Data.Int
-import qualified Data.Vector                   as DV
-import qualified Data.Vector.Storable          as DVS
 import           Data.Word
 import           HaskellWorks.Data.Container
 
--- | Class of values that support vector like operations
+import qualified Data.ByteString               as BS
+import qualified Data.Vector                   as DV
+import qualified Data.Vector.Storable          as DVS
+
 class Container v => Generate v where
+  -- | Generate a container of the given size using element produced by the
+  -- provided function.
   generate :: Int -> (Int -> Elem v) -> v
 
 instance Generate String where
diff --git a/src/HaskellWorks/Data/Head.hs b/src/HaskellWorks/Data/Head.hs
--- a/src/HaskellWorks/Data/Head.hs
+++ b/src/HaskellWorks/Data/Head.hs
@@ -7,16 +7,18 @@
     , Head(..)
     ) where
 
-import qualified Data.ByteString               as BS
-import           Data.Int
-import qualified Data.List                     as L
-import qualified Data.Vector                   as DV
-import qualified Data.Vector.Storable          as DVS
-import           Data.Word
-import           HaskellWorks.Data.Container
-import           Prelude hiding (head)
+import Data.Int
+import Data.Word
+import HaskellWorks.Data.Container
+import Prelude                     hiding (head)
 
+import qualified Data.ByteString      as BS
+import qualified Data.List            as L
+import qualified Data.Vector          as DV
+import qualified Data.Vector.Storable as DVS
+
 class Container v => Head v where
+  -- | The first element of the container.
   head :: v -> Elem v
 
 instance Head [a] where
diff --git a/src/HaskellWorks/Data/Length.hs b/src/HaskellWorks/Data/Length.hs
--- a/src/HaskellWorks/Data/Length.hs
+++ b/src/HaskellWorks/Data/Length.hs
@@ -1,23 +1,27 @@
-{-# LANGUAGE FlexibleInstances     #-}
-{-# LANGUAGE TypeFamilies          #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE TypeFamilies      #-}
 
 module HaskellWorks.Data.Length
     ( Container(..)
     , Length(..)
     ) where
 
-import qualified Data.ByteString               as BS
-import           Data.Int
-import qualified Data.List                     as L
-import qualified Data.Vector                   as DV
-import qualified Data.Vector.Storable          as DVS
-import           Data.Word
-import           HaskellWorks.Data.Container
-import           HaskellWorks.Data.Positioning
-import           Prelude hiding (length)
+import Data.Int
+import Data.Word
+import HaskellWorks.Data.Container
+import HaskellWorks.Data.Positioning
+import Prelude                       hiding (length)
 
+import qualified Data.ByteString      as BS
+import qualified Data.List            as L
+import qualified Data.Vector          as DV
+import qualified Data.Vector.Storable as DVS
+
 class Container v => Length v where
+  -- | The length of the container
   length :: v -> Count
+
+  -- | The length of the container given as a position
   end :: v -> Position
   end = fromIntegral . length
   {-# INLINE end #-}
diff --git a/src/HaskellWorks/Data/Naive.hs b/src/HaskellWorks/Data/Naive.hs
--- a/src/HaskellWorks/Data/Naive.hs
+++ b/src/HaskellWorks/Data/Naive.hs
@@ -3,6 +3,8 @@
     , naive
     ) where
 
+-- | Data type providing reference implementations of typeclasses.  Such
+-- implementations may be inefficient.
 newtype Naive a = Naive a deriving (Eq, Show)
 
 naive :: Naive a -> a
diff --git a/src/HaskellWorks/Data/Sign.hs b/src/HaskellWorks/Data/Sign.hs
deleted file mode 100644
--- a/src/HaskellWorks/Data/Sign.hs
+++ /dev/null
@@ -1,62 +0,0 @@
-{-# LANGUAGE TypeFamilies #-}
-
-module HaskellWorks.Data.Sign
-    ( Sign(..)
-    ) where
-
-import Data.Int
-import Data.Word
-
-class Sign a where
-  type SignOf a
-  sign :: a -> SignOf a
-
-instance Sign Word where
-  type SignOf Word = Int
-  sign = fromIntegral
-  {-# INLINE sign #-}
-
-instance Sign Word8 where
-  type SignOf Word8 = Int8
-  sign = fromIntegral
-  {-# INLINE sign #-}
-
-instance Sign Word16 where
-  type SignOf Word16 = Int16
-  sign = fromIntegral
-  {-# INLINE sign #-}
-
-instance Sign Word32 where
-  type SignOf Word32 = Int32
-  sign = fromIntegral
-  {-# INLINE sign #-}
-
-instance Sign Word64 where
-  type SignOf Word64 = Int64
-  sign = fromIntegral
-  {-# INLINE sign #-}
-
-instance Sign Int where
-  type SignOf Int = Int
-  sign = fromIntegral
-  {-# INLINE sign #-}
-
-instance Sign Int8 where
-  type SignOf Int8 = Int8
-  sign = fromIntegral
-  {-# INLINE sign #-}
-
-instance Sign Int16 where
-  type SignOf Int16 = Int16
-  sign = fromIntegral
-  {-# INLINE sign #-}
-
-instance Sign Int32 where
-  type SignOf Int32 = Int32
-  sign = fromIntegral
-  {-# INLINE sign #-}
-
-instance Sign Int64 where
-  type SignOf Int64 = Int64
-  sign = fromIntegral
-  {-# INLINE sign #-}
diff --git a/src/HaskellWorks/Data/Snoc.hs b/src/HaskellWorks/Data/Snoc.hs
deleted file mode 100644
--- a/src/HaskellWorks/Data/Snoc.hs
+++ /dev/null
@@ -1,93 +0,0 @@
-{-# LANGUAGE FlexibleInstances     #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies          #-}
-
-module HaskellWorks.Data.Snoc
-    ( Snoc(..)
-    ) where
-
-import qualified Data.ByteString               as BS
-import           Data.Int
-import qualified Data.Vector                   as DV
-import qualified Data.Vector.Storable          as DVS
-import           Data.Word
-import           HaskellWorks.Data.Container
-
-class Container v => Snoc v where
-  snoc :: v -> Elem v -> v
-
-instance Snoc [a] where
-  snoc v a = v ++ [a]
-  {-# INLINE snoc #-}
-
-instance Snoc BS.ByteString where
-  snoc = BS.snoc
-  {-# INLINE snoc #-}
-
-instance Snoc (DV.Vector Word8) where
-  snoc = DV.snoc
-  {-# INLINE snoc #-}
-
-instance Snoc (DV.Vector Word16) where
-  snoc = DV.snoc
-  {-# INLINE snoc #-}
-
-instance Snoc (DV.Vector Word32) where
-  snoc = DV.snoc
-  {-# INLINE snoc #-}
-
-instance Snoc (DV.Vector Word64) where
-  snoc = DV.snoc
-  {-# INLINE snoc #-}
-
-instance Snoc (DVS.Vector Word8) where
-  snoc = DVS.snoc
-  {-# INLINE snoc #-}
-
-instance Snoc (DVS.Vector Word16) where
-  snoc = DVS.snoc
-  {-# INLINE snoc #-}
-
-instance Snoc (DVS.Vector Word32) where
-  snoc = DVS.snoc
-  {-# INLINE snoc #-}
-
-instance Snoc (DVS.Vector Word64) where
-  snoc = DVS.snoc
-  {-# INLINE snoc #-}
-
-instance Snoc (DV.Vector Int8) where
-  snoc = DV.snoc
-  {-# INLINE snoc #-}
-
-instance Snoc (DV.Vector Int16) where
-  snoc = DV.snoc
-  {-# INLINE snoc #-}
-
-instance Snoc (DV.Vector Int32) where
-  snoc = DV.snoc
-  {-# INLINE snoc #-}
-
-instance Snoc (DV.Vector Int64) where
-  snoc = DV.snoc
-  {-# INLINE snoc #-}
-
-instance Snoc (DVS.Vector Int8) where
-  snoc = DVS.snoc
-  {-# INLINE snoc #-}
-
-instance Snoc (DVS.Vector Int16) where
-  snoc = DVS.snoc
-  {-# INLINE snoc #-}
-
-instance Snoc (DVS.Vector Int32) where
-  snoc = DVS.snoc
-  {-# INLINE snoc #-}
-
-instance Snoc (DVS.Vector Int64) where
-  snoc = DVS.snoc
-  {-# INLINE snoc #-}
-
-instance Snoc (DVS.Vector Int) where
-  snoc = DVS.snoc
-  {-# INLINE snoc #-}
diff --git a/src/HaskellWorks/Data/Take.hs b/src/HaskellWorks/Data/Take.hs
--- a/src/HaskellWorks/Data/Take.hs
+++ b/src/HaskellWorks/Data/Take.hs
@@ -7,16 +7,18 @@
     , Take(..)
     ) where
 
-import qualified Data.ByteString               as BS
-import           Data.Int
-import qualified Data.List                     as L
-import qualified Data.Vector                   as DV
-import qualified Data.Vector.Storable          as DVS
-import           Data.Word
-import           HaskellWorks.Data.Container
-import           HaskellWorks.Data.Positioning
+import Data.Int
+import Data.Word
+import HaskellWorks.Data.Container
+import HaskellWorks.Data.Positioning
 
+import qualified Data.ByteString      as BS
+import qualified Data.List            as L
+import qualified Data.Vector          as DV
+import qualified Data.Vector.Storable as DVS
+
 class Container v => Take v where
+  -- | Take the first n elements from a container
   take :: Count -> v -> v
 
 instance Take [a] where
diff --git a/src/HaskellWorks/Data/TreeCursor.hs b/src/HaskellWorks/Data/TreeCursor.hs
--- a/src/HaskellWorks/Data/TreeCursor.hs
+++ b/src/HaskellWorks/Data/TreeCursor.hs
@@ -1,13 +1,8 @@
--- |
--- Copyright: 2016 John Ky
--- License: MIT
---
--- Tree Cursor
 module HaskellWorks.Data.TreeCursor
     ( TreeCursor(..)
     ) where
 
-import           HaskellWorks.Data.Positioning
+import HaskellWorks.Data.Positioning
 
 class TreeCursor k where
   firstChild  :: k -> Maybe k
diff --git a/src/HaskellWorks/Data/Uncons.hs b/src/HaskellWorks/Data/Uncons.hs
--- a/src/HaskellWorks/Data/Uncons.hs
+++ b/src/HaskellWorks/Data/Uncons.hs
@@ -7,23 +7,25 @@
     , Uncons(..)
     ) where
 
-import qualified Data.ByteString               as BS
-import           Data.Int
-import           Data.Maybe
-import qualified Data.Vector                   as DV
-import qualified Data.Vector.Storable          as DVS
-import           Data.Word
-import           HaskellWorks.Data.Container
-import           HaskellWorks.Data.Drop
-import           Prelude hiding (drop)
+import Data.Int
+import Data.Maybe
+import Data.Word
+import HaskellWorks.Data.Container
+import HaskellWorks.Data.Drop
+import Prelude                     hiding (drop)
 
+import qualified Data.ByteString      as BS
+import qualified Data.Vector          as DV
+import qualified Data.Vector.Storable as DVS
+
 class Drop v => Uncons v where
+  -- | Uncons the head from the container
   uncons :: v -> Maybe (Elem v, v)
 
 instance Uncons String where
   uncons s = case s of
-    (x:xs)  -> Just (x, xs)
-    _       -> Nothing
+    (x:xs) -> Just (x, xs)
+    _      -> Nothing
   {-# INLINE uncons   #-}
 
 instance Uncons BS.ByteString where
diff --git a/src/HaskellWorks/Data/Unsign.hs b/src/HaskellWorks/Data/Unsign.hs
--- a/src/HaskellWorks/Data/Unsign.hs
+++ b/src/HaskellWorks/Data/Unsign.hs
@@ -8,7 +8,10 @@
 import Data.Word
 
 class Unsign a where
+  -- | The correspond unsigned version of a type
   type UnsignOf a
+
+  -- | Convert to an unsigned type
   unsign :: a -> UnsignOf a
 
 instance Unsign Int where
diff --git a/src/HaskellWorks/Data/Vector/BoxedVectorLike.hs b/src/HaskellWorks/Data/Vector/BoxedVectorLike.hs
deleted file mode 100644
--- a/src/HaskellWorks/Data/Vector/BoxedVectorLike.hs
+++ /dev/null
@@ -1,58 +0,0 @@
-{-# LANGUAGE AllowAmbiguousTypes   #-}
-{-# LANGUAGE FlexibleInstances     #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-
-module HaskellWorks.Data.Vector.BoxedVectorLike
-  ( BoxedVectorLike(..)
-  ) where
-
-import qualified Data.Vector      as DV
-import           Data.Word
-import           Foreign.Storable
-
--- | Class of values that support boxed vector like operations
-class BoxedVectorLike v e where
-  bImap :: (Int -> a -> b) -> v a -> v b
-  bMap :: (a -> b) -> v a -> v b
-  bUnfoldr :: (Storable a) => (b -> Maybe (a, b)) -> b -> v a
-  bUnfoldrN :: (Storable a) => Int -> (b -> Maybe (a, b)) -> b -> v a
-
-instance BoxedVectorLike DV.Vector Word8 where
-  bImap = DV.imap
-  bMap = DV.map
-  bUnfoldr = DV.unfoldr
-  bUnfoldrN = DV.unfoldrN
-  {-# INLINE bImap     #-}
-  {-# INLINE bMap      #-}
-  {-# INLINE bUnfoldr  #-}
-  {-# INLINE bUnfoldrN #-}
-
-instance BoxedVectorLike DV.Vector Word16 where
-  bImap = DV.imap
-  bMap = DV.map
-  bUnfoldr = DV.unfoldr
-  bUnfoldrN = DV.unfoldrN
-  {-# INLINE bImap     #-}
-  {-# INLINE bMap      #-}
-  {-# INLINE bUnfoldr  #-}
-  {-# INLINE bUnfoldrN #-}
-
-instance BoxedVectorLike DV.Vector Word32 where
-  bImap = DV.imap
-  bMap = DV.map
-  bUnfoldr = DV.unfoldr
-  bUnfoldrN = DV.unfoldrN
-  {-# INLINE bImap     #-}
-  {-# INLINE bMap      #-}
-  {-# INLINE bUnfoldr  #-}
-  {-# INLINE bUnfoldrN #-}
-
-instance BoxedVectorLike DV.Vector Word64 where
-  bImap = DV.imap
-  bMap = DV.map
-  bUnfoldr = DV.unfoldr
-  bUnfoldrN = DV.unfoldrN
-  {-# INLINE bImap     #-}
-  {-# INLINE bMap      #-}
-  {-# INLINE bUnfoldr  #-}
-  {-# INLINE bUnfoldrN #-}
diff --git a/src/HaskellWorks/Data/Vector/StorableVectorLike.hs b/src/HaskellWorks/Data/Vector/StorableVectorLike.hs
deleted file mode 100644
--- a/src/HaskellWorks/Data/Vector/StorableVectorLike.hs
+++ /dev/null
@@ -1,58 +0,0 @@
-{-# LANGUAGE AllowAmbiguousTypes   #-}
-{-# LANGUAGE FlexibleInstances     #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-
-module HaskellWorks.Data.Vector.StorableVectorLike
-  ( StorableVectorLike(..)
-  ) where
-
-import qualified Data.Vector.Storable as DVS
-import           Data.Word
-import           Foreign.Storable
-
--- | Class of values that support storable vector like operations
-class StorableVectorLike v e where
-  sImap :: (Storable a, Storable b) => (Int -> a -> b) -> v a -> v b
-  sMap :: (Storable a, Storable b) => (a -> b) -> v a -> v b
-  sUnfoldr :: (Storable a) => (b -> Maybe (a, b)) -> b -> v a
-  sUnfoldrN :: (Storable a) => Int -> (b -> Maybe (a, b)) -> b -> v a
-
-instance StorableVectorLike DVS.Vector Word8 where
-  sImap = DVS.imap
-  sMap = DVS.map
-  sUnfoldr = DVS.unfoldr
-  sUnfoldrN = DVS.unfoldrN
-  {-# INLINABLE sImap     #-}
-  {-# INLINABLE sMap      #-}
-  {-# INLINABLE sUnfoldr  #-}
-  {-# INLINABLE sUnfoldrN #-}
-
-instance StorableVectorLike DVS.Vector Word16 where
-  sImap = DVS.imap
-  sMap = DVS.map
-  sUnfoldr = DVS.unfoldr
-  sUnfoldrN = DVS.unfoldrN
-  {-# INLINABLE sImap     #-}
-  {-# INLINABLE sMap      #-}
-  {-# INLINABLE sUnfoldr  #-}
-  {-# INLINABLE sUnfoldrN #-}
-
-instance StorableVectorLike DVS.Vector Word32 where
-  sImap = DVS.imap
-  sMap = DVS.map
-  sUnfoldr = DVS.unfoldr
-  sUnfoldrN = DVS.unfoldrN
-  {-# INLINABLE sImap     #-}
-  {-# INLINABLE sMap      #-}
-  {-# INLINABLE sUnfoldr  #-}
-  {-# INLINABLE sUnfoldrN #-}
-
-instance StorableVectorLike DVS.Vector Word64 where
-  sImap = DVS.imap
-  sMap = DVS.map
-  sUnfoldr = DVS.unfoldr
-  sUnfoldrN = DVS.unfoldrN
-  {-# INLINABLE sImap     #-}
-  {-# INLINABLE sMap      #-}
-  {-# INLINABLE sUnfoldr  #-}
-  {-# INLINABLE sUnfoldrN #-}
diff --git a/test/HaskellWorks/Data/FromForeignRegionSpec.hs b/test/HaskellWorks/Data/FromForeignRegionSpec.hs
deleted file mode 100644
--- a/test/HaskellWorks/Data/FromForeignRegionSpec.hs
+++ /dev/null
@@ -1,40 +0,0 @@
-{-# OPTIONS_GHC -fno-warn-incomplete-patterns #-}
-{-# LANGUAGE BangPatterns               #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE OverloadedLists            #-}
-{-# LANGUAGE ScopedTypeVariables        #-}
-{-# LANGUAGE StandaloneDeriving         #-}
-
-module HaskellWorks.Data.FromForeignRegionSpec (spec) where
-
-import Control.Monad.IO.Class
-import Data.Word
-import Data.Word
-import HaskellWorks.Data.FromByteString
-import HaskellWorks.Data.FromForeignRegion
-import HaskellWorks.Hspec.Hedgehog
-import Hedgehog
-import Hedgehog.Internal.Gen
-import Test.Hspec
-
-import qualified Data.ByteString                     as BS
-import qualified Data.Vector.Storable                as DVS
-import qualified HaskellWorks.Data.FromForeignRegion as IO
-import qualified Hedgehog.Gen                        as G
-import qualified Hedgehog.Range                      as R
-import qualified System.Directory                    as IO
-import qualified System.IO                           as IO
-
-{-# ANN module ("HLint: Ignore Redundant do" :: String) #-}
-
-spec :: Spec
-spec = describe "HaskellWorks.Data.FromForeignRegionSpec" $ do
-  it "Be able to load file into Vector" $ requireProperty $ do
-    ws <- forAll $ G.list (R.linear 0 (1024 * 16)) (G.word8 R.constantBounded)
-    liftIO $ IO.createDirectoryIfMissing True "./tmp"
-    (fp, h) <- liftIO $ IO.openBinaryTempFile "./tmp" "property-test-.txt"
-    liftIO $ BS.hPut h (BS.pack ws)
-    liftIO $ IO.hClose h
-    !(_ :: DVS.Vector Word64) <- liftIO $ IO.mmapFromForeignRegion fp
-    liftIO $ IO.removeFile fp
-    True === True