Data.Aeson.Extra

More or less useful newtypes for writing FromJSON & ToJSON instances

Strict encoding

encodeStrict :: ToJSON a => a -> ByteString

Like encode, but produces strict ByteString.

Since: 0.2.3.0

Generic maps

newtype M a

A wrapper type to parse arbitrary maps

λ > decode "{\"1\": 1, \"2\": 2}" :: Maybe (M (H.HashMap Int Int))
Just (M {getMap = fromList [(1,1),(2,2)]})

Constructors

M

Fields

getMap :: a

Instances

Functor M

Foldable M

Traversable M

Eq a => Eq (M a)

Ord a => Ord (M a)

Read a => Read (M a)

Show a => Show (M a)

ToJSONMap m k v => ToJSON (M m)

FromJSONMap m k v => FromJSON (M m)

class FromJSONKey a where

Methods

parseJSONKey :: Text -> Parser a

Instances

FromJSONKey Int

FromJSONKey Integer

FromJSONKey String

FromJSONKey Text

FromJSONKey Text

parseIntegralJSONKey :: Integral a => Text -> Parser a

class FromJSONMap m k v | m -> k v where

Methods

parseJSONMap :: HashMap Text Value -> Parser m

Instances

(Eq k, Hashable k, FromJSONKey k, FromJSON v) => FromJSONMap (HashMap k v) k v

(Ord k, FromJSONKey k, FromJSON v) => FromJSONMap (Map k v) k v

class ToJSONKey a where

Methods

toJSONKey :: a -> Text

Instances

ToJSONKey Int

ToJSONKey Integer

ToJSONKey String

ToJSONKey Text

ToJSONKey Text

class ToJSONMap m k v | m -> k v where

Methods

toJSONMap :: m -> HashMap Text Value

Instances

(ToJSONKey k, ToJSON v) => ToJSONMap (HashMap k v) k v

(ToJSONKey k, ToJSON v) => ToJSONMap (Map k v) k v

Symbol tag

data SymTag s

Singleton string encoded and decoded as ifself.

λ> encode (SymTag :: SymTag "foobar")
"\"foobar\""

decode "\"foobar\"" :: Maybe (SymTag "foobar")
Just SymTag

decode "\"foobar\"" :: Maybe (SymTag "barfoo")
Nothing

Available with: base >=4.7

Constructors

SymTag

Instances

Bounded (SymTag s)

Enum (SymTag s)

Eq (SymTag s)

Ord (SymTag s)

Read (SymTag s)

Show (SymTag s)

KnownSymbol s => ToJSON (SymTag s)

KnownSymbol s => FromJSON (SymTag s)

Singleton object

newtype SingObject s a

Singleton value object

λ > decode "{\"value\": 42 }" :: Maybe (SingObject "value" Int)
Just (SingObject 42)

λ > encode (SingObject 42 :: SingObject "value" Int)
"{\"value\":42}"

Available with: base >=4.7

Constructors

SingObject a

Instances

Functor (SingObject s)

Foldable (SingObject s)

Traversable (SingObject s)

Eq a => Eq (SingObject s a)

Ord a => Ord (SingObject s a)

Read a => Read (SingObject s a)

Show a => Show (SingObject s a)

(KnownSymbol s, ToJSON a) => ToJSON (SingObject s a)

(KnownSymbol s, FromJSON a) => FromJSON (SingObject s a)

mkSingObject :: Proxy s -> a -> SingObject s a

getSingObject :: Proxy s -> SingObject s a -> a

CollapsedList

newtype CollapsedList f a

Collapsed list, singleton is represented as the value itself in JSON encoding.

λ > decode "null" :: Maybe (CollapsedList [Int] Int)
Just (CollapsedList [])
λ > decode "42" :: Maybe (CollapsedList [Int] Int)
Just (CollapsedList [42])
λ > decode "[1, 2, 3]" :: Maybe (CollapsedList [Int] Int)
Just (CollapsedList [1,2,3])

λ > encode (CollapsedList ([] :: [Int]))
"null"
λ > encode (CollapsedList ([42] :: [Int]))
"42"
λ > encode (CollapsedList ([1, 2, 3] :: [Int]))
"[1,2,3]"

Documentation rely on f Alternative instance behaving like lists'.

Constructors

CollapsedList (f a)

Instances

Functor f => Functor (CollapsedList f)

Foldable f => Foldable (CollapsedList f)

Traversable f => Traversable (CollapsedList f)

Eq (f a) => Eq (CollapsedList f a)

Ord (f a) => Ord (CollapsedList f a)

Read (f a) => Read (CollapsedList f a)

Show (f a) => Show (CollapsedList f a)

(ToJSON a, ToJSON (f a), Foldable f) => ToJSON (CollapsedList f a)

(FromJSON a, FromJSON (f a), Alternative f) => FromJSON (CollapsedList f a)

getCollapsedList :: CollapsedList f a -> f a

parseCollapsedList :: (FromJSON a, FromJSON (f a), Alternative f) => Object -> Text -> Parser (f a)

Parses possibly collapsed array value from the object's field.

λ > newtype V = V [Int] deriving (Show)
λ > instance FromJSON V where parseJSON = withObject "V" $ \obj -> V <$> parseCollapsedList obj "value"
λ > decode "{}" :: Maybe V
Just (V [])
λ > decode "{\"value\": null}" :: Maybe V
Just (V [])
λ > decode "{\"value\": 42}" :: Maybe V
Just (V [42])
λ > decode "{\"value\": [1, 2, 3, 4]}" :: Maybe V
Just (V [1,2,3,4])

UTCTime

newtype U

A type to parse UTCTime

FromJSON instance accepts for example:

2015-09-07T08:16:40.807Z
2015-09-07 11:16:40.807 +03:00

Latter format is accepted by aeson staring from version 0.10.0.0.

See https://github.com/bos/aeson/blob/4667ef1029a373cf4510f7deca147c357c6d8947/Data/Aeson/Parser/Time.hs#L150

Since: aeson-extra-0.2.2.0

Constructors

U

Fields

getU :: UTCTime

Instances

Eq U

Ord U

Read U

Show U

ToJSON U

FromJSON U

newtype Z

A type to parse ZonedTime

Since: aeson-extra-0.2.2.0

Constructors

Z

Fields

getZ :: ZonedTime

Instances

Read Z

Show Z

ToJSON Z

FromJSON Z

Algebra

data ValueF a

An algebra of Value

Since: aeson-extra-0.3.1.0

Constructors

ObjectF (ObjectF a)

ArrayF !(ArrayF a)

StringF !Text

NumberF !Scientific

BoolF !Bool

NullF

Instances

Functor ValueF

Foldable ValueF

Traversable ValueF

Eq a => Eq (ValueF a)

Data a => Data (ValueF a)

Read a => Read (ValueF a)

Show a => Show (ValueF a)

type ObjectF a = HashMap Text a

A JSON "object" (key/value map).

Since: aeson-extra-0.3.1.0

type ArrayF a = Vector a

A JSON "array" (sequence).

Since: aeson-extra-0.3.1.0

Merge

merge :: (forall a. (a -> a -> a) -> ValueF a -> ValueF a -> ValueF a) -> Value -> Value -> Value

Generic merge.

For example https://lodash.com/docs#merge:

lodashMerge :: Value -> Value -> Value
lodashMerge x y = merge lodashMergeAlg x y

lodashMergeAlg :: (a -> a -> a) -> ValueF a -> ValueF a -> ValueF a
lodashMergeAlg r a' b' = case (a', b') of
    (ObjectF a, ObjectF b) -> ObjectF $ alignWith f a b
    (ArrayF a,  ArrayF b)  -> ArrayF $ alignWith f a b
    (_,         b)         -> b
  where f (These x y) = r x y
        f (This x)    = x
        f (That x)    = x

Since: aeson-extra-0.3.1.0

Template Haskell

mkValue :: String -> Q Exp

Create a Value from string representation.

This is useful in tests.

Since: aeson-extra-0.3.1.0

mkValue' :: String -> Q Exp

Like mkValue, but replace single quotes with double quotes before.

> $(mkValue' "{'a': 2 }")
Object (fromList [("a",Number 2.0)])

Since: aeson-extra-0.3.1.0

Re-exports

module Data.Aeson.Compat