aeson-extra-0.2.1.0: Extra goodies for aeson

Copyright(C) 2015 Oleg Grenrus
LicenseBSD3
MaintainerOleg Grenrus <oleg.grenrus@iki.fi>
Safe HaskellNone
LanguageHaskell2010

Data.Aeson.Extra

Contents

Description

More or less useful newtypes for writing FromJSON & ToJSON instances

Synopsis

Generic maps

newtype M a Source

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

Instances

Functor M Source 

Methods

fmap :: (a -> b) -> M a -> M b

(<$) :: a -> M b -> M a

Foldable M Source 

Methods

fold :: Monoid m => M m -> m

foldMap :: Monoid m => (a -> m) -> M a -> m

foldr :: (a -> b -> b) -> b -> M a -> b

foldr' :: (a -> b -> b) -> b -> M a -> b

foldl :: (b -> a -> b) -> b -> M a -> b

foldl' :: (b -> a -> b) -> b -> M a -> b

foldr1 :: (a -> a -> a) -> M a -> a

foldl1 :: (a -> a -> a) -> M a -> a

toList :: M a -> [a]

null :: M a -> Bool

length :: M a -> Int

elem :: Eq a => a -> M a -> Bool

maximum :: Ord a => M a -> a

minimum :: Ord a => M a -> a

sum :: Num a => M a -> a

product :: Num a => M a -> a

Traversable M Source 

Methods

traverse :: Applicative f => (a -> f b) -> M a -> f (M b)

sequenceA :: Applicative f => M (f a) -> f (M a)

mapM :: Monad m => (a -> m b) -> M a -> m (M b)

sequence :: Monad m => M (m a) -> m (M a)

Eq a => Eq (M a) Source 

Methods

(==) :: M a -> M a -> Bool

(/=) :: M a -> M a -> Bool

Ord a => Ord (M a) Source 

Methods

compare :: M a -> M a -> Ordering

(<) :: M a -> M a -> Bool

(<=) :: M a -> M a -> Bool

(>) :: M a -> M a -> Bool

(>=) :: M a -> M a -> Bool

max :: M a -> M a -> M a

min :: M a -> M a -> M a

Read a => Read (M a) Source 

Methods

readsPrec :: Int -> ReadS (M a)

readList :: ReadS [M a]

readPrec :: ReadPrec (M a)

readListPrec :: ReadPrec [M a]

Show a => Show (M a) Source 

Methods

showsPrec :: Int -> M a -> ShowS

show :: M a -> String

showList :: [M a] -> ShowS

ToJSONMap m k v => ToJSON (M m) Source 

Methods

toJSON :: M m -> Value

toEncoding :: M m -> Encoding

FromJSONMap m k v => FromJSON (M m) Source 

Methods

parseJSON :: Value -> Parser (M m)

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

Instances

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

Instances

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

Symbol tag

data SymTag s Source

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) Source 

Methods

minBound :: SymTag s

maxBound :: SymTag s

Enum (SymTag s) Source 

Methods

succ :: SymTag s -> SymTag s

pred :: SymTag s -> SymTag s

toEnum :: Int -> SymTag s

fromEnum :: SymTag s -> Int

enumFrom :: SymTag s -> [SymTag s]

enumFromThen :: SymTag s -> SymTag s -> [SymTag s]

enumFromTo :: SymTag s -> SymTag s -> [SymTag s]

enumFromThenTo :: SymTag s -> SymTag s -> SymTag s -> [SymTag s]

Eq (SymTag s) Source 

Methods

(==) :: SymTag s -> SymTag s -> Bool

(/=) :: SymTag s -> SymTag s -> Bool

Ord (SymTag s) Source 

Methods

compare :: SymTag s -> SymTag s -> Ordering

(<) :: SymTag s -> SymTag s -> Bool

(<=) :: SymTag s -> SymTag s -> Bool

(>) :: SymTag s -> SymTag s -> Bool

(>=) :: SymTag s -> SymTag s -> Bool

max :: SymTag s -> SymTag s -> SymTag s

min :: SymTag s -> SymTag s -> SymTag s

Read (SymTag s) Source 
Show (SymTag s) Source 

Methods

showsPrec :: Int -> SymTag s -> ShowS

show :: SymTag s -> String

showList :: [SymTag s] -> ShowS

KnownSymbol s => ToJSON (SymTag s) Source 
KnownSymbol s => FromJSON (SymTag s) Source 

Methods

parseJSON :: Value -> Parser (SymTag s)

Singleton object

newtype SingObject s a Source

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) Source 

Methods

fmap :: (a -> b) -> SingObject s a -> SingObject s b

(<$) :: a -> SingObject s b -> SingObject s a

Foldable (SingObject s) Source 

Methods

fold :: Monoid m => SingObject s m -> m

foldMap :: Monoid m => (a -> m) -> SingObject s a -> m

foldr :: (a -> b -> b) -> b -> SingObject s a -> b

foldr' :: (a -> b -> b) -> b -> SingObject s a -> b

foldl :: (b -> a -> b) -> b -> SingObject s a -> b

foldl' :: (b -> a -> b) -> b -> SingObject s a -> b

foldr1 :: (a -> a -> a) -> SingObject s a -> a

foldl1 :: (a -> a -> a) -> SingObject s a -> a

toList :: SingObject s a -> [a]

null :: SingObject s a -> Bool

length :: SingObject s a -> Int

elem :: Eq a => a -> SingObject s a -> Bool

maximum :: Ord a => SingObject s a -> a

minimum :: Ord a => SingObject s a -> a

sum :: Num a => SingObject s a -> a

product :: Num a => SingObject s a -> a

Traversable (SingObject s) Source 

Methods

traverse :: Applicative f => (a -> f b) -> SingObject s a -> f (SingObject s b)

sequenceA :: Applicative f => SingObject s (f a) -> f (SingObject s a)

mapM :: Monad m => (a -> m b) -> SingObject s a -> m (SingObject s b)

sequence :: Monad m => SingObject s (m a) -> m (SingObject s a)

Eq a => Eq (SingObject s a) Source 

Methods

(==) :: SingObject s a -> SingObject s a -> Bool

(/=) :: SingObject s a -> SingObject s a -> Bool

Ord a => Ord (SingObject s a) Source 

Methods

compare :: SingObject s a -> SingObject s a -> Ordering

(<) :: SingObject s a -> SingObject s a -> Bool

(<=) :: SingObject s a -> SingObject s a -> Bool

(>) :: SingObject s a -> SingObject s a -> Bool

(>=) :: SingObject s a -> SingObject s a -> Bool

max :: SingObject s a -> SingObject s a -> SingObject s a

min :: SingObject s a -> SingObject s a -> SingObject s a

Read a => Read (SingObject s a) Source 
Show a => Show (SingObject s a) Source 

Methods

showsPrec :: Int -> SingObject s a -> ShowS

show :: SingObject s a -> String

showList :: [SingObject s a] -> ShowS

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

Methods

parseJSON :: Value -> Parser (SingObject s a)

CollapsedList

newtype CollapsedList f a Source

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) Source 

Methods

fmap :: (a -> b) -> CollapsedList f a -> CollapsedList f b

(<$) :: a -> CollapsedList f b -> CollapsedList f a

Foldable f => Foldable (CollapsedList f) Source 

Methods

fold :: Monoid m => CollapsedList f m -> m

foldMap :: Monoid m => (a -> m) -> CollapsedList f a -> m

foldr :: (a -> b -> b) -> b -> CollapsedList f a -> b

foldr' :: (a -> b -> b) -> b -> CollapsedList f a -> b

foldl :: (b -> a -> b) -> b -> CollapsedList f a -> b

foldl' :: (b -> a -> b) -> b -> CollapsedList f a -> b

foldr1 :: (a -> a -> a) -> CollapsedList f a -> a

foldl1 :: (a -> a -> a) -> CollapsedList f a -> a

toList :: CollapsedList f a -> [a]

null :: CollapsedList f a -> Bool

length :: CollapsedList f a -> Int

elem :: Eq a => a -> CollapsedList f a -> Bool

maximum :: Ord a => CollapsedList f a -> a

minimum :: Ord a => CollapsedList f a -> a

sum :: Num a => CollapsedList f a -> a

product :: Num a => CollapsedList f a -> a

Traversable f => Traversable (CollapsedList f) Source 

Methods

traverse :: Applicative b => (a -> b c) -> CollapsedList f a -> b (CollapsedList f c)

sequenceA :: Applicative a => CollapsedList f (a b) -> a (CollapsedList f b)

mapM :: Monad m => (a -> m b) -> CollapsedList f a -> m (CollapsedList f b)

sequence :: Monad m => CollapsedList f (m a) -> m (CollapsedList f a)

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

Methods

(==) :: CollapsedList f a -> CollapsedList f a -> Bool

(/=) :: CollapsedList f a -> CollapsedList f a -> Bool

Ord (f a) => Ord (CollapsedList f a) Source 
Read (f a) => Read (CollapsedList f a) Source 
Show (f a) => Show (CollapsedList f a) Source 
(ToJSON a, ToJSON (f a), Foldable f) => ToJSON (CollapsedList f a) Source 
(FromJSON a, FromJSON (f a), Alternative f) => FromJSON (CollapsedList f a) Source 

Methods

parseJSON :: Value -> Parser (CollapsedList f a)

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

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])

Re-exports