diff --git a/bench/Main.hs b/bench/Main.hs
--- a/bench/Main.hs
+++ b/bench/Main.hs
@@ -4,7 +4,6 @@
 module Main where
 
 import Criterion.Main
-import Data.Monoid
 import Data.Word
 import Foreign
 import HaskellWorks.Data.FromForeignRegion
diff --git a/hw-prim.cabal b/hw-prim.cabal
--- a/hw-prim.cabal
+++ b/hw-prim.cabal
@@ -2,10 +2,10 @@
 --
 -- see: https://github.com/sol/hpack
 --
--- hash: e13d367ccce10eb041455fee1fba2f253b49799a2caf12f1c21cdc05f3fc5f84
+-- hash: 7744d3568e3de865cd0c785d38ad2c2519a9b44316d31e88a922d3802c35aa05
 
 name:           hw-prim
-version:        0.5.0.2
+version:        0.5.0.3
 synopsis:       Primitive functions and data types
 description:    Please see README.md
 category:       Data
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,24 +1,27 @@
-{-# LANGUAGE FlexibleInstances   #-}
+{-# LANGUAGE FlexibleInstances     #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeFamilies        #-}
+{-# LANGUAGE TypeFamilies          #-}
 
 module HaskellWorks.Data.AtIndex
     ( Container(..)
     , AtIndex(..)
     , Length(..)
+    , atIndexOr
     ) 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
+import qualified HaskellWorks.Data.Length as HW
+
 class Length v => AtIndex v where
-  (!!!)   :: v -> Position -> Elem v
-  atIndex :: v -> Position -> Elem v
+  (!!!)     :: v -> Position -> Elem v
+  atIndex   :: v -> Position -> Elem v
 
 instance AtIndex [a] where
   (!!!)   v i = v !! fromIntegral i
@@ -133,3 +136,7 @@
   atIndex v i = DVS.unsafeIndex v (fromIntegral i)
   {-# INLINE (!!!)   #-}
   {-# INLINE atIndex #-}
+
+atIndexOr :: AtIndex v => Elem v -> v -> Position -> Elem v
+atIndexOr d v p = if p < fromIntegral (HW.length v) then v !!! p else d
+{-# INLINE atIndexOr #-}
diff --git a/src/HaskellWorks/Data/Char/IsChar.hs b/src/HaskellWorks/Data/Char/IsChar.hs
--- a/src/HaskellWorks/Data/Char/IsChar.hs
+++ b/src/HaskellWorks/Data/Char/IsChar.hs
@@ -2,8 +2,9 @@
     ( IsChar(..)
     ) where
 
+import Data.Word
+
 import qualified Data.ByteString.Internal as BI
-import           Data.Word
 
 class IsChar c where
   toChar :: c -> Char
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,12 +6,13 @@
   ( 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
+
+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 of values that support vector like operations
 class Concat v 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,11 +6,12 @@
     ( 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
   type Elem a
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,15 +7,16 @@
     , 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 :: Count -> v -> v
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,12 +7,13 @@
     ( 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 :: a
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
@@ -7,13 +7,14 @@
   , Filter(..)
   ) 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 Data.Int
+import Data.Word
+import HaskellWorks.Data.Container
+
+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 of values that support vector like operations
 class Container v => Filter v 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,15 +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
 
+import qualified Data.ByteString      as BS
+import qualified Data.Vector.Storable as DVS
+
 -- | Class for byte-string-like datastructures
 class FromByteString a where
   -- | Convert a byte string to a value of type @a
@@ -20,47 +21,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/Generate.hs b/src/HaskellWorks/Data/Generate.hs
--- a/src/HaskellWorks/Data/Generate.hs
+++ b/src/HaskellWorks/Data/Generate.hs
@@ -7,12 +7,13 @@
   , 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
+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 of values that support vector like operations
 class Container v => Generate v 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,14 +7,15 @@
     , 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
   head :: v -> Elem v
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,20 +1,21 @@
-{-# 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
   length :: v -> Count
diff --git a/src/HaskellWorks/Data/Positioning.hs b/src/HaskellWorks/Data/Positioning.hs
--- a/src/HaskellWorks/Data/Positioning.hs
+++ b/src/HaskellWorks/Data/Positioning.hs
@@ -9,8 +9,8 @@
   , toPosition
   ) where
 
-import           Data.Int
-import           Data.Word
+import Data.Int
+import Data.Word
 
 -- | A value representing a count
 type Count = Word64
diff --git a/src/HaskellWorks/Data/Search.hs b/src/HaskellWorks/Data/Search.hs
--- a/src/HaskellWorks/Data/Search.hs
+++ b/src/HaskellWorks/Data/Search.hs
@@ -1,6 +1,6 @@
 module HaskellWorks.Data.Search
-    ( binarySearch
-    ) where
+  ( binarySearch
+  ) where
 
 -- | Perform a binary search in the domain of function @f, bounded by the values @p and @q
 -- to find the least value @v such that: @w <= (f v)
diff --git a/src/HaskellWorks/Data/Snoc.hs b/src/HaskellWorks/Data/Snoc.hs
--- a/src/HaskellWorks/Data/Snoc.hs
+++ b/src/HaskellWorks/Data/Snoc.hs
@@ -6,12 +6,13 @@
     ( 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
+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 v => Snoc v where
   snoc :: v -> Elem v -> v
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,14 +7,15 @@
     , 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 :: Count -> v -> v
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
@@ -7,7 +7,7 @@
     ( 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,24 @@
     , 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 :: 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/Vector/AsVector64.hs b/src/HaskellWorks/Data/Vector/AsVector64.hs
--- a/src/HaskellWorks/Data/Vector/AsVector64.hs
+++ b/src/HaskellWorks/Data/Vector/AsVector64.hs
@@ -3,8 +3,9 @@
   ( AsVector64(..)
   ) where
 
+import Data.Word
+
 import qualified Data.Vector.Storable as DVS
-import           Data.Word
 
 class AsVector64 a where
   asVector64 :: a -> DVS.Vector Word64
diff --git a/src/HaskellWorks/Data/Vector/BoxedVectorLike.hs b/src/HaskellWorks/Data/Vector/BoxedVectorLike.hs
--- a/src/HaskellWorks/Data/Vector/BoxedVectorLike.hs
+++ b/src/HaskellWorks/Data/Vector/BoxedVectorLike.hs
@@ -6,9 +6,10 @@
   ( BoxedVectorLike(..)
   ) where
 
-import qualified Data.Vector      as DV
-import           Data.Word
-import           Foreign.Storable
+import Data.Word
+import Foreign.Storable
+
+import qualified Data.Vector as DV
 
 -- | Class of values that support boxed vector like operations
 class BoxedVectorLike v e where
diff --git a/src/HaskellWorks/Data/Vector/StorableVectorLike.hs b/src/HaskellWorks/Data/Vector/StorableVectorLike.hs
--- a/src/HaskellWorks/Data/Vector/StorableVectorLike.hs
+++ b/src/HaskellWorks/Data/Vector/StorableVectorLike.hs
@@ -6,9 +6,10 @@
   ( StorableVectorLike(..)
   ) where
 
+import Data.Word
+import Foreign.Storable
+
 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
diff --git a/test/HaskellWorks/Data/FromByteStringSpec.hs b/test/HaskellWorks/Data/FromByteStringSpec.hs
--- a/test/HaskellWorks/Data/FromByteStringSpec.hs
+++ b/test/HaskellWorks/Data/FromByteStringSpec.hs
@@ -1,14 +1,15 @@
 {-# OPTIONS_GHC -fno-warn-incomplete-patterns #-}
-{-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE OverloadedLists     #-}
+{-# LANGUAGE ScopedTypeVariables #-}
 
 module HaskellWorks.Data.FromByteStringSpec (spec) where
 
-import qualified Data.ByteString                  as BS
-import qualified Data.Vector.Storable             as DVS
-import           Data.Word
-import           HaskellWorks.Data.FromByteString
-import           Test.Hspec
+import Data.Word
+import HaskellWorks.Data.FromByteString
+import Test.Hspec
+
+import qualified Data.ByteString      as BS
+import qualified Data.Vector.Storable as DVS
 
 {-# ANN module ("HLint: Ignore Redundant do" :: String) #-}
 
diff --git a/test/HaskellWorks/Data/FromForeignRegionSpec.hs b/test/HaskellWorks/Data/FromForeignRegionSpec.hs
--- a/test/HaskellWorks/Data/FromForeignRegionSpec.hs
+++ b/test/HaskellWorks/Data/FromForeignRegionSpec.hs
@@ -9,12 +9,8 @@
 
 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
diff --git a/test/HaskellWorks/Data/SearchSpec.hs b/test/HaskellWorks/Data/SearchSpec.hs
--- a/test/HaskellWorks/Data/SearchSpec.hs
+++ b/test/HaskellWorks/Data/SearchSpec.hs
@@ -2,8 +2,8 @@
 
 module HaskellWorks.Data.SearchSpec (spec) where
 
-import           HaskellWorks.Data.Search
-import           Test.Hspec
+import HaskellWorks.Data.Search
+import Test.Hspec
 
 {-# ANN module ("HLint: Ignore Redundant do" :: String) #-}