Derulo

Derulo parses and renders JSON simply. It aims to provide an RFC 7159 compliant parser and renderer without incurring any dependencies. It is intended to be used either for learning or in situations where dependencies are unwanted. In normal usage, prefer a faster, more robust library like Aeson.

Derulo does not export any identifiers that conflict with the prelude and can be imported unqualified.

>>> import Derulo

Use readJSON to parse a String into a JSON value.

>>> readJSON " null "
Just Null

Use showJSON to render a JSON value as a String.

>>> showJSON Null
"null"

Types

data JSON

A JSON value as described by RFC 7159.

Constructors

Null

Boolean Bool

Number Integer Integer

String String

Array [JSON]

Object [(String, JSON)]

Instances

Eq JSON

Methods

(==) :: JSON -> JSON -> Bool

(/=) :: JSON -> JSON -> Bool

Data JSON

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> JSON -> c JSON

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c JSON

toConstr :: JSON -> Constr

dataTypeOf :: JSON -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c JSON)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c JSON)

gmapT :: (forall b. Data b => b -> b) -> JSON -> JSON

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> JSON -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> JSON -> r

gmapQ :: (forall d. Data d => d -> u) -> JSON -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> JSON -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> JSON -> m JSON

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> JSON -> m JSON

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> JSON -> m JSON

Ord JSON

Methods

compare :: JSON -> JSON -> Ordering

(<) :: JSON -> JSON -> Bool

(<=) :: JSON -> JSON -> Bool

(>) :: JSON -> JSON -> Bool

(>=) :: JSON -> JSON -> Bool

max :: JSON -> JSON -> JSON

min :: JSON -> JSON -> JSON

Read JSON

Methods

readsPrec :: Int -> ReadS JSON

readList :: ReadS [JSON]

readPrec :: ReadPrec JSON

readListPrec :: ReadPrec [JSON]

Show JSON

Methods

showsPrec :: Int -> JSON -> ShowS

show :: JSON -> String

showList :: [JSON] -> ShowS

Generic JSON

Associated Types

type Rep JSON :: * -> *

Methods

from :: JSON -> Rep JSON x

to :: Rep JSON x -> JSON

type Rep JSON

type Rep JSON = D1 (MetaData "JSON" "Derulo" "derulo-0.0.3-InNIUCUjXzVLFCseYhfEyY" False) ((:+:) ((:+:) (C1 (MetaCons "Null" PrefixI False) U1) ((:+:) (C1 (MetaCons "Boolean" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool))) (C1 (MetaCons "Number" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer)))))) ((:+:) (C1 (MetaCons "String" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))) ((:+:) (C1 (MetaCons "Array" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [JSON]))) (C1 (MetaCons "Object" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [(String, JSON)]))))))

Parsing

readJSON :: String -> Maybe JSON

Parses a string as JSON.

>>> readJSON "null"
Just Null

>>> readJSON "true"
Just (Boolean True)
>>> readJSON "false"
Just (Boolean False)

>>> readJSON "0e0"
Just (Number 0 0)
>>> readJSON "12e34"
Just (Number 12 34)
>>> readJSON "-12e-34"
Just (Number (-12) (-34))

>>> readJSON "\"\""
Just (String "")
>>> readJSON "\"js\""
Just (String "js")
>>> readJSON "\"\\\"\\\\\\b\\f\\n\\r\\t\""
Just (String "\"\\\b\f\n\r\t")
>>> readJSON "\"\\u001f\""
Just (String "\US")

>>> readJSON "[]"
Just (Array [])
>>> readJSON "[null]"
Just (Array [Null])
>>> readJSON "[true,false]"
Just (Array [Boolean True,Boolean False])

>>> readJSON "{}"
Just (Object [])
>>> readJSON "{\"\":null}"
Just (Object [("",Null)])
>>> readJSON "{\"t\":true,\"f\":false}"
Just (Object [("t",Boolean True),("f",Boolean False)])

pJSON :: ReadP JSON

pValue :: ReadP JSON

pNull :: ReadP JSON

pBoolean :: ReadP JSON

pTrue :: ReadP JSON

pFalse :: ReadP JSON

pNumber :: ReadP JSON

pInteger :: ReadP Integer

pZero :: ReadP Integer

pNonZero :: ReadP Integer

pFraction :: ReadP (Integer, Integer)

pPower :: ReadP Integer

pString :: ReadP JSON

pCharacter :: ReadP Char

pLiteral :: ReadP Char

pEscape :: ReadP Char

pArray :: ReadP JSON

pObject :: ReadP JSON

pPair :: ReadP (String, JSON)

Rendering

showJSON :: JSON -> String

Renders JSON as a string.

>>> showJSON Null
"null"

>>> showJSON (Boolean True)
"true"
>>> showJSON (Boolean False)
"false"

>>> showJSON (Number 0 0)
"0e0"
>>> showJSON (Number 12 34)
"12e34"
>>> showJSON (Number (-12) (-34))
"-12e-34"

>>> showJSON (String "")
"\"\""
>>> showJSON (String "js")
"\"js\""
>>> showJSON (String "\"\\\b\f\n\r\t")
"\"\\\"\\\\\\b\\f\\n\\r\\t\""
>>> showJSON (String "\x1f")
"\"\\u001f\""

>>> showJSON (Array [])
"[]"
>>> showJSON (Array [Null])
"[null]"
>>> showJSON (Array [Boolean True, Boolean False])
"[true,false]"

>>> showJSON (Object [])
"{}"
>>> showJSON (Object [("", Null)])
"{\"\":null}"
>>> showJSON (Object [("t", Boolean True), ("f", Boolean False)])
"{\"t\":true,\"f\":false}"

sJSON :: JSON -> ShowS

sNull :: ShowS

sBoolean :: Bool -> ShowS

sTrue :: ShowS

sFalse :: ShowS

sNumber :: Integer -> Integer -> ShowS

sString :: String -> ShowS

sCharacter :: Char -> ShowS

sArray :: [JSON] -> ShowS

sObject :: [(String, JSON)] -> ShowS

sPair :: (String, JSON) -> ShowS

Helpers

fromBase :: Integer -> (Char -> Maybe Integer) -> String -> Maybe Integer

fromDecimal :: String -> Maybe Integer

fromDecimalDigit :: Char -> Maybe Integer

fromHexadecimal :: String -> Maybe Integer

fromHexadecimalDigit :: Char -> Maybe Integer

isControl :: Char -> Bool

isDecimalDigit :: Char -> Bool

isHexadecimalDigit :: Char -> Bool

isLiteral :: Char -> Bool

isNonZeroDigit :: Char -> Bool

isWhitespace :: Char -> Bool

negateIf :: Bool -> Integer -> Integer

pSymbol :: String -> ReadP ()

pWhitespaces :: ReadP ()

padLeft :: Integer -> a -> [a] -> [a]

padRight :: Integer -> a -> [a] -> [a]

runParser :: ReadP a -> String -> Maybe a

sBetween :: ShowS -> ShowS -> (anything -> ShowS) -> anything -> ShowS

sSeparated :: ShowS -> (element -> ShowS) -> [element] -> ShowS

sSeparatedBetween :: ShowS -> ShowS -> ShowS -> (element -> ShowS) -> [element] -> ShowS

toBase :: Integer -> (Integer -> Maybe Char) -> Integer -> String

toBase' :: Integer -> (Integer -> Maybe Char) -> Integer -> String

toHexadecimal :: Integer -> String

toHexadecimalDigit :: Integer -> Maybe Char