Maintainer	Leon P Smith <leon@melding-monads.com>

Data.Json.Builder

Description

Data structure agnostic JSON serialization

Synopsis

Documentation

class Value a whereSource

The Value typeclass represents types that can be rendered into valid json syntax.

Methods

toJson :: a -> Json Source

Instances

Value Bool	renders as `true` or `false`
Value Double
Value Float
Value Int
Value Int8
Value Int16
Value Int32
Value Int64
Value Integer
Value Word
Value Word8
Value Word16
Value Word32
Value Word64
Value ()	renders as `null`
Value Text
Value Text
Value ByteString
Value ByteString
Value Array
Value Object
Value Escaped
Value Json
Value [Char]
Value a => Value [a]	renders as an `Array`
(JsString k, Value a) => Value (Map k a)	renders as an `Object`
(JsString k, Value a) => Value (HashMap k a)	renders as an `Object`

data Json Source

The Json type represents valid json syntax. It cannot be directly analyzed, however it can be rendered into a ByteString and used to as a component of an array or an object to build a bigger json value.

Instances

Value Json

toBuilder :: Value a => a -> Builder Source

toJsonBS :: Value a => a -> ByteString Source

toJsonLBS :: Value a => a -> ByteString Source

data Array Source

The Array type represents syntax for a json array. It has been given a singleton constructor element and an instance of Monoid, so that mempty represents the empty array and mappend concatinates two arrays. Arbitrary arrays can be constructed using these operators.

Instances

Monoid Array
Value Array
JsArray Array

element :: Value a => a -> Array Source

The element function constructs a json array consisting of exactly one value. These arrays can be concatinated using mappend.

data Object Source

The Object type represents syntax for a json object. It has a singleton constructor row, and an instance of Monoid, so that mempty represents the empty object and mappend concatinates two objects. Arbitrary objects can be constructed using these operators.

Note that duplicate field names will appear in the output, so it is up to the user of this interface to avoid duplicate field names.

Instances

Monoid Object
Value Object
JsObject Object

row :: (JsString k, Value a) => k -> a -> Object Source

The row function constructs a json object consisting of exactly one field. These objects can be concatinated using mappend.

class Value a => JsString a whereSource

The String typeclass represents types that render into json string syntax. They are special because only strings can appear as field names of json objects.

Methods

escape :: a -> Escaped Source

Instances

JsString Text
JsString Text
JsString ByteString	must be UTF-8 encoded
JsString ByteString	must be UTF-8 encoded
JsString Escaped
JsString [Char]

data Escaped Source

The Escaped type represents json string syntax. The purpose of this type is so that json strings can be efficiently constructed from multiple Haskell strings without superfluous conversions or concatinations.

Internally, it is just a Builder value which must produce a UTF-8 encoded bytestring with backslashes, quotes, and control characters appropriately escaped. It also must not render the opening or closing quote, which are instead rendered by toJson.

Instances

Monoid Escaped
JsString Escaped
Value Escaped

class JsArray a whereSource

Methods

toArray :: a -> Array Source

Instances

JsArray Array
Value a => JsArray [a]

class JsObject a whereSource

Methods

toObject :: a -> Object Source

Instances

JsObject Object
(JsString k, Value a) => JsObject (Map k a)
(JsString k, Value a) => JsObject (HashMap k a)

class Monoid a where

The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following laws:

```
mappend mempty x = x
```
```
mappend x mempty = x
```

mappend x (mappend y z) = mappend (mappend x y) z

```
mconcat = foldr mappend mempty
```

The method names refer to the monoid of lists under concatenation, but there are many other instances.

Minimal complete definition: mempty and mappend.

Some types can be viewed as a monoid in more than one way, e.g. both addition and multiplication on numbers. In such cases we often define newtypes and make those instances of Monoid, e.g. Sum and Product.

Methods

mempty :: a

Identity of mappend

mappend :: a -> a -> a

An associative operation

mconcat :: [a] -> a

Fold a list using the monoid. For most types, the default definition for mconcat will be used, but the function is included in the class definition so that an optimized version can be provided for specific types.

Instances

Monoid Ordering
Monoid ()
Monoid All
Monoid Any
Monoid Text
Monoid Text
Monoid ByteString
Monoid ByteString
Monoid Poke
Monoid Write
Monoid Builder
Monoid CommaMonoid
Monoid Array
Monoid Object
Monoid Escaped
Monoid [a]
Monoid a => Monoid (Dual a)
Monoid (Endo a)
Num a => Monoid (Sum a)
Num a => Monoid (Product a)
Monoid (First a)
Monoid (Last a)
Monoid a => Monoid (Maybe a)	Lift a semigroup into `Maybe` forming a `Monoid` according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup `S` may be turned into a monoid simply by adjoining an element `e` not in `S` and defining `ee = e` and `es = s = s*e` for all `s S`." Since there is no "Semigroup" typeclass providing just `mappend`, we use `Monoid` instead.
Monoid (Vector a)
Monoid b => Monoid (a -> b)
(Monoid a, Monoid b) => Monoid (a, b)
Ord k => Monoid (Map k v)
Eq k => Monoid (HashMap k v)
(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c)
(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d)
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e)