Text.JSON

json-0.9.1: Support for serialising Haskell to and from JSON

Copyright | (c) Galois Inc. 2007-2009
License | BSD3
Maintainer | Sigbjorn Finne <sof@galois.com>
Stability | provisional
Portability | portable
Safe Haskell | Safe
Language | Haskell98

Text.JSON

Contents

- JSON Types
- Serialization to and from JSValues
- Encoding and Decoding
- Wrapper Types
- Serialization to and from Strings.
  - Reading JSON
  - Writing JSON
  - Instance helpers

Description

Synopsis

- data JSValue
  - = JSNull
  - | JSBool !Bool
  - | JSRational Bool !Rational
  - | JSString JSString
  - | JSArray [JSValue]
  - | JSObject (JSObject JSValue)
- class JSON a where
- data Result a
  - = Ok a
  - | Error String
- encode :: JSON a => a -> String
- decode :: JSON a => String -> Result a
- encodeStrict :: JSON a => a -> String
- decodeStrict :: JSON a => String -> Result a
- data JSString
- toJSString :: String -> JSString
- fromJSString :: JSString -> String
- data JSObject e
- toJSObject :: [(String, a)] -> JSObject a
- fromJSObject :: JSObject e -> [(String, e)]
- resultToEither :: Result a -> Either String a
- readJSNull :: GetJSON JSValue
- readJSBool :: GetJSON JSValue
- readJSString :: GetJSON JSValue
- readJSRational :: GetJSON Rational
- readJSArray :: GetJSON JSValue
- readJSObject :: GetJSON JSValue
- readJSValue :: GetJSON JSValue
- showJSNull :: ShowS
- showJSBool :: Bool -> ShowS
- showJSArray :: [JSValue] -> ShowS
- showJSRational :: Rational -> ShowS
- showJSRational' :: Bool -> Rational -> ShowS
- showJSObject :: JSObject JSValue -> ShowS
- showJSValue :: JSValue -> ShowS
- makeObj :: [(String, JSValue)] -> JSValue
- valFromObj :: JSON a => String -> JSObject JSValue -> Result a
- class JSKey a where
- encJSDict :: (JSKey a, JSON b) => [(a, b)] -> JSValue
- decJSDict :: (JSKey a, JSON b) => String -> JSValue -> Result [(a, b)]

# JSON Types

data JSValue #

JSON values

The type to which we encode Haskell values. There's a set of primitives, and a couple of heterogenous collection types.

Objects:

An object structure is represented as a pair of curly brackets surrounding zero or more name/value pairs (or members). A name is a string. A single colon comes after each name, separating the name from the value. A single comma separates a value from a following name.

Arrays:

An array structure is represented as square brackets surrounding zero or more values (or elements). Elements are separated by commas.

Only valid JSON can be constructed this way

Constructors

JSNull |
JSBool !Bool |
JSRational Bool !Rational |
JSString JSString |
JSArray [JSValue] |
JSObject (JSObject JSValue) |

Instances

Eq JSValue # |
Methods (==) :: JSValue -> JSValue -> Bool # (/=) :: JSValue -> JSValue -> Bool #
Ord JSValue # |
Methods compare :: JSValue -> JSValue -> Ordering # (<) :: JSValue -> JSValue -> Bool # (<=) :: JSValue -> JSValue -> Bool # (>) :: JSValue -> JSValue -> Bool # (>=) :: JSValue -> JSValue -> Bool # max :: JSValue -> JSValue -> JSValue # min :: JSValue -> JSValue -> JSValue #
Read JSValue # |
Methods readsPrec :: Int -> ReadS JSValue # readList :: ReadS [JSValue] # readPrec :: ReadPrec JSValue # readListPrec :: ReadPrec [JSValue] #
Show JSValue # |
Methods showsPrec :: Int -> JSValue -> ShowS # show :: JSValue -> String # showList :: [JSValue] -> ShowS #
JSON JSValue # | To ensure we generate valid JSON, we map Haskell types to JSValue internally, then pretty print that.
Methods readJSON :: JSValue -> Result JSValue # showJSON :: JSValue -> JSValue # readJSONs :: JSValue -> Result [JSValue] # showJSONs :: [JSValue] -> JSValue #

# Serialization to and from JSValues

class JSON a where #

The class of types serialisable to and from JSON

Minimal complete definition

readJSON, showJSON

Methods

readJSON :: JSValue -> Result a #

showJSON :: a -> JSValue #

readJSONs :: JSValue -> Result [a] #

showJSONs :: [a] -> JSValue #

Instances

JSON Bool # |
Methods readJSON :: JSValue -> Result Bool # showJSON :: Bool -> JSValue # readJSONs :: JSValue -> Result [Bool] # showJSONs :: [Bool] -> JSValue #
JSON Char # |
Methods readJSON :: JSValue -> Result Char # showJSON :: Char -> JSValue # readJSONs :: JSValue -> Result [Char] # showJSONs :: [Char] -> JSValue #
JSON Double # |
Methods readJSON :: JSValue -> Result Double # showJSON :: Double -> JSValue # readJSONs :: JSValue -> Result [Double] # showJSONs :: [Double] -> JSValue #
JSON Float # |
Methods readJSON :: JSValue -> Result Float # showJSON :: Float -> JSValue # readJSONs :: JSValue -> Result [Float] # showJSONs :: [Float] -> JSValue #
JSON Int # |
Methods readJSON :: JSValue -> Result Int # showJSON :: Int -> JSValue # readJSONs :: JSValue -> Result [Int] # showJSONs :: [Int] -> JSValue #
JSON Int8 # |
Methods readJSON :: JSValue -> Result Int8 # showJSON :: Int8 -> JSValue # readJSONs :: JSValue -> Result [Int8] # showJSONs :: [Int8] -> JSValue #
JSON Int16 # |
Methods readJSON :: JSValue -> Result Int16 # showJSON :: Int16 -> JSValue # readJSONs :: JSValue -> Result [Int16] # showJSONs :: [Int16] -> JSValue #
JSON Int32 # |
Methods readJSON :: JSValue -> Result Int32 # showJSON :: Int32 -> JSValue # readJSONs :: JSValue -> Result [Int32] # showJSONs :: [Int32] -> JSValue #
JSON Int64 # |
Methods readJSON :: JSValue -> Result Int64 # showJSON :: Int64 -> JSValue # readJSONs :: JSValue -> Result [Int64] # showJSONs :: [Int64] -> JSValue #
JSON Integer # |
Methods readJSON :: JSValue -> Result Integer # showJSON :: Integer -> JSValue # readJSONs :: JSValue -> Result [Integer] # showJSONs :: [Integer] -> JSValue #
JSON Ordering # |
Methods readJSON :: JSValue -> Result Ordering # showJSON :: Ordering -> JSValue # readJSONs :: JSValue -> Result [Ordering] # showJSONs :: [Ordering] -> JSValue #
JSON Word # |
Methods readJSON :: JSValue -> Result Word # showJSON :: Word -> JSValue # readJSONs :: JSValue -> Result [Word] # showJSONs :: [Word] -> JSValue #
JSON Word8 # |
Methods readJSON :: JSValue -> Result Word8 # showJSON :: Word8 -> JSValue # readJSONs :: JSValue -> Result [Word8] # showJSONs :: [Word8] -> JSValue #
JSON Word16 # |
Methods readJSON :: JSValue -> Result Word16 # showJSON :: Word16 -> JSValue # readJSONs :: JSValue -> Result [Word16] # showJSONs :: [Word16] -> JSValue #
JSON Word32 # |
Methods readJSON :: JSValue -> Result Word32 # showJSON :: Word32 -> JSValue # readJSONs :: JSValue -> Result [Word32] # showJSONs :: [Word32] -> JSValue #
JSON Word64 # |
Methods readJSON :: JSValue -> Result Word64 # showJSON :: Word64 -> JSValue # readJSONs :: JSValue -> Result [Word64] # showJSONs :: [Word64] -> JSValue #
JSON () # |
Methods readJSON :: JSValue -> Result () # showJSON :: () -> JSValue # readJSONs :: JSValue -> Result [()] # showJSONs :: [()] -> JSValue #
JSON ByteString # |
Methods readJSON :: JSValue -> Result ByteString # showJSON :: ByteString -> JSValue # readJSONs :: JSValue -> Result [ByteString] # showJSONs :: [ByteString] -> JSValue #
JSON ByteString # |
Methods readJSON :: JSValue -> Result ByteString # showJSON :: ByteString -> JSValue # readJSONs :: JSValue -> Result [ByteString] # showJSONs :: [ByteString] -> JSValue #
JSON IntSet # |
Methods readJSON :: JSValue -> Result IntSet # showJSON :: IntSet -> JSValue # readJSONs :: JSValue -> Result [IntSet] # showJSONs :: [IntSet] -> JSValue #
JSON Text # |
Methods readJSON :: JSValue -> Result Text # showJSON :: Text -> JSValue # readJSONs :: JSValue -> Result [Text] # showJSONs :: [Text] -> JSValue #
JSON JSString # |
Methods readJSON :: JSValue -> Result JSString # showJSON :: JSString -> JSValue # readJSONs :: JSValue -> Result [JSString] # showJSONs :: [JSString] -> JSValue #
JSON JSValue # | To ensure we generate valid JSON, we map Haskell types to JSValue internally, then pretty print that.
Methods readJSON :: JSValue -> Result JSValue # showJSON :: JSValue -> JSValue # readJSONs :: JSValue -> Result [JSValue] # showJSONs :: [JSValue] -> JSValue #
JSON a => JSON [a] # |
Methods readJSON :: JSValue -> Result [a] # showJSON :: [a] -> JSValue # readJSONs :: JSValue -> Result [[a]] # showJSONs :: [[a]] -> JSValue #
JSON a => JSON (Maybe a) # |
Methods readJSON :: JSValue -> Result (Maybe a) # showJSON :: Maybe a -> JSValue # readJSONs :: JSValue -> Result [Maybe a] # showJSONs :: [Maybe a] -> JSValue #
JSON a => JSON (IntMap a) # |
Methods readJSON :: JSValue -> Result (IntMap a) # showJSON :: IntMap a -> JSValue # readJSONs :: JSValue -> Result [IntMap a] # showJSONs :: [IntMap a] -> JSValue #
(Ord a, JSON a) => JSON (Set a) # |
Methods readJSON :: JSValue -> Result (Set a) # showJSON :: Set a -> JSValue # readJSONs :: JSValue -> Result [Set a] # showJSONs :: [Set a] -> JSValue #
JSON a => JSON (JSObject a) # |
Methods readJSON :: JSValue -> Result (JSObject a) # showJSON :: JSObject a -> JSValue # readJSONs :: JSValue -> Result [JSObject a] # showJSONs :: [JSObject a] -> JSValue #
(JSON a, JSON b) => JSON (Either a b) # |
Methods readJSON :: JSValue -> Result (Either a b) # showJSON :: Either a b -> JSValue # readJSONs :: JSValue -> Result [Either a b] # showJSONs :: [Either a b] -> JSValue #
(JSON a, JSON b) => JSON (a, b) # |
Methods readJSON :: JSValue -> Result (a, b) # showJSON :: (a, b) -> JSValue # readJSONs :: JSValue -> Result [(a, b)] # showJSONs :: [(a, b)] -> JSValue #
(Ix i, JSON i, JSON e) => JSON (Array i e) # |
Methods readJSON :: JSValue -> Result (Array i e) # showJSON :: Array i e -> JSValue # readJSONs :: JSValue -> Result [Array i e] # showJSONs :: [Array i e] -> JSValue #
(Ord a, JSON a, JSON b) => JSON (Map a b) # |
Methods readJSON :: JSValue -> Result (Map a b) # showJSON :: Map a b -> JSValue # readJSONs :: JSValue -> Result [Map a b] # showJSONs :: [Map a b] -> JSValue #
(JSON a, JSON b, JSON c) => JSON (a, b, c) # |
Methods readJSON :: JSValue -> Result (a, b, c) # showJSON :: (a, b, c) -> JSValue # readJSONs :: JSValue -> Result [(a, b, c)] # showJSONs :: [(a, b, c)] -> JSValue #
(JSON a, JSON b, JSON c, JSON d) => JSON (a, b, c, d) # |
Methods readJSON :: JSValue -> Result (a, b, c, d) # showJSON :: (a, b, c, d) -> JSValue # readJSONs :: JSValue -> Result [(a, b, c, d)] # showJSONs :: [(a, b, c, d)] -> JSValue #

# Encoding and Decoding

data Result a #

A type for parser results

Constructors

Ok a |
Error String |

Instances

Monad Result # |
Methods (>>=) :: Result a -> (a -> Result b) -> Result b # (>>) :: Result a -> Result b -> Result b # return :: a -> Result a # fail :: String -> Result a #
Functor Result # |
Methods fmap :: (a -> b) -> Result a -> Result b # (<$) :: a -> Result b -> Result a #
Applicative Result # |
Methods pure :: a -> Result a # (<*>) :: Result (a -> b) -> Result a -> Result b # liftA2 :: (a -> b -> c) -> Result a -> Result b -> Result c # (*>) :: Result a -> Result b -> Result b # (<*) :: Result a -> Result b -> Result a #
Alternative Result # |
Methods empty :: Result a # (<|>) :: Result a -> Result a -> Result a # some :: Result a -> Result [a] # many :: Result a -> Result [a] #
MonadPlus Result # |
Methods mzero :: Result a # mplus :: Result a -> Result a -> Result a #
Eq a => Eq (Result a) # |
Methods (==) :: Result a -> Result a -> Bool # (/=) :: Result a -> Result a -> Bool #
Show a => Show (Result a) # |
Methods showsPrec :: Int -> Result a -> ShowS # show :: Result a -> String # showList :: [Result a] -> ShowS #

encode :: JSON a => a -> String #

Encode a Haskell value into a string, in JSON format.

This is a superset of JSON, as types other than Array and Object are allowed at the top level.

decode :: JSON a => String -> Result a #

Decode a String representing a JSON value (either an object, array, bool, number, null)

This is a superset of JSON, as types other than Array and Object are allowed at the top level.

encodeStrict :: JSON a => a -> String #

Encode a value as a String in strict JSON format. This follows the spec, and requires all values at the top level to be wrapped in either an Array or Object. JSON types to be an Array or Object.

decodeStrict :: JSON a => String -> Result a #

Decode a String representing a strict JSON value. This follows the spec, and requires top level JSON types to be an Array or Object.

# Wrapper Types

data JSString #

Strings can be represented a little more efficiently in JSON

Instances

Eq JSString # |
Methods (==) :: JSString -> JSString -> Bool # (/=) :: JSString -> JSString -> Bool #
Ord JSString # |
Methods compare :: JSString -> JSString -> Ordering # (<) :: JSString -> JSString -> Bool # (<=) :: JSString -> JSString -> Bool # (>) :: JSString -> JSString -> Bool # (>=) :: JSString -> JSString -> Bool # max :: JSString -> JSString -> JSString # min :: JSString -> JSString -> JSString #
Read JSString # |
Methods readsPrec :: Int -> ReadS JSString # readList :: ReadS [JSString] # readPrec :: ReadPrec JSString # readListPrec :: ReadPrec [JSString] #
Show JSString # |
Methods showsPrec :: Int -> JSString -> ShowS # show :: JSString -> String # showList :: [JSString] -> ShowS #
JSKey JSString # |
Methods toJSKey :: JSString -> String # fromJSKey :: String -> Maybe JSString #
JSON JSString # |
Methods readJSON :: JSValue -> Result JSString # showJSON :: JSString -> JSValue # readJSONs :: JSValue -> Result [JSString] # showJSONs :: [JSString] -> JSValue #

toJSString :: String -> JSString #

Turn a Haskell string into a JSON string.

fromJSString :: JSString -> String #

data JSObject e #

As can association lists

Instances

Eq e => Eq (JSObject e) # |
Methods (==) :: JSObject e -> JSObject e -> Bool # (/=) :: JSObject e -> JSObject e -> Bool #
Ord e => Ord (JSObject e) # |
Methods compare :: JSObject e -> JSObject e -> Ordering # (<) :: JSObject e -> JSObject e -> Bool # (<=) :: JSObject e -> JSObject e -> Bool # (>) :: JSObject e -> JSObject e -> Bool # (>=) :: JSObject e -> JSObject e -> Bool # max :: JSObject e -> JSObject e -> JSObject e # min :: JSObject e -> JSObject e -> JSObject e #
Read e => Read (JSObject e) # |
Methods readsPrec :: Int -> ReadS (JSObject e) # readList :: ReadS [JSObject e] # readPrec :: ReadPrec (JSObject e) # readListPrec :: ReadPrec [JSObject e] #
Show e => Show (JSObject e) # |
Methods showsPrec :: Int -> JSObject e -> ShowS # show :: JSObject e -> String # showList :: [JSObject e] -> ShowS #
JSON a => JSON (JSObject a) # |
Methods readJSON :: JSValue -> Result (JSObject a) # showJSON :: JSObject a -> JSValue # readJSONs :: JSValue -> Result [JSObject a] # showJSONs :: [JSObject a] -> JSValue #

toJSObject :: [(String, a)] -> JSObject a #

Make JSON object out of an association list.

fromJSObject :: JSObject e -> [(String, e)] #

resultToEither :: Result a -> Either String a #

Map Results to Eithers

# Serialization to and from Strings.

## Reading JSON

readJSNull :: GetJSON JSValue #

Read the JSON null type

readJSBool :: GetJSON JSValue #

Read the JSON Bool type

readJSString :: GetJSON JSValue #

Read the JSON String type

readJSRational :: GetJSON Rational #

Read an Integer or Double in JSON format, returning a Rational

readJSArray :: GetJSON JSValue #

Read a list in JSON format

readJSObject :: GetJSON JSValue #

Read an object in JSON format

readJSValue :: GetJSON JSValue #

Read one of several possible JS types

## Writing JSON

showJSNull :: ShowS #

Write the JSON null type

showJSBool :: Bool -> ShowS #

Write the JSON Bool type

showJSArray :: [JSValue] -> ShowS #

Show a list in JSON format

showJSRational :: Rational -> ShowS #

Show a Rational in JSON format

showJSRational' :: Bool -> Rational -> ShowS #

showJSObject :: JSObject JSValue -> ShowS #

Show an association list in JSON format

showJSValue :: JSValue -> ShowS #

Show JSON values

## Instance helpers

makeObj :: [(String, JSValue)] -> JSValue #

valFromObj :: JSON a => String -> JSObject JSValue -> Result a #

Pull a value out of a JSON object.

class JSKey a where #

Haskell types that can be used as keys in JSON objects.

Minimal complete definition

toJSKey, fromJSKey

Methods

toJSKey :: a -> String #

fromJSKey :: String -> Maybe a #

Instances

JSKey Int # |
Methods toJSKey :: Int -> String # fromJSKey :: String -> Maybe Int #
JSKey String # |
Methods toJSKey :: String -> String # fromJSKey :: String -> Maybe String #
JSKey JSString # |
Methods toJSKey :: JSString -> String # fromJSKey :: String -> Maybe JSString #

encJSDict :: (JSKey a, JSON b) => [(a, b)] -> JSValue #

Encode an association list as `JSObject` value.

decJSDict :: (JSKey a, JSON b) => String -> JSValue -> Result [(a, b)] #

Decode a `JSObject` value into an association list.