diff --git a/hw-json.cabal b/hw-json.cabal
--- a/hw-json.cabal
+++ b/hw-json.cabal
@@ -1,5 +1,5 @@
 name:                   hw-json
-version:                0.5.0.0
+version:                0.6.0.0
 synopsis:               Memory efficient JSON parser
 description:            Please see README.md
 homepage:               http://github.com/haskell-works/hw-json#readme
diff --git a/src/HaskellWorks/Data/Json.hs b/src/HaskellWorks/Data/Json.hs
--- a/src/HaskellWorks/Data/Json.hs
+++ b/src/HaskellWorks/Data/Json.hs
@@ -7,7 +7,7 @@
     ( module X
     ) where
 
-import           HaskellWorks.Data.Json.Succinct  as X
-import           HaskellWorks.Data.Json.Token     as X
-import           HaskellWorks.Data.Json.Type      as X
-import           HaskellWorks.Data.Json.Value     as X
+import HaskellWorks.Data.Json.Succinct  as X
+import HaskellWorks.Data.Json.Token     as X
+import HaskellWorks.Data.Json.Type      as X
+import HaskellWorks.Data.Json.Value     as X
diff --git a/src/HaskellWorks/Data/Json/Conduit.hs b/src/HaskellWorks/Data/Json/Conduit.hs
--- a/src/HaskellWorks/Data/Json/Conduit.hs
+++ b/src/HaskellWorks/Data/Json/Conduit.hs
@@ -10,17 +10,18 @@
   , interestingWord8s
   ) where
 
-import           Control.Monad
-import           Data.Array.Unboxed                   as A
-import qualified Data.Bits                            as BITS
-import           Data.ByteString                      as BS
-import           Data.Conduit
-import           Data.Int
-import           Data.Word
-import           Data.Word8
-import           HaskellWorks.Data.Bits.BitWise
-import           Prelude                              as P
+import Control.Monad
+import Data.Array.Unboxed             as A
+import Data.ByteString                as BS
+import Data.Conduit
+import Data.Int
+import Data.Word
+import Data.Word8
+import HaskellWorks.Data.Bits.BitWise
+import Prelude                        as P
 
+import qualified Data.Bits as BITS
+
 interestingWord8s :: A.UArray Word8 Word8
 interestingWord8s = A.array (0, 255) [
   (w, if w == _bracketleft || w == _braceleft || w == _parenleft || w == _t || w == _f || w == _n || w == _1
@@ -79,7 +80,7 @@
       d | d == _f             -> yield True >> yield False
       d | d == _1             -> yield True >> yield False
       d | d == _n             -> yield True >> yield False
-      _                       -> return ()
+      _ -> return ()
     blankedJsonToBalancedParens' cs
   Nothing -> return ()
 
@@ -125,10 +126,10 @@
         gen (Just False , bs) = Just (0x00, (Nothing, bs))
         gen (Nothing    , bs) = case BS.uncons bs of
           Just (c, cs) -> case balancedParensOf c of
-            MiniN   -> gen         (Nothing    , cs)
-            MiniT   -> Just (0xFF, (Nothing    , cs))
-            MiniF   -> Just (0x00, (Nothing    , cs))
-            MiniTF  -> Just (0xFF, (Just False , cs))
+            MiniN  -> gen         (Nothing    , cs)
+            MiniT  -> Just (0xFF, (Nothing    , cs))
+            MiniF  -> Just (0x00, (Nothing    , cs))
+            MiniTF -> Just (0xFF, (Just False , cs))
           Nothing   -> Nothing
 
 data MiniBP = MiniN | MiniT | MiniF | MiniTF
@@ -145,7 +146,7 @@
     d | d == _f             -> MiniTF
     d | d == _1             -> MiniTF
     d | d == _n             -> MiniTF
-    _                       -> MiniN
+    _ -> MiniN
 
 yieldBitsOfWord8 :: Monad m => Word8 -> Conduit BS.ByteString m Bool
 yieldBitsOfWord8 w = do
diff --git a/src/HaskellWorks/Data/Json/Conduit/Blank.hs b/src/HaskellWorks/Data/Json/Conduit/Blank.hs
--- a/src/HaskellWorks/Data/Json/Conduit/Blank.hs
+++ b/src/HaskellWorks/Data/Json/Conduit/Blank.hs
@@ -1,18 +1,17 @@
 {-# LANGUAGE BangPatterns      #-}
-{-# LANGUAGE OverloadedStrings #-}
 
 module HaskellWorks.Data.Json.Conduit.Blank
   ( blankJson
   ) where
 
-import           Control.Monad
-import           Control.Monad.Trans.Resource         (MonadThrow)
-import           Data.ByteString                      as BS
-import           Data.Conduit
-import           Data.Word
-import           Data.Word8
-import           HaskellWorks.Data.Json.Conduit.Words
-import           Prelude                              as P
+import Control.Monad
+import Control.Monad.Trans.Resource         (MonadThrow)
+import Data.ByteString                      as BS
+import Data.Conduit
+import Data.Word
+import Data.Word8
+import HaskellWorks.Data.Json.Conduit.Words
+import Prelude                              as P
 
 data BlankState
   = Escaped
diff --git a/src/HaskellWorks/Data/Json/Conduit/Words.hs b/src/HaskellWorks/Data/Json/Conduit/Words.hs
--- a/src/HaskellWorks/Data/Json/Conduit/Words.hs
+++ b/src/HaskellWorks/Data/Json/Conduit/Words.hs
@@ -1,7 +1,7 @@
 module HaskellWorks.Data.Json.Conduit.Words where
 
-import           Data.Word
-import           Data.Word8
+import Data.Word
+import Data.Word8
 
 isLeadingDigit :: Word8 -> Bool
 isLeadingDigit w = w == _hyphen || (w >= _0 && w <= _9)
diff --git a/src/HaskellWorks/Data/Json/DecodeError.hs b/src/HaskellWorks/Data/Json/DecodeError.hs
--- a/src/HaskellWorks/Data/Json/DecodeError.hs
+++ b/src/HaskellWorks/Data/Json/DecodeError.hs
@@ -1,5 +1,3 @@
-module HaskellWorks.Data.Json.DecodeError
-  ( DecodeError(..)
-  ) where
+module HaskellWorks.Data.Json.DecodeError where
 
 newtype DecodeError = DecodeError String deriving (Eq, Show)
diff --git a/src/HaskellWorks/Data/Json/LightJson.hs b/src/HaskellWorks/Data/Json/LightJson.hs
--- a/src/HaskellWorks/Data/Json/LightJson.hs
+++ b/src/HaskellWorks/Data/Json/LightJson.hs
@@ -1,43 +1,44 @@
-{-# LANGUAGE BangPatterns               #-}
-{-# LANGUAGE FlexibleContexts           #-}
-{-# LANGUAGE FlexibleInstances          #-}
-{-# LANGUAGE InstanceSigs               #-}
-{-# LANGUAGE MultiParamTypeClasses      #-}
-{-# LANGUAGE OverloadedStrings          #-}
-{-# LANGUAGE ScopedTypeVariables        #-}
+{-# LANGUAGE BangPatterns          #-}
+{-# LANGUAGE FlexibleContexts      #-}
+{-# LANGUAGE FlexibleInstances     #-}
+{-# LANGUAGE InstanceSigs          #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE OverloadedStrings     #-}
+{-# LANGUAGE ScopedTypeVariables   #-}
 
 module HaskellWorks.Data.Json.LightJson where
 
-import           Control.Arrow
-import qualified Data.Attoparsec.ByteString.Char8           as ABC
-import qualified Data.ByteString.Char8                      as BSC
-import qualified Data.ByteString                            as BS
-import qualified Data.DList                                 as DL
-import qualified Data.List                                  as L
-import           Data.String
-import           Data.Word
-import           Data.Word8
-import           HaskellWorks.Data.AtLeastSize
-import           HaskellWorks.Data.Bits.BitWise
-import qualified HaskellWorks.Data.BalancedParens           as BP
-import           HaskellWorks.Data.Drop
-import           HaskellWorks.Data.Entry
-import           HaskellWorks.Data.Json.CharLike
-import           HaskellWorks.Data.Json.Conduit.Words
-import           HaskellWorks.Data.Json.Succinct
-import           HaskellWorks.Data.Micro
-import           HaskellWorks.Data.Mini
-import           HaskellWorks.Data.MQuery
-import           HaskellWorks.Data.Positioning
-import           HaskellWorks.Data.RankSelect.Base.Rank0
-import           HaskellWorks.Data.RankSelect.Base.Rank1
-import           HaskellWorks.Data.RankSelect.Base.Select1
-import           HaskellWorks.Data.Row
-import           HaskellWorks.Data.TreeCursor
-import           HaskellWorks.Data.Uncons
-import           Prelude hiding (drop)
-import           Text.PrettyPrint.ANSI.Leijen
+import Control.Arrow
+import Data.String
+import Data.Word
+import Data.Word8
+import HaskellWorks.Data.AtLeastSize
+import HaskellWorks.Data.Bits.BitWise
+import HaskellWorks.Data.Drop
+import HaskellWorks.Data.Entry
+import HaskellWorks.Data.Json.CharLike
+import HaskellWorks.Data.Json.Conduit.Words
+import HaskellWorks.Data.Json.Succinct
+import HaskellWorks.Data.Micro
+import HaskellWorks.Data.Mini
+import HaskellWorks.Data.MQuery
+import HaskellWorks.Data.Positioning
+import HaskellWorks.Data.RankSelect.Base.Rank0
+import HaskellWorks.Data.RankSelect.Base.Rank1
+import HaskellWorks.Data.RankSelect.Base.Select1
+import HaskellWorks.Data.Row
+import HaskellWorks.Data.TreeCursor
+import HaskellWorks.Data.Uncons
+import Prelude                                   hiding (drop)
+import Text.PrettyPrint.ANSI.Leijen
 
+import qualified Data.Attoparsec.ByteString.Char8 as ABC
+import qualified Data.ByteString                  as BS
+import qualified Data.ByteString.Char8            as BSC
+import qualified Data.DList                       as DL
+import qualified Data.List                        as L
+import qualified HaskellWorks.Data.BalancedParens as BP
+
 data LightJson c
   = LightJsonString String
   | LightJsonNumber BS.ByteString
@@ -49,11 +50,11 @@
   deriving Show
 
 instance Eq (LightJson c) where
-  (==) (LightJsonString a) (LightJsonString b)  = a == b
-  (==) (LightJsonNumber a) (LightJsonNumber b)  = a == b
-  (==) (LightJsonBool   a) (LightJsonBool   b)  = a == b
-  (==)  LightJsonNull       LightJsonNull       = True
-  (==)  _                   _                   = False
+  (==) (LightJsonString a) (LightJsonString b) = a == b
+  (==) (LightJsonNumber a) (LightJsonNumber b) = a == b
+  (==) (LightJsonBool   a) (LightJsonBool   b) = a == b
+  (==)  LightJsonNull       LightJsonNull      = True
+  (==)  _                   _                  = False
 
 -- instance Ord (LightJson c) where
 --   compare (LightJsonString a) (LightJsonString b)  = a `compare` b
@@ -82,33 +83,33 @@
         genString (InJson, cs) = case BS.uncons cs of
           Just (!e, !es) | e == _quotedbl     -> genString            (InString , es)
           -- TODO: Only match whitespace
-          Just (!_, !es)                      -> genString            (InJson   , es)
-          Nothing                             -> Nothing
+          Just (!_, !es) -> genString            (InJson   , es)
+          Nothing        -> Nothing
         genString (InString, ds) = case BS.uncons ds of
           Just (!e, !es) | e == _backslash    -> genString            (Escaped  , es)
           Just (!e, !_ ) | e == _quotedbl     -> Nothing
-          Just (e , !es)                      -> Just (e            , (InString , es))
-          Nothing                             -> Nothing
+          Just (e , !es) -> Just (e            , (InString , es))
+          Nothing        -> Nothing
         genString (Escaped, ds) = case BS.uncons ds of
-          Just (_ , !es)                      -> Just (_period      , (InString , es))
-          Nothing                             -> Nothing
+          Just (_ , !es) -> Just (_period      , (InString , es))
+          Nothing        -> Nothing
         genString (_, _) = Nothing
 
 slurpString :: BS.ByteString -> String
 slurpString bs = L.unfoldr genString (InJson, BSC.unpack bs)
   where genString :: (JsonState, String) -> Maybe (Char, (JsonState, String))
         genString (InJson, ds) = case ds of
-          (e:es)  | e == '"'  -> genString  (InString , es)
-          (_:es)              -> genString  (InJson   , es)
-          _                   -> Nothing
+          (e:es) | e == '"'  -> genString  (InString , es)
+          (_:es) -> genString  (InJson   , es)
+          _      -> Nothing
         genString (InString, ds) = case ds of
           (e:es) | e == '\\'  -> genString  (Escaped  , es)
           (e:_ ) | e == '"'   -> Nothing
-          (e:es)              -> Just (e,   (InString , es))
-          _                   -> Nothing
+          (e:es) -> Just (e,   (InString , es))
+          _      -> Nothing
         genString (Escaped, ds) = case ds of
-          (_:es)              -> Just ('.', (InString , es))
-          _                   -> Nothing
+          (_:es) -> Just ('.', (InString , es))
+          _      -> Nothing
         genString (_, _) = Nothing
 
 slurpNumber :: BS.ByteString -> BS.ByteString
@@ -116,12 +117,12 @@
     where genNumber :: (JsonState, BS.ByteString) -> Maybe (Word8, (JsonState, BS.ByteString))
           genNumber (InJson, cs) = case BS.uncons cs of
             Just (!d, !ds) | isLeadingDigit d   -> Just (d           , (InNumber , ds))
-            Just (!d, !ds)                      -> Just (d           , (InJson   , ds))
-            Nothing -> Nothing
+            Just (!d, !ds) -> Just (d           , (InJson   , ds))
+            Nothing        -> Nothing
           genNumber (InNumber, cs) = case BS.uncons cs of
             Just (!d, !ds) | isTrailingDigit d  -> Just (d           , (InNumber , ds))
             Just (!d, !ds) | d == _quotedbl     -> Just (_parenleft  , (InString , ds))
-            _                                   -> Nothing
+            _              -> Nothing
           genNumber (_, _) = Nothing
 
 instance (BP.BalancedParens w, Rank0 w, Rank1 w, Select1 v, TestBit w) => LightJsonAt (JsonCursor BS.ByteString v w) where
@@ -133,8 +134,8 @@
     Just (!c, _) | isChar_n c         -> LightJsonNull
     Just (!c, _) | isBraceLeft c      -> LightJsonObject (mapValuesFrom   (firstChild k))
     Just (!c, _) | isBracketLeft c    -> LightJsonArray  (arrayValuesFrom (firstChild k))
-    Just _                            -> LightJsonError "Invalid Json Type"
-    Nothing                           -> LightJsonError "End of data"
+    Just _       -> LightJsonError "Invalid Json Type"
+    Nothing      -> LightJsonError "End of data"
     where ik                = interests k
           bpk               = balancedParens k
           p                 = lastPositionOf (select1 ik (rank1 bpk (cursorRank k)))
@@ -223,8 +224,8 @@
 
 entry :: LightJsonAt c => LightJson c -> MQuery (Entry String (LightJson c))
 entry jpv = case jpv of
-  LightJsonObject fs  -> MQuery $ DL.fromList ((uncurry Entry . second lightJsonAt) `map` fs)
-  _                   -> MQuery   DL.empty
+  LightJsonObject fs -> MQuery $ DL.fromList ((uncurry Entry . second lightJsonAt) `map` fs)
+  _                  -> MQuery   DL.empty
 
 asString :: LightJson c -> MQuery String
 asString jpv = case jpv of
@@ -236,9 +237,9 @@
   LightJsonNumber sn  -> case ABC.parse ABC.rational sn of
     ABC.Fail    {}    -> MQuery DL.empty
     ABC.Partial f     -> case f " " of
-      ABC.Fail    {}    -> MQuery DL.empty
-      ABC.Partial _     -> MQuery DL.empty
-      ABC.Done    _ r   -> MQuery (DL.singleton r)
+      ABC.Fail    {}  -> MQuery DL.empty
+      ABC.Partial _   -> MQuery DL.empty
+      ABC.Done    _ r -> MQuery (DL.singleton r)
     ABC.Done    _ r   -> MQuery (DL.singleton r)
   _                   -> MQuery   DL.empty
 
@@ -255,18 +256,18 @@
 
 named :: String -> Entry String (LightJson c) -> MQuery (LightJson c)
 named fieldName (Entry fieldName' jpv) | fieldName == fieldName'  = MQuery $ DL.singleton jpv
-named _         _                                                 = MQuery   DL.empty
+named _         _                      = MQuery   DL.empty
 
 jsonKeys :: LightJson c -> [String]
 jsonKeys jpv = case jpv of
-  LightJsonObject fs  -> fst `map` fs
-  _                   -> []
+  LightJsonObject fs -> fst `map` fs
+  _                  -> []
 
 hasKey :: String -> LightJson c -> Bool
 hasKey fieldName jpv = fieldName `elem` jsonKeys jpv
 
 jsonSize :: LightJson c -> MQuery Integer
 jsonSize jpv = case jpv of
-  LightJsonArray  es  -> MQuery (DL.singleton (fromIntegral (length es)))
-  LightJsonObject es  -> MQuery (DL.singleton (fromIntegral (length es)))
-  _                   -> MQuery (DL.singleton 0)
+  LightJsonArray  es -> MQuery (DL.singleton (fromIntegral (length es)))
+  LightJsonObject es -> MQuery (DL.singleton (fromIntegral (length es)))
+  _                  -> MQuery (DL.singleton 0)
diff --git a/src/HaskellWorks/Data/Json/Load.hs b/src/HaskellWorks/Data/Json/Load.hs
--- a/src/HaskellWorks/Data/Json/Load.hs
+++ b/src/HaskellWorks/Data/Json/Load.hs
@@ -1,6 +1,6 @@
-{-# LANGUAGE BangPatterns               #-}
-{-# LANGUAGE FlexibleInstances          #-}
-{-# LANGUAGE ScopedTypeVariables        #-}
+{-# LANGUAGE BangPatterns        #-}
+{-# LANGUAGE FlexibleInstances   #-}
+{-# LANGUAGE ScopedTypeVariables #-}
 
 module HaskellWorks.Data.Json.Load
   ( indexJson
@@ -41,9 +41,9 @@
 import System.IO
 import System.IO.MMap
 
-import qualified Data.ByteString                                          as BS
-import qualified Data.ByteString.Internal                                 as BSI
-import qualified Data.Vector.Storable                                     as DVS
+import qualified Data.ByteString          as BS
+import qualified Data.ByteString.Internal as BSI
+import qualified Data.Vector.Storable     as DVS
 
 -- | Write out a vector verbatim into an open file handle.
 hPutVector :: forall a. Storable a => Handle -> DVS.Vector a -> IO ()
diff --git a/src/HaskellWorks/Data/Json/LoadCursor.hs b/src/HaskellWorks/Data/Json/LoadCursor.hs
--- a/src/HaskellWorks/Data/Json/LoadCursor.hs
+++ b/src/HaskellWorks/Data/Json/LoadCursor.hs
@@ -1,6 +1,6 @@
-{-# LANGUAGE BangPatterns               #-}
-{-# LANGUAGE FlexibleInstances          #-}
-{-# LANGUAGE ScopedTypeVariables        #-}
+{-# LANGUAGE BangPatterns        #-}
+{-# LANGUAGE FlexibleInstances   #-}
+{-# LANGUAGE ScopedTypeVariables #-}
 
 module HaskellWorks.Data.Json.LoadCursor
   ( indexJsonCursor
@@ -37,9 +37,9 @@
 import System.IO
 import System.IO.MMap
 
-import qualified Data.ByteString                                          as BS
-import qualified Data.ByteString.Internal                                 as BSI
-import qualified Data.Vector.Storable                                     as DVS
+import qualified Data.ByteString          as BS
+import qualified Data.ByteString.Internal as BSI
+import qualified Data.Vector.Storable     as DVS
 
 -- | Write out a vector verbatim into an open file handle.
 hPutVector :: forall a. Storable a => Handle -> DVS.Vector a -> IO ()
diff --git a/src/HaskellWorks/Data/Json/PartialValue.hs b/src/HaskellWorks/Data/Json/PartialValue.hs
--- a/src/HaskellWorks/Data/Json/PartialValue.hs
+++ b/src/HaskellWorks/Data/Json/PartialValue.hs
@@ -4,7 +4,6 @@
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE OverloadedStrings     #-}
 {-# LANGUAGE ScopedTypeVariables   #-}
-{-# LANGUAGE TupleSections         #-}
 
 module HaskellWorks.Data.Json.PartialValue
   ( JsonPartialValue(..)
@@ -21,26 +20,27 @@
   , named
   ) where
 
-import           Control.Arrow
-import qualified Data.Attoparsec.ByteString.Char8             as ABC
-import qualified Data.ByteString                              as BS
-import qualified Data.DList                                   as DL
-import           HaskellWorks.Data.AtLeastSize
-import qualified HaskellWorks.Data.BalancedParens             as BP
-import           HaskellWorks.Data.Bits.BitWise
-import           HaskellWorks.Data.Entry
-import           HaskellWorks.Data.Micro
-import           HaskellWorks.Data.Mini
-import           HaskellWorks.Data.MQuery
-import           HaskellWorks.Data.Json.Succinct.Cursor
-import           HaskellWorks.Data.Json.Succinct.PartialIndex
-import           HaskellWorks.Data.Json.Value.Internal
-import           HaskellWorks.Data.RankSelect.Base.Rank0
-import           HaskellWorks.Data.RankSelect.Base.Rank1
-import           HaskellWorks.Data.RankSelect.Base.Select1
-import           HaskellWorks.Data.Row
-import           Text.PrettyPrint.ANSI.Leijen
+import Control.Arrow
+import HaskellWorks.Data.AtLeastSize
+import HaskellWorks.Data.Bits.BitWise
+import HaskellWorks.Data.Entry
+import HaskellWorks.Data.Json.Succinct.Cursor
+import HaskellWorks.Data.Json.Succinct.PartialIndex
+import HaskellWorks.Data.Json.Value.Internal
+import HaskellWorks.Data.Micro
+import HaskellWorks.Data.Mini
+import HaskellWorks.Data.MQuery
+import HaskellWorks.Data.RankSelect.Base.Rank0
+import HaskellWorks.Data.RankSelect.Base.Rank1
+import HaskellWorks.Data.RankSelect.Base.Select1
+import HaskellWorks.Data.Row
+import Text.PrettyPrint.ANSI.Leijen
 
+import qualified Data.Attoparsec.ByteString.Char8 as ABC
+import qualified Data.ByteString                  as BS
+import qualified Data.DList                       as DL
+import qualified HaskellWorks.Data.BalancedParens as BP
+
 data JsonPartialValue
   = JsonPartialString String
   | JsonPartialNumber Double
@@ -64,15 +64,15 @@
 instance JsonPartialValueAt JsonPartialIndex where
   jsonPartialJsonValueAt i = case i of
     JsonPartialIndexString s  -> case ABC.parse parseJsonString s of
-      ABC.Fail    {}          -> JsonPartialError ("Invalid string: '" ++ show (BS.take 20 s) ++ "...'")
-      ABC.Partial _           -> JsonPartialError "Unexpected end of string"
-      ABC.Done    _ r         -> JsonPartialString r
+      ABC.Fail    {}  -> JsonPartialError ("Invalid string: '" ++ show (BS.take 20 s) ++ "...'")
+      ABC.Partial _   -> JsonPartialError "Unexpected end of string"
+      ABC.Done    _ r -> JsonPartialString r
     JsonPartialIndexNumber s  -> case ABC.parse ABC.rational s of
       ABC.Fail    {}    -> JsonPartialError ("Invalid number: '" ++ show (BS.take 20 s) ++ "...'")
       ABC.Partial f     -> case f " " of
-        ABC.Fail    {}    -> JsonPartialError ("Invalid number: '" ++ show (BS.take 20 s) ++ "...'")
-        ABC.Partial _     -> JsonPartialError "Unexpected end of number"
-        ABC.Done    _ r   -> JsonPartialNumber r
+        ABC.Fail    {}  -> JsonPartialError ("Invalid number: '" ++ show (BS.take 20 s) ++ "...'")
+        ABC.Partial _   -> JsonPartialError "Unexpected end of number"
+        ABC.Done    _ r -> JsonPartialNumber r
       ABC.Done    _ r   -> JsonPartialNumber r
     JsonPartialIndexObject  fs -> JsonPartialObject (map ((jsonPartialValueString . parseString) *** jsonPartialJsonValueAt) fs)
     JsonPartialIndexArray   es -> JsonPartialArray (map jsonPartialJsonValueAt es)
@@ -152,8 +152,8 @@
   pretty (MQuery das) = pretty (Row 120 das)
 
 hasKV :: String -> JsonPartialValue -> JsonPartialValue -> MQuery JsonPartialValue
-hasKV k v (JsonPartialObject xs)  = if (k, v) `elem` xs then MQuery (DL.singleton (JsonPartialObject xs)) else MQuery DL.empty
-hasKV _ _  _                      = MQuery DL.empty
+hasKV k v (JsonPartialObject xs) = if (k, v) `elem` xs then MQuery (DL.singleton (JsonPartialObject xs)) else MQuery DL.empty
+hasKV _ _  _                     = MQuery DL.empty
 
 item :: JsonPartialValue -> MQuery JsonPartialValue
 item jpv = case jpv of
@@ -162,8 +162,8 @@
 
 entry :: JsonPartialValue -> MQuery (Entry String JsonPartialValue)
 entry jpv = case jpv of
-  JsonPartialObject fs  -> MQuery $ DL.fromList (uncurry Entry `map` fs)
-  _                     -> MQuery   DL.empty
+  JsonPartialObject fs -> MQuery $ DL.fromList (uncurry Entry `map` fs)
+  _                    -> MQuery   DL.empty
 
 asString :: JsonPartialValue -> MQuery String
 asString jpv = case jpv of
@@ -183,18 +183,18 @@
 
 named :: String -> Entry String JsonPartialValue -> MQuery JsonPartialValue
 named fieldName (Entry fieldName' jpv) | fieldName == fieldName'  = MQuery $ DL.singleton jpv
-named _         _                                                 = MQuery   DL.empty
+named _         _                      = MQuery   DL.empty
 
 jsonKeys :: JsonPartialValue -> [String]
 jsonKeys jpv = case jpv of
-  JsonPartialObject fs  -> fst `map` fs
-  _                     -> []
+  JsonPartialObject fs -> fst `map` fs
+  _                    -> []
 
 hasKey :: String -> JsonPartialValue -> Bool
 hasKey fieldName jpv = fieldName `elem` jsonKeys jpv
 
 jsonSize :: JsonPartialValue -> MQuery JsonPartialValue
 jsonSize jpv = case jpv of
-  JsonPartialArray  es  -> MQuery (DL.singleton (JsonPartialNumber (fromIntegral (length es))))
-  JsonPartialObject es  -> MQuery (DL.singleton (JsonPartialNumber (fromIntegral (length es))))
-  _                     -> MQuery (DL.singleton (JsonPartialNumber 0))
+  JsonPartialArray  es -> MQuery (DL.singleton (JsonPartialNumber (fromIntegral (length es))))
+  JsonPartialObject es -> MQuery (DL.singleton (JsonPartialNumber (fromIntegral (length es))))
+  _                    -> MQuery (DL.singleton (JsonPartialNumber 0))
diff --git a/src/HaskellWorks/Data/Json/Succinct.hs b/src/HaskellWorks/Data/Json/Succinct.hs
--- a/src/HaskellWorks/Data/Json/Succinct.hs
+++ b/src/HaskellWorks/Data/Json/Succinct.hs
@@ -2,4 +2,4 @@
   ( module X
   ) where
 
-import           HaskellWorks.Data.Json.Succinct.Cursor as X
+import HaskellWorks.Data.Json.Succinct.Cursor as X
diff --git a/src/HaskellWorks/Data/Json/Succinct/Cursor.hs b/src/HaskellWorks/Data/Json/Succinct/Cursor.hs
--- a/src/HaskellWorks/Data/Json/Succinct/Cursor.hs
+++ b/src/HaskellWorks/Data/Json/Succinct/Cursor.hs
@@ -3,5 +3,5 @@
   ( module X
   ) where
 
-import           HaskellWorks.Data.Json.Succinct.Cursor.Internal            as X
-import           HaskellWorks.Data.Json.Succinct.Cursor.Token               as X
+import HaskellWorks.Data.Json.Succinct.Cursor.Internal as X
+import HaskellWorks.Data.Json.Succinct.Cursor.Token    as X
diff --git a/src/HaskellWorks/Data/Json/Succinct/Cursor/BalancedParens.hs b/src/HaskellWorks/Data/Json/Succinct/Cursor/BalancedParens.hs
--- a/src/HaskellWorks/Data/Json/Succinct/Cursor/BalancedParens.hs
+++ b/src/HaskellWorks/Data/Json/Succinct/Cursor/BalancedParens.hs
@@ -8,15 +8,16 @@
   , getJsonBalancedParens
   ) where
 
-import           Control.Applicative
-import qualified Data.ByteString                                    as BS
-import           Data.Conduit
-import qualified Data.Vector.Storable                               as DVS
-import           Data.Word
-import           HaskellWorks.Data.BalancedParens                   as BP
-import           HaskellWorks.Data.Conduit.List
-import           HaskellWorks.Data.Json.Conduit
-import           HaskellWorks.Data.Json.Succinct.Cursor.BlankedJson
+import Control.Applicative
+import Data.Conduit
+import Data.Word
+import HaskellWorks.Data.BalancedParens                   as BP
+import HaskellWorks.Data.Conduit.List
+import HaskellWorks.Data.Json.Conduit
+import HaskellWorks.Data.Json.Succinct.Cursor.BlankedJson
+
+import qualified Data.ByteString      as BS
+import qualified Data.Vector.Storable as DVS
 
 newtype JsonBalancedParens a = JsonBalancedParens a
 
diff --git a/src/HaskellWorks/Data/Json/Succinct/Cursor/BlankedJson.hs b/src/HaskellWorks/Data/Json/Succinct/Cursor/BlankedJson.hs
--- a/src/HaskellWorks/Data/Json/Succinct/Cursor/BlankedJson.hs
+++ b/src/HaskellWorks/Data/Json/Succinct/Cursor/BlankedJson.hs
@@ -5,11 +5,12 @@
   , getBlankedJson
   ) where
 
-import qualified Data.ByteString                      as BS
-import           HaskellWorks.Data.ByteString
-import           HaskellWorks.Data.Conduit.List
-import           HaskellWorks.Data.FromByteString
-import           HaskellWorks.Data.Json.Conduit.Blank
+import HaskellWorks.Data.ByteString
+import HaskellWorks.Data.Conduit.List
+import HaskellWorks.Data.FromByteString
+import HaskellWorks.Data.Json.Conduit.Blank
+
+import qualified Data.ByteString as BS
 
 newtype BlankedJson = BlankedJson [BS.ByteString] deriving (Eq, Show)
 
diff --git a/src/HaskellWorks/Data/Json/Succinct/Cursor/InterestBits.hs b/src/HaskellWorks/Data/Json/Succinct/Cursor/InterestBits.hs
--- a/src/HaskellWorks/Data/Json/Succinct/Cursor/InterestBits.hs
+++ b/src/HaskellWorks/Data/Json/Succinct/Cursor/InterestBits.hs
@@ -8,17 +8,18 @@
   , getJsonInterestBits
   ) where
 
-import           Control.Applicative
-import qualified Data.ByteString                                       as BS
-import           Data.ByteString.Internal
-import qualified Data.Vector.Storable                                  as DVS
-import           Data.Word
-import           HaskellWorks.Data.Bits.BitShown
-import           HaskellWorks.Data.Conduit.List
-import           HaskellWorks.Data.FromByteString
-import           HaskellWorks.Data.Json.Conduit
-import           HaskellWorks.Data.Json.Succinct.Cursor.BlankedJson
-import           HaskellWorks.Data.RankSelect.Poppy512
+import Control.Applicative
+import Data.ByteString.Internal
+import Data.Word
+import HaskellWorks.Data.Bits.BitShown
+import HaskellWorks.Data.Conduit.List
+import HaskellWorks.Data.FromByteString
+import HaskellWorks.Data.Json.Conduit
+import HaskellWorks.Data.Json.Succinct.Cursor.BlankedJson
+import HaskellWorks.Data.RankSelect.Poppy512
+
+import qualified Data.ByteString      as BS
+import qualified Data.Vector.Storable as DVS
 
 newtype JsonInterestBits a = JsonInterestBits a
 
diff --git a/src/HaskellWorks/Data/Json/Succinct/Cursor/Internal.hs b/src/HaskellWorks/Data/Json/Succinct/Cursor/Internal.hs
--- a/src/HaskellWorks/Data/Json/Succinct/Cursor/Internal.hs
+++ b/src/HaskellWorks/Data/Json/Succinct/Cursor/Internal.hs
@@ -9,26 +9,27 @@
   , jsonCursorPos
   ) where
 
-import qualified Data.ByteString                                        as BS
-import qualified Data.ByteString.Char8                                  as BSC
-import           Data.ByteString.Internal                               as BSI
-import           Data.String
-import qualified Data.Vector.Storable                                   as DVS
-import           Data.Word
-import           Foreign.ForeignPtr
-import qualified HaskellWorks.Data.BalancedParens                       as BP
-import           HaskellWorks.Data.Bits.BitShown
-import           HaskellWorks.Data.FromByteString
-import           HaskellWorks.Data.FromForeignRegion
-import qualified HaskellWorks.Data.Json.Succinct.Cursor.BalancedParens  as CBP
-import           HaskellWorks.Data.Json.Succinct.Cursor.BlankedJson
-import           HaskellWorks.Data.Json.Succinct.Cursor.InterestBits
-import           HaskellWorks.Data.Positioning
-import           HaskellWorks.Data.RankSelect.Base.Rank0
-import           HaskellWorks.Data.RankSelect.Base.Rank1
-import           HaskellWorks.Data.RankSelect.Base.Select1
-import           HaskellWorks.Data.RankSelect.Poppy512
-import           HaskellWorks.Data.TreeCursor
+import Data.ByteString.Internal                            as BSI
+import Data.String
+import Data.Word
+import Foreign.ForeignPtr
+import HaskellWorks.Data.Bits.BitShown
+import HaskellWorks.Data.FromByteString
+import HaskellWorks.Data.FromForeignRegion
+import HaskellWorks.Data.Json.Succinct.Cursor.BlankedJson
+import HaskellWorks.Data.Json.Succinct.Cursor.InterestBits
+import HaskellWorks.Data.Positioning
+import HaskellWorks.Data.RankSelect.Base.Rank0
+import HaskellWorks.Data.RankSelect.Base.Rank1
+import HaskellWorks.Data.RankSelect.Base.Select1
+import HaskellWorks.Data.RankSelect.Poppy512
+import HaskellWorks.Data.TreeCursor
+
+import qualified Data.ByteString                                       as BS
+import qualified Data.ByteString.Char8                                 as BSC
+import qualified Data.Vector.Storable                                  as DVS
+import qualified HaskellWorks.Data.BalancedParens                      as BP
+import qualified HaskellWorks.Data.Json.Succinct.Cursor.BalancedParens as CBP
 
 data JsonCursor t v w = JsonCursor
   { cursorText     :: !t
diff --git a/src/HaskellWorks/Data/Json/Succinct/Cursor/Token.hs b/src/HaskellWorks/Data/Json/Succinct/Cursor/Token.hs
--- a/src/HaskellWorks/Data/Json/Succinct/Cursor/Token.hs
+++ b/src/HaskellWorks/Data/Json/Succinct/Cursor/Token.hs
@@ -3,16 +3,17 @@
   ( jsonTokenAt
   ) where
 
-import qualified Data.Attoparsec.ByteString.Char8                 as ABC
-import           Data.ByteString.Internal                         as BSI
-import           HaskellWorks.Data.Bits.BitWise
-import           HaskellWorks.Data.Drop
-import           HaskellWorks.Data.Json.Succinct.Cursor.Internal
-import           HaskellWorks.Data.Json.Token.Tokenize
-import           HaskellWorks.Data.Positioning
-import           HaskellWorks.Data.RankSelect.Base.Rank1
-import           HaskellWorks.Data.RankSelect.Base.Select1
-import           Prelude hiding (drop)
+import Data.ByteString.Internal                        as BSI
+import HaskellWorks.Data.Bits.BitWise
+import HaskellWorks.Data.Drop
+import HaskellWorks.Data.Json.Succinct.Cursor.Internal
+import HaskellWorks.Data.Json.Token.Tokenize
+import HaskellWorks.Data.Positioning
+import HaskellWorks.Data.RankSelect.Base.Rank1
+import HaskellWorks.Data.RankSelect.Base.Select1
+import Prelude                                         hiding (drop)
+
+import qualified Data.Attoparsec.ByteString.Char8 as ABC
 
 jsonTokenAt :: (Rank1 w, Select1 v, TestBit w) => JsonCursor ByteString v w -> Maybe (JsonToken String Double)
 jsonTokenAt k = if balancedParens k .?. lastPositionOf (cursorRank k)
diff --git a/src/HaskellWorks/Data/Json/Succinct/PartialIndex.hs b/src/HaskellWorks/Data/Json/Succinct/PartialIndex.hs
--- a/src/HaskellWorks/Data/Json/Succinct/PartialIndex.hs
+++ b/src/HaskellWorks/Data/Json/Succinct/PartialIndex.hs
@@ -1,28 +1,29 @@
-{-# LANGUAGE BangPatterns           #-}
-{-# LANGUAGE FlexibleContexts       #-}
-{-# LANGUAGE FlexibleInstances      #-}
-{-# LANGUAGE InstanceSigs           #-}
-{-# LANGUAGE MultiParamTypeClasses  #-}
-{-# LANGUAGE ScopedTypeVariables    #-}
+{-# LANGUAGE BangPatterns          #-}
+{-# LANGUAGE FlexibleContexts      #-}
+{-# LANGUAGE FlexibleInstances     #-}
+{-# LANGUAGE InstanceSigs          #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE ScopedTypeVariables   #-}
 
 module HaskellWorks.Data.Json.Succinct.PartialIndex where
 
-import           Control.Arrow
-import qualified Data.ByteString                            as BS
-import qualified Data.List                                  as L
-import qualified HaskellWorks.Data.BalancedParens           as BP
-import           HaskellWorks.Data.Bits.BitWise
-import           HaskellWorks.Data.Drop
-import           HaskellWorks.Data.Json.CharLike
-import           HaskellWorks.Data.Json.Succinct
-import           HaskellWorks.Data.Positioning
-import           HaskellWorks.Data.RankSelect.Base.Rank0
-import           HaskellWorks.Data.RankSelect.Base.Rank1
-import           HaskellWorks.Data.RankSelect.Base.Select1
-import           HaskellWorks.Data.TreeCursor
-import           HaskellWorks.Data.Uncons
-import           Prelude hiding (drop)
+import Control.Arrow
+import HaskellWorks.Data.Bits.BitWise
+import HaskellWorks.Data.Drop
+import HaskellWorks.Data.Json.CharLike
+import HaskellWorks.Data.Json.Succinct
+import HaskellWorks.Data.Positioning
+import HaskellWorks.Data.RankSelect.Base.Rank0
+import HaskellWorks.Data.RankSelect.Base.Rank1
+import HaskellWorks.Data.RankSelect.Base.Select1
+import HaskellWorks.Data.TreeCursor
+import HaskellWorks.Data.Uncons
+import Prelude                                   hiding (drop)
 
+import qualified Data.ByteString                  as BS
+import qualified Data.List                        as L
+import qualified HaskellWorks.Data.BalancedParens as BP
+
 data JsonPartialIndex
   = JsonPartialIndexString BS.ByteString
   | JsonPartialIndexNumber BS.ByteString
@@ -45,8 +46,8 @@
     Just (!c, _) | isChar_n c         -> JsonPartialIndexNull
     Just (!c, _) | isBraceLeft c      -> JsonPartialIndexObject (mapValuesFrom   (firstChild k))
     Just (!c, _) | isBracketLeft c    -> JsonPartialIndexArray  (arrayValuesFrom (firstChild k))
-    Just _                            -> JsonPartialIndexError "Invalid Json Type"
-    Nothing                           -> JsonPartialIndexError "End of data"
+    Just _       -> JsonPartialIndexError "Invalid Json Type"
+    Nothing      -> JsonPartialIndexError "End of data"
     where ik                = interests k
           bpk               = balancedParens k
           p                 = lastPositionOf (select1 ik (rank1 bpk (cursorRank k)))
@@ -58,4 +59,4 @@
           pairwise _        = []
           asField (a, b)    = case a of
                                 JsonPartialIndexString s -> [(s, b)]
-                                _                 -> []
+                                _                        -> []
diff --git a/src/HaskellWorks/Data/Json/Token.hs b/src/HaskellWorks/Data/Json/Token.hs
--- a/src/HaskellWorks/Data/Json/Token.hs
+++ b/src/HaskellWorks/Data/Json/Token.hs
@@ -2,5 +2,5 @@
   ( module X
   ) where
 
-import           HaskellWorks.Data.Json.Token.Types     as X
-import           HaskellWorks.Data.Json.Token.Tokenize  as X
+import HaskellWorks.Data.Json.Token.Types     as X
+import HaskellWorks.Data.Json.Token.Tokenize  as X
diff --git a/src/HaskellWorks/Data/Json/Token/Tokenize.hs b/src/HaskellWorks/Data/Json/Token/Tokenize.hs
--- a/src/HaskellWorks/Data/Json/Token/Tokenize.hs
+++ b/src/HaskellWorks/Data/Json/Token/Tokenize.hs
@@ -1,8 +1,8 @@
-{-# LANGUAGE FlexibleContexts       #-}
-{-# LANGUAGE FlexibleInstances      #-}
-{-# LANGUAGE MultiParamTypeClasses  #-}
-{-# LANGUAGE OverloadedStrings      #-}
-{-# LANGUAGE TypeSynonymInstances   #-}
+{-# LANGUAGE FlexibleContexts      #-}
+{-# LANGUAGE FlexibleInstances     #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE OverloadedStrings     #-}
+{-# LANGUAGE TypeSynonymInstances  #-}
 
 module HaskellWorks.Data.Json.Token.Tokenize
     ( IsChar(..)
@@ -10,18 +10,19 @@
     , ParseJson(..)
     ) where
 
-import           Control.Applicative
-import qualified Data.Attoparsec.ByteString.Char8   as BC
-import qualified Data.Attoparsec.Combinator         as AC
-import qualified Data.Attoparsec.Types              as T
-import qualified Data.ByteString                    as BS
-import           Data.Bits
-import           Data.Char
-import           Data.Word
-import           Data.Word8
-import           HaskellWorks.Data.Char.IsChar
-import           HaskellWorks.Data.Json.Token.Types
-import           HaskellWorks.Data.Parser           as P
+import Control.Applicative
+import Data.Bits
+import Data.Char
+import Data.Word
+import Data.Word8
+import HaskellWorks.Data.Char.IsChar
+import HaskellWorks.Data.Json.Token.Types
+import HaskellWorks.Data.Parser           as P
+
+import qualified Data.Attoparsec.ByteString.Char8 as BC
+import qualified Data.Attoparsec.Combinator       as AC
+import qualified Data.Attoparsec.Types            as T
+import qualified Data.ByteString                  as BS
 
 hexDigitNumeric :: P.Parser t => T.Parser t Int
 hexDigitNumeric = do
diff --git a/src/HaskellWorks/Data/Json/Type.hs b/src/HaskellWorks/Data/Json/Type.hs
--- a/src/HaskellWorks/Data/Json/Type.hs
+++ b/src/HaskellWorks/Data/Json/Type.hs
@@ -1,25 +1,26 @@
-{-# LANGUAGE FlexibleInstances      #-}
-{-# LANGUAGE InstanceSigs           #-}
-{-# LANGUAGE MultiParamTypeClasses  #-}
+{-# LANGUAGE FlexibleInstances     #-}
+{-# LANGUAGE InstanceSigs          #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
 
 module HaskellWorks.Data.Json.Type
   ( JsonType(..)
   , JsonTypeAt(..)
   ) where
 
-import qualified Data.ByteString                            as BS
-import           Data.Char
-import           Data.Word8
-import qualified HaskellWorks.Data.BalancedParens           as BP
-import           HaskellWorks.Data.Bits.BitWise
-import           HaskellWorks.Data.Drop
-import           HaskellWorks.Data.Json.Succinct
-import           HaskellWorks.Data.Positioning
-import           HaskellWorks.Data.RankSelect.Base.Rank0
-import           HaskellWorks.Data.RankSelect.Base.Rank1
-import           HaskellWorks.Data.RankSelect.Base.Select1
-import           Prelude hiding (drop)
+import Data.Char
+import Data.Word8
+import HaskellWorks.Data.Bits.BitWise
+import HaskellWorks.Data.Drop
+import HaskellWorks.Data.Json.Succinct
+import HaskellWorks.Data.Positioning
+import HaskellWorks.Data.RankSelect.Base.Rank0
+import HaskellWorks.Data.RankSelect.Base.Rank1
+import HaskellWorks.Data.RankSelect.Base.Select1
+import Prelude                                   hiding (drop)
 
+import qualified Data.ByteString                  as BS
+import qualified HaskellWorks.Data.BalancedParens as BP
+
 {-# ANN module ("HLint: Reduce duplication" :: String) #-}
 
 wIsJsonNumberDigit :: Word8 -> Bool
@@ -47,7 +48,7 @@
     c:_ | wIsJsonNumberDigit (fromIntegral (ord c)) -> Just JsonTypeNumber
     c:_ | fromIntegral (ord c) == _braceleft        -> Just JsonTypeObject
     c:_ | fromIntegral (ord c) == _quotedbl         -> Just JsonTypeString
-    _                                               -> Nothing
+    _   -> Nothing
 
   jsonTypeAt k = jsonTypeAtPosition p k
     where p   = lastPositionOf (select1 ik (rank1 bpk (cursorRank k)))
@@ -63,7 +64,7 @@
     Just (c, _) | wIsJsonNumberDigit c  -> Just JsonTypeNumber
     Just (c, _) | c == _braceleft       -> Just JsonTypeObject
     Just (c, _) | c == _quotedbl        -> Just JsonTypeString
-    _                                   -> Nothing
+    _           -> Nothing
 
   jsonTypeAt k = jsonTypeAtPosition p k
     where p   = lastPositionOf (select1 ik (rank1 bpk (cursorRank k)))
diff --git a/src/HaskellWorks/Data/Json/Value.hs b/src/HaskellWorks/Data/Json/Value.hs
--- a/src/HaskellWorks/Data/Json/Value.hs
+++ b/src/HaskellWorks/Data/Json/Value.hs
@@ -10,8 +10,8 @@
 import HaskellWorks.Data.Json.Succinct.Index
 import HaskellWorks.Data.Json.Value.Internal
 
-import qualified Data.Attoparsec.ByteString.Char8       as ABC
-import qualified Data.ByteString                        as BS
+import qualified Data.Attoparsec.ByteString.Char8 as ABC
+import qualified Data.ByteString                  as BS
 
 data JsonValue
   = JsonString String
@@ -28,15 +28,15 @@
 instance JsonValueAt JsonIndex where
   jsonValueAt i = case i of
     JsonIndexString  s  -> case ABC.parse parseJsonString s of
-      ABC.Fail    {}    -> Left (DecodeError ("Invalid string: '" ++ show (BS.take 20 s) ++ "...'"))
-      ABC.Partial _     -> Left (DecodeError "Unexpected end of string")
-      ABC.Done    _ r   -> Right (JsonString r)
+      ABC.Fail    {}  -> Left (DecodeError ("Invalid string: '" ++ show (BS.take 20 s) ++ "...'"))
+      ABC.Partial _   -> Left (DecodeError "Unexpected end of string")
+      ABC.Done    _ r -> Right (JsonString r)
     JsonIndexNumber  s  -> case ABC.parse ABC.rational s of
       ABC.Fail    {}    -> Left (DecodeError ("Invalid number: '" ++ show (BS.take 20 s) ++ "...'"))
       ABC.Partial f     -> case f " " of
-        ABC.Fail    {}    -> Left (DecodeError ("Invalid number: '" ++ show (BS.take 20 s) ++ "...'"))
-        ABC.Partial _     -> Left (DecodeError "Unexpected end of number")
-        ABC.Done    _ r   -> Right (JsonNumber r)
+        ABC.Fail    {}  -> Left (DecodeError ("Invalid number: '" ++ show (BS.take 20 s) ++ "...'"))
+        ABC.Partial _   -> Left (DecodeError "Unexpected end of number")
+        ABC.Done    _ r -> Right (JsonNumber r)
       ABC.Done    _ r   -> Right (JsonNumber r)
     JsonIndexObject  fs -> JsonObject <$> mapM (\f -> (,) <$> parseString (fst f) <*> jsonValueAt (snd f)) fs
     JsonIndexArray   es -> JsonArray <$> mapM jsonValueAt es
diff --git a/src/HaskellWorks/Data/Json/Value/Internal.hs b/src/HaskellWorks/Data/Json/Value/Internal.hs
--- a/src/HaskellWorks/Data/Json/Value/Internal.hs
+++ b/src/HaskellWorks/Data/Json/Value/Internal.hs
@@ -7,13 +7,14 @@
 
 module HaskellWorks.Data.Json.Value.Internal where
 
-import           Control.Applicative
-import qualified Data.Attoparsec.ByteString.Char8       as ABC
-import qualified Data.Attoparsec.Types                  as T
-import           Data.Bits
-import           Data.Char
-import           Data.String
-import           HaskellWorks.Data.Parser               as P
+import Control.Applicative
+import Data.Bits
+import Data.Char
+import Data.String
+import HaskellWorks.Data.Parser as P
+
+import qualified Data.Attoparsec.ByteString.Char8 as ABC
+import qualified Data.Attoparsec.Types            as T
 
 parseHexDigitNumeric :: P.Parser t => T.Parser t Int
 parseHexDigitNumeric = do
diff --git a/test/HaskellWorks/Data/Json/Conduit/BlankSpec.hs b/test/HaskellWorks/Data/Json/Conduit/BlankSpec.hs
--- a/test/HaskellWorks/Data/Json/Conduit/BlankSpec.hs
+++ b/test/HaskellWorks/Data/Json/Conduit/BlankSpec.hs
@@ -2,10 +2,11 @@
 
 module HaskellWorks.Data.Json.Conduit.BlankSpec (spec) where
 
-import qualified Data.ByteString                      as BS
-import           HaskellWorks.Data.Json.Conduit.Blank
-import           HaskellWorks.Data.Conduit.List
-import           Test.Hspec
+import HaskellWorks.Data.Conduit.List
+import HaskellWorks.Data.Json.Conduit.Blank
+import Test.Hspec
+
+import qualified Data.ByteString as BS
 
 {-# ANN module ("HLint: ignore Redundant do" :: String) #-}
 
diff --git a/test/HaskellWorks/Data/Json/CorpusSpec.hs b/test/HaskellWorks/Data/Json/CorpusSpec.hs
--- a/test/HaskellWorks/Data/Json/CorpusSpec.hs
+++ b/test/HaskellWorks/Data/Json/CorpusSpec.hs
@@ -1,27 +1,27 @@
-{-# LANGUAGE BangPatterns               #-}
-{-# LANGUAGE ExplicitForAll             #-}
-{-# LANGUAGE FlexibleContexts           #-}
-{-# LANGUAGE FlexibleInstances          #-}
-{-# LANGUAGE InstanceSigs               #-}
-{-# LANGUAGE MultiParamTypeClasses      #-}
-{-# LANGUAGE NoMonomorphismRestriction  #-}
-{-# LANGUAGE OverloadedStrings          #-}
-{-# LANGUAGE ScopedTypeVariables        #-}
+{-# LANGUAGE BangPatterns              #-}
+{-# LANGUAGE ExplicitForAll            #-}
+{-# LANGUAGE FlexibleContexts          #-}
+{-# LANGUAGE FlexibleInstances         #-}
+{-# LANGUAGE InstanceSigs              #-}
+{-# LANGUAGE MultiParamTypeClasses     #-}
+{-# LANGUAGE NoMonomorphismRestriction #-}
+{-# LANGUAGE OverloadedStrings         #-}
+{-# LANGUAGE ScopedTypeVariables       #-}
 
 {-# OPTIONS_GHC -fno-warn-missing-signatures #-}
 
 module HaskellWorks.Data.Json.CorpusSpec(spec) where
 
-import qualified Data.ByteString                                            as BS
-import qualified Data.Vector.Storable                                       as DVS
-import           Data.Word
-import           HaskellWorks.Data.BalancedParens.Simple
-import           HaskellWorks.Data.Bits.BitShown
-import           HaskellWorks.Data.Bits.FromBitTextByteString
-import           HaskellWorks.Data.Json.Succinct.Cursor                     as C
-import           Test.Hspec
+import Data.Word
+import HaskellWorks.Data.BalancedParens.Simple
+import HaskellWorks.Data.Bits.BitShown
+import HaskellWorks.Data.Bits.FromBitTextByteString
+import HaskellWorks.Data.FromByteString
+import HaskellWorks.Data.Json.Succinct.Cursor       as C
+import Test.Hspec
 
-import           HaskellWorks.Data.FromByteString
+import qualified Data.ByteString      as BS
+import qualified Data.Vector.Storable as DVS
 
 {-# ANN module ("HLint: ignore Redundant do"        :: String) #-}
 {-# ANN module ("HLint: ignore Reduce duplication"  :: String) #-}
diff --git a/test/HaskellWorks/Data/Json/Succinct/Cursor/BalancedParensSpec.hs b/test/HaskellWorks/Data/Json/Succinct/Cursor/BalancedParensSpec.hs
--- a/test/HaskellWorks/Data/Json/Succinct/Cursor/BalancedParensSpec.hs
+++ b/test/HaskellWorks/Data/Json/Succinct/Cursor/BalancedParensSpec.hs
@@ -3,14 +3,15 @@
 
 module HaskellWorks.Data.Json.Succinct.Cursor.BalancedParensSpec(spec) where
 
-import qualified Data.ByteString                                    as BS
-import           Data.Conduit
-import           Data.String
-import           HaskellWorks.Data.Bits.BitShown
-import           HaskellWorks.Data.Conduit.List
-import           HaskellWorks.Data.Json.Conduit
-import           HaskellWorks.Data.Json.Succinct.Cursor.BlankedJson
-import           Test.Hspec
+import Data.Conduit
+import Data.String
+import HaskellWorks.Data.Bits.BitShown
+import HaskellWorks.Data.Conduit.List
+import HaskellWorks.Data.Json.Conduit
+import HaskellWorks.Data.Json.Succinct.Cursor.BlankedJson
+import Test.Hspec
+
+import qualified Data.ByteString as BS
 
 {-# ANN module ("HLint: Ignore Redundant do"        :: String) #-}
 
diff --git a/test/HaskellWorks/Data/Json/Succinct/Cursor/InterestBitsSpec.hs b/test/HaskellWorks/Data/Json/Succinct/Cursor/InterestBitsSpec.hs
--- a/test/HaskellWorks/Data/Json/Succinct/Cursor/InterestBitsSpec.hs
+++ b/test/HaskellWorks/Data/Json/Succinct/Cursor/InterestBitsSpec.hs
@@ -4,15 +4,16 @@
 
 module HaskellWorks.Data.Json.Succinct.Cursor.InterestBitsSpec(spec) where
 
-import qualified Data.ByteString                                     as BS
-import           Data.String
-import qualified Data.Vector.Storable                                as DVS
-import           Data.Word
-import           HaskellWorks.Data.Bits.BitShown
-import           HaskellWorks.Data.FromByteString
-import           HaskellWorks.Data.Json.Succinct.Cursor.BlankedJson
-import           HaskellWorks.Data.Json.Succinct.Cursor.InterestBits
-import           Test.Hspec
+import Data.String
+import Data.Word
+import HaskellWorks.Data.Bits.BitShown
+import HaskellWorks.Data.FromByteString
+import HaskellWorks.Data.Json.Succinct.Cursor.BlankedJson
+import HaskellWorks.Data.Json.Succinct.Cursor.InterestBits
+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/Json/Succinct/CursorSpec.hs b/test/HaskellWorks/Data/Json/Succinct/CursorSpec.hs
--- a/test/HaskellWorks/Data/Json/Succinct/CursorSpec.hs
+++ b/test/HaskellWorks/Data/Json/Succinct/CursorSpec.hs
@@ -1,36 +1,37 @@
-{-# LANGUAGE ExplicitForAll             #-}
-{-# LANGUAGE FlexibleContexts           #-}
-{-# LANGUAGE FlexibleInstances          #-}
-{-# LANGUAGE InstanceSigs               #-}
-{-# LANGUAGE MultiParamTypeClasses      #-}
-{-# LANGUAGE NoMonomorphismRestriction  #-}
-{-# LANGUAGE OverloadedStrings          #-}
-{-# LANGUAGE ScopedTypeVariables        #-}
+{-# LANGUAGE ExplicitForAll            #-}
+{-# LANGUAGE FlexibleContexts          #-}
+{-# LANGUAGE FlexibleInstances         #-}
+{-# LANGUAGE InstanceSigs              #-}
+{-# LANGUAGE MultiParamTypeClasses     #-}
+{-# LANGUAGE NoMonomorphismRestriction #-}
+{-# LANGUAGE OverloadedStrings         #-}
+{-# LANGUAGE ScopedTypeVariables       #-}
 
 {-# OPTIONS_GHC -fno-warn-missing-signatures #-}
 
 module HaskellWorks.Data.Json.Succinct.CursorSpec(spec) where
 
-import           Control.Monad
-import qualified Data.ByteString                                            as BS
-import           Data.String
-import qualified Data.Vector.Storable                                       as DVS
-import           Data.Word
-import           HaskellWorks.Data.BalancedParens.BalancedParens
-import           HaskellWorks.Data.BalancedParens.Simple
-import           HaskellWorks.Data.Bits.BitShow
-import           HaskellWorks.Data.Bits.BitShown
-import           HaskellWorks.Data.Bits.BitWise
-import           HaskellWorks.Data.FromForeignRegion
-import           HaskellWorks.Data.Json.Succinct.Cursor                     as C
-import           HaskellWorks.Data.Json.Succinct.Index
-import           HaskellWorks.Data.Json.Token
-import           HaskellWorks.Data.RankSelect.Base.Rank0
-import           HaskellWorks.Data.RankSelect.Base.Rank1
-import           HaskellWorks.Data.RankSelect.Base.Select1
-import           HaskellWorks.Data.RankSelect.Poppy512
-import qualified HaskellWorks.Data.TreeCursor                               as TC
-import           Test.Hspec
+import Control.Monad
+import Data.String
+import Data.Word
+import HaskellWorks.Data.BalancedParens.BalancedParens
+import HaskellWorks.Data.BalancedParens.Simple
+import HaskellWorks.Data.Bits.BitShow
+import HaskellWorks.Data.Bits.BitShown
+import HaskellWorks.Data.Bits.BitWise
+import HaskellWorks.Data.FromForeignRegion
+import HaskellWorks.Data.Json.Succinct.Cursor          as C
+import HaskellWorks.Data.Json.Succinct.Index
+import HaskellWorks.Data.Json.Token
+import HaskellWorks.Data.RankSelect.Base.Rank0
+import HaskellWorks.Data.RankSelect.Base.Rank1
+import HaskellWorks.Data.RankSelect.Base.Select1
+import HaskellWorks.Data.RankSelect.Poppy512
+import Test.Hspec
+
+import qualified Data.ByteString              as BS
+import qualified Data.Vector.Storable         as DVS
+import qualified HaskellWorks.Data.TreeCursor as TC
 
 {-# ANN module ("HLint: ignore Redundant do"        :: String) #-}
 {-# ANN module ("HLint: ignore Reduce duplication"  :: String) #-}
diff --git a/test/HaskellWorks/Data/Json/Token/TokenizeSpec.hs b/test/HaskellWorks/Data/Json/Token/TokenizeSpec.hs
--- a/test/HaskellWorks/Data/Json/Token/TokenizeSpec.hs
+++ b/test/HaskellWorks/Data/Json/Token/TokenizeSpec.hs
@@ -2,10 +2,11 @@
 
 module HaskellWorks.Data.Json.Token.TokenizeSpec (spec) where
 
-import qualified Data.Attoparsec.ByteString.Char8      as BC
-import           Data.ByteString                       as BS
-import           HaskellWorks.Data.Json.Token.Tokenize
-import           Test.Hspec
+import Data.ByteString                       as BS
+import HaskellWorks.Data.Json.Token.Tokenize
+import Test.Hspec
+
+import qualified Data.Attoparsec.ByteString.Char8 as BC
 
 {-# ANN module ("HLint: ignore Redundant do"        :: String) #-}
 
diff --git a/test/HaskellWorks/Data/Json/TypeSpec.hs b/test/HaskellWorks/Data/Json/TypeSpec.hs
--- a/test/HaskellWorks/Data/Json/TypeSpec.hs
+++ b/test/HaskellWorks/Data/Json/TypeSpec.hs
@@ -1,35 +1,36 @@
-{-# LANGUAGE ExplicitForAll             #-}
-{-# LANGUAGE FlexibleContexts           #-}
-{-# LANGUAGE FlexibleInstances          #-}
-{-# LANGUAGE InstanceSigs               #-}
-{-# LANGUAGE MultiParamTypeClasses      #-}
-{-# LANGUAGE NoMonomorphismRestriction  #-}
-{-# LANGUAGE OverloadedStrings          #-}
-{-# LANGUAGE ScopedTypeVariables        #-}
+{-# LANGUAGE ExplicitForAll            #-}
+{-# LANGUAGE FlexibleContexts          #-}
+{-# LANGUAGE FlexibleInstances         #-}
+{-# LANGUAGE InstanceSigs              #-}
+{-# LANGUAGE MultiParamTypeClasses     #-}
+{-# LANGUAGE NoMonomorphismRestriction #-}
+{-# LANGUAGE OverloadedStrings         #-}
+{-# LANGUAGE ScopedTypeVariables       #-}
 
 {-# OPTIONS_GHC -fno-warn-missing-signatures #-}
 
 module HaskellWorks.Data.Json.TypeSpec (spec) where
 
-import           Control.Monad
-import qualified Data.ByteString                                            as BS
-import           Data.String
-import qualified Data.Vector.Storable                                       as DVS
-import           Data.Word
-import           HaskellWorks.Data.BalancedParens.BalancedParens
-import           HaskellWorks.Data.BalancedParens.Simple
-import           HaskellWorks.Data.Bits.BitShown
-import           HaskellWorks.Data.Bits.BitWise
-import           HaskellWorks.Data.FromForeignRegion
-import           HaskellWorks.Data.Json.Succinct.Cursor                     as C
-import           HaskellWorks.Data.Json.Succinct.Index
-import           HaskellWorks.Data.Json.Type
-import           HaskellWorks.Data.RankSelect.Base.Rank0
-import           HaskellWorks.Data.RankSelect.Base.Rank1
-import           HaskellWorks.Data.RankSelect.Base.Select1
-import           HaskellWorks.Data.RankSelect.Poppy512
-import qualified HaskellWorks.Data.TreeCursor                               as TC
-import           Test.Hspec
+import Control.Monad
+import Data.String
+import Data.Word
+import HaskellWorks.Data.BalancedParens.BalancedParens
+import HaskellWorks.Data.BalancedParens.Simple
+import HaskellWorks.Data.Bits.BitShown
+import HaskellWorks.Data.Bits.BitWise
+import HaskellWorks.Data.FromForeignRegion
+import HaskellWorks.Data.Json.Succinct.Cursor          as C
+import HaskellWorks.Data.Json.Succinct.Index
+import HaskellWorks.Data.Json.Type
+import HaskellWorks.Data.RankSelect.Base.Rank0
+import HaskellWorks.Data.RankSelect.Base.Rank1
+import HaskellWorks.Data.RankSelect.Base.Select1
+import HaskellWorks.Data.RankSelect.Poppy512
+import Test.Hspec
+
+import qualified Data.ByteString              as BS
+import qualified Data.Vector.Storable         as DVS
+import qualified HaskellWorks.Data.TreeCursor as TC
 
 {-# ANN module ("HLint: ignore Redundant do"        :: String) #-}
 {-# ANN module ("HLint: ignore Reduce duplication"  :: String) #-}
diff --git a/test/HaskellWorks/Data/Json/ValueSpec.hs b/test/HaskellWorks/Data/Json/ValueSpec.hs
--- a/test/HaskellWorks/Data/Json/ValueSpec.hs
+++ b/test/HaskellWorks/Data/Json/ValueSpec.hs
@@ -1,37 +1,38 @@
-{-# LANGUAGE ExplicitForAll             #-}
-{-# LANGUAGE FlexibleContexts           #-}
-{-# LANGUAGE FlexibleInstances          #-}
-{-# LANGUAGE InstanceSigs               #-}
-{-# LANGUAGE MultiParamTypeClasses      #-}
-{-# LANGUAGE NoMonomorphismRestriction  #-}
-{-# LANGUAGE OverloadedStrings          #-}
-{-# LANGUAGE ScopedTypeVariables        #-}
+{-# LANGUAGE ExplicitForAll            #-}
+{-# LANGUAGE FlexibleContexts          #-}
+{-# LANGUAGE FlexibleInstances         #-}
+{-# LANGUAGE InstanceSigs              #-}
+{-# LANGUAGE MultiParamTypeClasses     #-}
+{-# LANGUAGE NoMonomorphismRestriction #-}
+{-# LANGUAGE OverloadedStrings         #-}
+{-# LANGUAGE ScopedTypeVariables       #-}
 
 {-# OPTIONS_GHC -fno-warn-missing-signatures #-}
 
 module HaskellWorks.Data.Json.ValueSpec (spec) where
 
-import           Control.Monad
-import qualified Data.ByteString                                            as BS
-import           Data.String
-import qualified Data.Vector.Storable                                       as DVS
-import           Data.Word
-import           HaskellWorks.Data.BalancedParens.BalancedParens
-import           HaskellWorks.Data.BalancedParens.Simple
-import           HaskellWorks.Data.Bits.BitShown
-import           HaskellWorks.Data.Bits.BitWise
-import           HaskellWorks.Data.FromForeignRegion
-import           HaskellWorks.Data.Json.DecodeError
-import           HaskellWorks.Data.Json.Succinct.Cursor                     as C
-import           HaskellWorks.Data.Json.Succinct.Index
-import           HaskellWorks.Data.Json.Value
-import           HaskellWorks.Data.RankSelect.Base.Rank0
-import           HaskellWorks.Data.RankSelect.Base.Rank1
-import           HaskellWorks.Data.RankSelect.Base.Select1
-import           HaskellWorks.Data.RankSelect.Poppy512
-import qualified HaskellWorks.Data.TreeCursor                               as TC
-import           Test.Hspec
+import Control.Monad
+import Data.String
+import Data.Word
+import HaskellWorks.Data.BalancedParens.BalancedParens
+import HaskellWorks.Data.BalancedParens.Simple
+import HaskellWorks.Data.Bits.BitShown
+import HaskellWorks.Data.Bits.BitWise
+import HaskellWorks.Data.FromForeignRegion
+import HaskellWorks.Data.Json.DecodeError
+import HaskellWorks.Data.Json.Succinct.Cursor          as C
+import HaskellWorks.Data.Json.Succinct.Index
+import HaskellWorks.Data.Json.Value
+import HaskellWorks.Data.RankSelect.Base.Rank0
+import HaskellWorks.Data.RankSelect.Base.Rank1
+import HaskellWorks.Data.RankSelect.Base.Select1
+import HaskellWorks.Data.RankSelect.Poppy512
+import Test.Hspec
 
+import qualified Data.ByteString              as BS
+import qualified Data.Vector.Storable         as DVS
+import qualified HaskellWorks.Data.TreeCursor as TC
+
 {-# ANN module ("HLint: ignore Redundant do"        :: String) #-}
 {-# ANN module ("HLint: ignore Reduce duplication"  :: String) #-}
 {-# ANN module ("HLint: redundant bracket"          :: String) #-}
@@ -51,8 +52,8 @@
 jsonValueVia  :: JsonIndexAt (JsonCursor BS.ByteString t u)
               => Maybe (JsonCursor BS.ByteString t u) -> Either DecodeError JsonValue
 jsonValueVia mk = case mk of
-  Just k    -> (jsonIndexAt >=> jsonValueAt) k
-  Nothing   -> Left (DecodeError "No such element")
+  Just k  -> (jsonIndexAt >=> jsonValueAt) k
+  Nothing -> Left (DecodeError "No such element")
 
 genSpec :: forall t u.
   ( Eq                t