packages feed

hw-json 0.5.0.0 → 0.6.0.0

raw patch · 31 files changed

+429/−414 lines, 31 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

hw-json.cabal view
@@ -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
src/HaskellWorks/Data/Json.hs view
@@ -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
src/HaskellWorks/Data/Json/Conduit.hs view
@@ -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
src/HaskellWorks/Data/Json/Conduit/Blank.hs view
@@ -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
src/HaskellWorks/Data/Json/Conduit/Words.hs view
@@ -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)
src/HaskellWorks/Data/Json/DecodeError.hs view
@@ -1,5 +1,3 @@-module HaskellWorks.Data.Json.DecodeError-  ( DecodeError(..)-  ) where+module HaskellWorks.Data.Json.DecodeError where  newtype DecodeError = DecodeError String deriving (Eq, Show)
src/HaskellWorks/Data/Json/LightJson.hs view
@@ -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)
src/HaskellWorks/Data/Json/Load.hs view
@@ -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 ()
src/HaskellWorks/Data/Json/LoadCursor.hs view
@@ -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 ()
src/HaskellWorks/Data/Json/PartialValue.hs view
@@ -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))
src/HaskellWorks/Data/Json/Succinct.hs view
@@ -2,4 +2,4 @@   ( module X   ) where -import           HaskellWorks.Data.Json.Succinct.Cursor as X+import HaskellWorks.Data.Json.Succinct.Cursor as X
src/HaskellWorks/Data/Json/Succinct/Cursor.hs view
@@ -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
src/HaskellWorks/Data/Json/Succinct/Cursor/BalancedParens.hs view
@@ -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
src/HaskellWorks/Data/Json/Succinct/Cursor/BlankedJson.hs view
@@ -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)
src/HaskellWorks/Data/Json/Succinct/Cursor/InterestBits.hs view
@@ -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
src/HaskellWorks/Data/Json/Succinct/Cursor/Internal.hs view
@@ -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
src/HaskellWorks/Data/Json/Succinct/Cursor/Token.hs view
@@ -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)
src/HaskellWorks/Data/Json/Succinct/PartialIndex.hs view
@@ -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)]-                                _                 -> []+                                _                        -> []
src/HaskellWorks/Data/Json/Token.hs view
@@ -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
src/HaskellWorks/Data/Json/Token/Tokenize.hs view
@@ -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
src/HaskellWorks/Data/Json/Type.hs view
@@ -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)))
src/HaskellWorks/Data/Json/Value.hs view
@@ -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
src/HaskellWorks/Data/Json/Value/Internal.hs view
@@ -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
test/HaskellWorks/Data/Json/Conduit/BlankSpec.hs view
@@ -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) #-}
test/HaskellWorks/Data/Json/CorpusSpec.hs view
@@ -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) #-}
test/HaskellWorks/Data/Json/Succinct/Cursor/BalancedParensSpec.hs view
@@ -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) #-}
test/HaskellWorks/Data/Json/Succinct/Cursor/InterestBitsSpec.hs view
@@ -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) #-}
test/HaskellWorks/Data/Json/Succinct/CursorSpec.hs view
@@ -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) #-}
test/HaskellWorks/Data/Json/Token/TokenizeSpec.hs view
@@ -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) #-}
test/HaskellWorks/Data/Json/TypeSpec.hs view
@@ -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) #-}
test/HaskellWorks/Data/Json/ValueSpec.hs view
@@ -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