{-# LANGUAGE OverloadedStrings #-}

module SimpleParser.Examples.Json
  ( Json (..)
  , JsonF (..)
  , JsonParserC
  , JsonParserM
  , jsonParser
  , recJsonParser
  ) where

import Control.Monad (void)
import Data.Scientific (Scientific)
import Data.Sequence (Seq)
import Data.Text (Text)
import Data.Void (Void)
import SimpleParser (MatchBlock (..), MatchCase (..), Parser, Stream (..), TextLabel, TextualChunked (..),
                     TextualStream, anyToken, betweenParser, escapedStringParser, lexemeParser, lookAheadMatch,
                     matchChunk, matchToken, orParser, scientificParser, sepByParser, signedNumStartPred, spaceParser)

data JsonF a =
    JsonObject !(Seq (Text, a))
  | JsonArray !(Seq a)
  | JsonString !Text
  | JsonBool !Bool
  | JsonNum !Scientific
  | JsonNull
  deriving (JsonF a -> JsonF a -> Bool
(JsonF a -> JsonF a -> Bool)
-> (JsonF a -> JsonF a -> Bool) -> Eq (JsonF a)
forall a. Eq a => JsonF a -> JsonF a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: JsonF a -> JsonF a -> Bool
$c/= :: forall a. Eq a => JsonF a -> JsonF a -> Bool
== :: JsonF a -> JsonF a -> Bool
$c== :: forall a. Eq a => JsonF a -> JsonF a -> Bool
Eq, Int -> JsonF a -> ShowS
[JsonF a] -> ShowS
JsonF a -> String
(Int -> JsonF a -> ShowS)
-> (JsonF a -> String) -> ([JsonF a] -> ShowS) -> Show (JsonF a)
forall a. Show a => Int -> JsonF a -> ShowS
forall a. Show a => [JsonF a] -> ShowS
forall a. Show a => JsonF a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [JsonF a] -> ShowS
$cshowList :: forall a. Show a => [JsonF a] -> ShowS
show :: JsonF a -> String
$cshow :: forall a. Show a => JsonF a -> String
showsPrec :: Int -> JsonF a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> JsonF a -> ShowS
Show, a -> JsonF b -> JsonF a
(a -> b) -> JsonF a -> JsonF b
(forall a b. (a -> b) -> JsonF a -> JsonF b)
-> (forall a b. a -> JsonF b -> JsonF a) -> Functor JsonF
forall a b. a -> JsonF b -> JsonF a
forall a b. (a -> b) -> JsonF a -> JsonF b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> JsonF b -> JsonF a
$c<$ :: forall a b. a -> JsonF b -> JsonF a
fmap :: (a -> b) -> JsonF a -> JsonF b
$cfmap :: forall a b. (a -> b) -> JsonF a -> JsonF b
Functor, JsonF a -> Bool
(a -> m) -> JsonF a -> m
(a -> b -> b) -> b -> JsonF a -> b
(forall m. Monoid m => JsonF m -> m)
-> (forall m a. Monoid m => (a -> m) -> JsonF a -> m)
-> (forall m a. Monoid m => (a -> m) -> JsonF a -> m)
-> (forall a b. (a -> b -> b) -> b -> JsonF a -> b)
-> (forall a b. (a -> b -> b) -> b -> JsonF a -> b)
-> (forall b a. (b -> a -> b) -> b -> JsonF a -> b)
-> (forall b a. (b -> a -> b) -> b -> JsonF a -> b)
-> (forall a. (a -> a -> a) -> JsonF a -> a)
-> (forall a. (a -> a -> a) -> JsonF a -> a)
-> (forall a. JsonF a -> [a])
-> (forall a. JsonF a -> Bool)
-> (forall a. JsonF a -> Int)
-> (forall a. Eq a => a -> JsonF a -> Bool)
-> (forall a. Ord a => JsonF a -> a)
-> (forall a. Ord a => JsonF a -> a)
-> (forall a. Num a => JsonF a -> a)
-> (forall a. Num a => JsonF a -> a)
-> Foldable JsonF
forall a. Eq a => a -> JsonF a -> Bool
forall a. Num a => JsonF a -> a
forall a. Ord a => JsonF a -> a
forall m. Monoid m => JsonF m -> m
forall a. JsonF a -> Bool
forall a. JsonF a -> Int
forall a. JsonF a -> [a]
forall a. (a -> a -> a) -> JsonF a -> a
forall m a. Monoid m => (a -> m) -> JsonF a -> m
forall b a. (b -> a -> b) -> b -> JsonF a -> b
forall a b. (a -> b -> b) -> b -> JsonF a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: JsonF a -> a
$cproduct :: forall a. Num a => JsonF a -> a
sum :: JsonF a -> a
$csum :: forall a. Num a => JsonF a -> a
minimum :: JsonF a -> a
$cminimum :: forall a. Ord a => JsonF a -> a
maximum :: JsonF a -> a
$cmaximum :: forall a. Ord a => JsonF a -> a
elem :: a -> JsonF a -> Bool
$celem :: forall a. Eq a => a -> JsonF a -> Bool
length :: JsonF a -> Int
$clength :: forall a. JsonF a -> Int
null :: JsonF a -> Bool
$cnull :: forall a. JsonF a -> Bool
toList :: JsonF a -> [a]
$ctoList :: forall a. JsonF a -> [a]
foldl1 :: (a -> a -> a) -> JsonF a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> JsonF a -> a
foldr1 :: (a -> a -> a) -> JsonF a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> JsonF a -> a
foldl' :: (b -> a -> b) -> b -> JsonF a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> JsonF a -> b
foldl :: (b -> a -> b) -> b -> JsonF a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> JsonF a -> b
foldr' :: (a -> b -> b) -> b -> JsonF a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> JsonF a -> b
foldr :: (a -> b -> b) -> b -> JsonF a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> JsonF a -> b
foldMap' :: (a -> m) -> JsonF a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> JsonF a -> m
foldMap :: (a -> m) -> JsonF a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> JsonF a -> m
fold :: JsonF m -> m
$cfold :: forall m. Monoid m => JsonF m -> m
Foldable, Functor JsonF
Foldable JsonF
Functor JsonF
-> Foldable JsonF
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> JsonF a -> f (JsonF b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    JsonF (f a) -> f (JsonF a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> JsonF a -> m (JsonF b))
-> (forall (m :: * -> *) a. Monad m => JsonF (m a) -> m (JsonF a))
-> Traversable JsonF
(a -> f b) -> JsonF a -> f (JsonF b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => JsonF (m a) -> m (JsonF a)
forall (f :: * -> *) a. Applicative f => JsonF (f a) -> f (JsonF a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> JsonF a -> m (JsonF b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> JsonF a -> f (JsonF b)
sequence :: JsonF (m a) -> m (JsonF a)
$csequence :: forall (m :: * -> *) a. Monad m => JsonF (m a) -> m (JsonF a)
mapM :: (a -> m b) -> JsonF a -> m (JsonF b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> JsonF a -> m (JsonF b)
sequenceA :: JsonF (f a) -> f (JsonF a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => JsonF (f a) -> f (JsonF a)
traverse :: (a -> f b) -> JsonF a -> f (JsonF b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> JsonF a -> f (JsonF b)
$cp2Traversable :: Foldable JsonF
$cp1Traversable :: Functor JsonF
Traversable)

newtype Json = Json { Json -> JsonF Json
unJson :: JsonF Json } deriving (Json -> Json -> Bool
(Json -> Json -> Bool) -> (Json -> Json -> Bool) -> Eq Json
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Json -> Json -> Bool
$c/= :: Json -> Json -> Bool
== :: Json -> Json -> Bool
$c== :: Json -> Json -> Bool
Eq, Int -> Json -> ShowS
[Json] -> ShowS
Json -> String
(Int -> Json -> ShowS)
-> (Json -> String) -> ([Json] -> ShowS) -> Show Json
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Json] -> ShowS
$cshowList :: [Json] -> ShowS
show :: Json -> String
$cshow :: Json -> String
showsPrec :: Int -> Json -> ShowS
$cshowsPrec :: Int -> Json -> ShowS
Show)

type JsonParserC s = (TextualStream s, Eq (Chunk s))

type JsonParserM s a = Parser TextLabel s Void a

jsonParser :: JsonParserC s => JsonParserM s Json
jsonParser :: JsonParserM s Json
jsonParser = let p :: JsonParserM s Json
p = (JsonF Json -> Json)
-> ParserT TextLabel s Void Identity (JsonF Json)
-> JsonParserM s Json
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap JsonF Json -> Json
Json (JsonParserM s Json
-> ParserT TextLabel s Void Identity (JsonF Json)
forall s a.
JsonParserC s =>
JsonParserM s a -> JsonParserM s (JsonF a)
recJsonParser JsonParserM s Json
p) in JsonParserM s Json
p

isBoolStartPred :: Char -> Bool
isBoolStartPred :: Char -> Bool
isBoolStartPred Char
c = Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
't' Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'f'

recJsonParser :: JsonParserC s => JsonParserM s a -> JsonParserM s (JsonF a)
recJsonParser :: JsonParserM s a -> JsonParserM s (JsonF a)
recJsonParser JsonParserM s a
root = JsonParserM s (JsonF a) -> JsonParserM s (JsonF a)
forall s a. JsonParserC s => JsonParserM s a -> JsonParserM s a
lexP (MatchBlock TextLabel s Void Identity Char (JsonF a)
-> JsonParserM s (JsonF a)
forall (m :: * -> *) l s e a b.
Monad m =>
MatchBlock l s e m a b -> ParserT l s e m b
lookAheadMatch MatchBlock TextLabel s Void Identity Char (JsonF a)
block) where
  block :: MatchBlock TextLabel s Void Identity Char (JsonF a)
block = ParserT TextLabel s Void Identity Char
-> JsonParserM s (JsonF a)
-> [MatchCase TextLabel s Void Identity Char (JsonF a)]
-> MatchBlock TextLabel s Void Identity Char (JsonF a)
forall l s e (m :: * -> *) a b.
ParserT l s e m a
-> ParserT l s e m b
-> [MatchCase l s e m a b]
-> MatchBlock l s e m a b
MatchBlock ParserT TextLabel s Void Identity Char
forall s (m :: * -> *) l e.
(Stream s, Monad m) =>
ParserT l s e m (Token s)
anyToken (String -> JsonParserM s (JsonF a)
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"failed to parse json document")
    [ Maybe TextLabel
-> (Char -> Bool)
-> JsonParserM s (JsonF a)
-> MatchCase TextLabel s Void Identity Char (JsonF a)
forall l s e (m :: * -> *) a b.
Maybe l
-> (a -> Bool) -> ParserT l s e m b -> MatchCase l s e m a b
MatchCase Maybe TextLabel
forall a. Maybe a
Nothing (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'{') (JsonParserM s (Text, a) -> JsonParserM s (JsonF a)
forall s a.
JsonParserC s =>
JsonParserM s (Text, a) -> JsonParserM s (JsonF a)
objectP (JsonParserM s a -> JsonParserM s (Text, a)
forall s a.
JsonParserC s =>
JsonParserM s a -> JsonParserM s (Text, a)
objectPairP JsonParserM s a
root))
    , Maybe TextLabel
-> (Char -> Bool)
-> JsonParserM s (JsonF a)
-> MatchCase TextLabel s Void Identity Char (JsonF a)
forall l s e (m :: * -> *) a b.
Maybe l
-> (a -> Bool) -> ParserT l s e m b -> MatchCase l s e m a b
MatchCase Maybe TextLabel
forall a. Maybe a
Nothing (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'[') (JsonParserM s a -> JsonParserM s (JsonF a)
forall s a.
JsonParserC s =>
JsonParserM s a -> JsonParserM s (JsonF a)
arrayP JsonParserM s a
root)
    , Maybe TextLabel
-> (Char -> Bool)
-> JsonParserM s (JsonF a)
-> MatchCase TextLabel s Void Identity Char (JsonF a)
forall l s e (m :: * -> *) a b.
Maybe l
-> (a -> Bool) -> ParserT l s e m b -> MatchCase l s e m a b
MatchCase Maybe TextLabel
forall a. Maybe a
Nothing (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'"') JsonParserM s (JsonF a)
forall s a. JsonParserC s => JsonParserM s (JsonF a)
stringP
    , Maybe TextLabel
-> (Char -> Bool)
-> JsonParserM s (JsonF a)
-> MatchCase TextLabel s Void Identity Char (JsonF a)
forall l s e (m :: * -> *) a b.
Maybe l
-> (a -> Bool) -> ParserT l s e m b -> MatchCase l s e m a b
MatchCase Maybe TextLabel
forall a. Maybe a
Nothing Char -> Bool
signedNumStartPred JsonParserM s (JsonF a)
forall s a. JsonParserC s => JsonParserM s (JsonF a)
numP
    , Maybe TextLabel
-> (Char -> Bool)
-> JsonParserM s (JsonF a)
-> MatchCase TextLabel s Void Identity Char (JsonF a)
forall l s e (m :: * -> *) a b.
Maybe l
-> (a -> Bool) -> ParserT l s e m b -> MatchCase l s e m a b
MatchCase Maybe TextLabel
forall a. Maybe a
Nothing Char -> Bool
isBoolStartPred JsonParserM s (JsonF a)
forall s a. JsonParserC s => JsonParserM s (JsonF a)
boolP
    , Maybe TextLabel
-> (Char -> Bool)
-> JsonParserM s (JsonF a)
-> MatchCase TextLabel s Void Identity Char (JsonF a)
forall l s e (m :: * -> *) a b.
Maybe l
-> (a -> Bool) -> ParserT l s e m b -> MatchCase l s e m a b
MatchCase Maybe TextLabel
forall a. Maybe a
Nothing (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'n') JsonParserM s (JsonF a)
forall s a. JsonParserC s => JsonParserM s (JsonF a)
nullP
    ]

spaceP :: JsonParserC s => JsonParserM s ()
spaceP :: JsonParserM s ()
spaceP = JsonParserM s ()
forall s (m :: * -> *) l e.
(Stream s, Token s ~ Char, Monad m) =>
ParserT l s e m ()
spaceParser

lexP :: JsonParserC s => JsonParserM s a -> JsonParserM s a
lexP :: JsonParserM s a -> JsonParserM s a
lexP = ParserT TextLabel s Void Identity ()
-> JsonParserM s a -> JsonParserM s a
forall (m :: * -> *) l s e a.
Monad m =>
ParserT l s e m () -> ParserT l s e m a -> ParserT l s e m a
lexemeParser ParserT TextLabel s Void Identity ()
forall s. JsonParserC s => JsonParserM s ()
spaceP

tokL :: JsonParserC s => Char -> JsonParserM s ()
tokL :: Char -> JsonParserM s ()
tokL Char
c = JsonParserM s () -> JsonParserM s ()
forall s a. JsonParserC s => JsonParserM s a -> JsonParserM s a
lexP (ParserT TextLabel s Void Identity Char -> JsonParserM s ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Token s -> ParserT TextLabel s Void Identity (Token s)
forall s (m :: * -> *) l e.
(Stream s, Monad m, Eq (Token s)) =>
Token s -> ParserT l s e m (Token s)
matchToken Char
Token s
c))

chunkL :: JsonParserC s => Text -> JsonParserM s ()
chunkL :: Text -> JsonParserM s ()
chunkL Text
cs = JsonParserM s () -> JsonParserM s ()
forall s a. JsonParserC s => JsonParserM s a -> JsonParserM s a
lexP (ParserT TextLabel s Void Identity (Chunk s) -> JsonParserM s ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Chunk s -> ParserT TextLabel s Void Identity (Chunk s)
forall s (m :: * -> *) l e.
(Stream s, Monad m, Eq (Chunk s)) =>
Chunk s -> ParserT l s e m (Chunk s)
matchChunk (Text -> Chunk s
forall chunk. TextualChunked chunk => Text -> chunk
unpackChunk Text
cs)))

openBraceP, closeBraceP, commaP, colonP, openBracketP, closeBracketP, closeQuoteP :: JsonParserC s => JsonParserM s ()
openBraceP :: JsonParserM s ()
openBraceP = Char -> JsonParserM s ()
forall s. JsonParserC s => Char -> JsonParserM s ()
tokL Char
'{'
closeBraceP :: JsonParserM s ()
closeBraceP = Char -> JsonParserM s ()
forall s. JsonParserC s => Char -> JsonParserM s ()
tokL Char
'}'
commaP :: JsonParserM s ()
commaP = Char -> JsonParserM s ()
forall s. JsonParserC s => Char -> JsonParserM s ()
tokL Char
','
colonP :: JsonParserM s ()
colonP = Char -> JsonParserM s ()
forall s. JsonParserC s => Char -> JsonParserM s ()
tokL Char
':'
openBracketP :: JsonParserM s ()
openBracketP = Char -> JsonParserM s ()
forall s. JsonParserC s => Char -> JsonParserM s ()
tokL Char
'['
closeBracketP :: JsonParserM s ()
closeBracketP = Char -> JsonParserM s ()
forall s. JsonParserC s => Char -> JsonParserM s ()
tokL Char
']'
closeQuoteP :: JsonParserM s ()
closeQuoteP = Char -> JsonParserM s ()
forall s. JsonParserC s => Char -> JsonParserM s ()
tokL Char
'"'

openQuoteP :: JsonParserC s => JsonParserM s ()
openQuoteP :: JsonParserM s ()
openQuoteP = ParserT TextLabel s Void Identity Char -> JsonParserM s ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Token s -> ParserT TextLabel s Void Identity (Token s)
forall s (m :: * -> *) l e.
(Stream s, Monad m, Eq (Token s)) =>
Token s -> ParserT l s e m (Token s)
matchToken Char
Token s
'"')

nullTokP, trueTokP, falseTokP :: JsonParserC s => JsonParserM s ()
nullTokP :: JsonParserM s ()
nullTokP = Text -> JsonParserM s ()
forall s. JsonParserC s => Text -> JsonParserM s ()
chunkL Text
"null"
trueTokP :: JsonParserM s ()
trueTokP = Text -> JsonParserM s ()
forall s. JsonParserC s => Text -> JsonParserM s ()
chunkL Text
"true"
falseTokP :: JsonParserM s ()
falseTokP = Text -> JsonParserM s ()
forall s. JsonParserC s => Text -> JsonParserM s ()
chunkL Text
"false"

rawStringP :: JsonParserC s => JsonParserM s Text
rawStringP :: JsonParserM s Text
rawStringP = (Chunk s -> Text)
-> ParserT TextLabel s Void Identity (Chunk s)
-> JsonParserM s Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Chunk s -> Text
forall chunk. TextualChunked chunk => chunk -> Text
packChunk (Char -> ParserT TextLabel s Void Identity (Chunk s)
forall s (m :: * -> *) l e.
(Stream s, Token s ~ Char, Monad m) =>
Char -> ParserT l s e m (Chunk s)
escapedStringParser Char
'"')

stringP :: JsonParserC s => JsonParserM s (JsonF a)
stringP :: JsonParserM s (JsonF a)
stringP = (Text -> JsonF a)
-> ParserT TextLabel s Void Identity Text
-> JsonParserM s (JsonF a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Text -> JsonF a
forall a. Text -> JsonF a
JsonString ParserT TextLabel s Void Identity Text
forall s. JsonParserC s => JsonParserM s Text
rawStringP

nullP :: JsonParserC s => JsonParserM s (JsonF a)
nullP :: JsonParserM s (JsonF a)
nullP = JsonF a
forall a. JsonF a
JsonNull JsonF a
-> ParserT TextLabel s Void Identity () -> JsonParserM s (JsonF a)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserT TextLabel s Void Identity ()
forall s. JsonParserC s => JsonParserM s ()
nullTokP

boolP :: JsonParserC s => JsonParserM s (JsonF a)
boolP :: JsonParserM s (JsonF a)
boolP = JsonParserM s (JsonF a)
-> JsonParserM s (JsonF a) -> JsonParserM s (JsonF a)
forall (m :: * -> *) l s e a.
Monad m =>
ParserT l s e m a -> ParserT l s e m a -> ParserT l s e m a
orParser (Bool -> JsonF a
forall a. Bool -> JsonF a
JsonBool Bool
True JsonF a
-> ParserT TextLabel s Void Identity () -> JsonParserM s (JsonF a)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserT TextLabel s Void Identity ()
forall s. JsonParserC s => JsonParserM s ()
trueTokP) (Bool -> JsonF a
forall a. Bool -> JsonF a
JsonBool Bool
False JsonF a
-> ParserT TextLabel s Void Identity () -> JsonParserM s (JsonF a)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserT TextLabel s Void Identity ()
forall s. JsonParserC s => JsonParserM s ()
falseTokP)

numP :: JsonParserC s => JsonParserM s (JsonF a)
numP :: JsonParserM s (JsonF a)
numP = (Scientific -> JsonF a)
-> ParserT TextLabel s Void Identity Scientific
-> JsonParserM s (JsonF a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Scientific -> JsonF a
forall a. Scientific -> JsonF a
JsonNum ParserT TextLabel s Void Identity Scientific
forall l s (m :: * -> *) e.
(EmbedTextLabel l, Stream s, Token s ~ Char, Monad m) =>
ParserT l s e m Scientific
scientificParser

objectPairP :: JsonParserC s => JsonParserM s a -> JsonParserM s (Text, a)
objectPairP :: JsonParserM s a -> JsonParserM s (Text, a)
objectPairP JsonParserM s a
root = do
  Text
name <- JsonParserM s Text
forall s. JsonParserC s => JsonParserM s Text
rawStringP
  JsonParserM s ()
forall s. JsonParserC s => JsonParserM s ()
colonP
  a
value <- JsonParserM s a
root
  (Text, a) -> JsonParserM s (Text, a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text
name, a
value)

objectP :: JsonParserC s => JsonParserM s (Text, a) -> JsonParserM s (JsonF a)
objectP :: JsonParserM s (Text, a) -> JsonParserM s (JsonF a)
objectP JsonParserM s (Text, a)
pairP = ParserT TextLabel s Void Identity ()
-> ParserT TextLabel s Void Identity ()
-> JsonParserM s (JsonF a)
-> JsonParserM s (JsonF a)
forall (m :: * -> *) l s e a.
Monad m =>
ParserT l s e m ()
-> ParserT l s e m () -> ParserT l s e m a -> ParserT l s e m a
betweenParser ParserT TextLabel s Void Identity ()
forall s. JsonParserC s => JsonParserM s ()
openBraceP ParserT TextLabel s Void Identity ()
forall s. JsonParserC s => JsonParserM s ()
closeBraceP ((Seq (Text, a) -> JsonF a)
-> ParserT TextLabel s Void Identity (Seq (Text, a))
-> JsonParserM s (JsonF a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Seq (Text, a) -> JsonF a
forall a. Seq (Text, a) -> JsonF a
JsonObject (JsonParserM s (Text, a)
-> ParserT TextLabel s Void Identity ()
-> ParserT TextLabel s Void Identity (Seq (Text, a))
forall seq elem (m :: * -> *) l s e.
(Chunked seq elem, Monad m) =>
ParserT l s e m elem -> ParserT l s e m () -> ParserT l s e m seq
sepByParser JsonParserM s (Text, a)
pairP ParserT TextLabel s Void Identity ()
forall s. JsonParserC s => JsonParserM s ()
commaP))

arrayP :: JsonParserC s => JsonParserM s a -> JsonParserM s (JsonF a)
arrayP :: JsonParserM s a -> JsonParserM s (JsonF a)
arrayP JsonParserM s a
root = ParserT TextLabel s Void Identity ()
-> ParserT TextLabel s Void Identity ()
-> JsonParserM s (JsonF a)
-> JsonParserM s (JsonF a)
forall (m :: * -> *) l s e a.
Monad m =>
ParserT l s e m ()
-> ParserT l s e m () -> ParserT l s e m a -> ParserT l s e m a
betweenParser ParserT TextLabel s Void Identity ()
forall s. JsonParserC s => JsonParserM s ()
openBracketP ParserT TextLabel s Void Identity ()
forall s. JsonParserC s => JsonParserM s ()
closeBracketP ((Seq a -> JsonF a)
-> ParserT TextLabel s Void Identity (Seq a)
-> JsonParserM s (JsonF a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Seq a -> JsonF a
forall a. Seq a -> JsonF a
JsonArray (JsonParserM s a
-> ParserT TextLabel s Void Identity ()
-> ParserT TextLabel s Void Identity (Seq a)
forall seq elem (m :: * -> *) l s e.
(Chunked seq elem, Monad m) =>
ParserT l s e m elem -> ParserT l s e m () -> ParserT l s e m seq
sepByParser JsonParserM s a
root ParserT TextLabel s Void Identity ()
forall s. JsonParserC s => JsonParserM s ()
commaP))