Web.Spock.Api

Documentation

data Endpoint p i o where

Describes an endpoint with path parameters, an optional json body and a json response

Constructors

MethodGet :: (ToJSON o, FromJSON o) => Path p Open -> Endpoint p Nothing o

MethodPost :: (ToJSON i, FromJSON i, ToJSON o, FromJSON o) => Proxy (i -> o) -> Path p Open -> Endpoint p (Just i) o

MethodPut :: (ToJSON i, FromJSON i, ToJSON o, FromJSON o) => Proxy (i -> o) -> Path p Open -> Endpoint p (Just i) o

data Proxy k t :: forall k. k -> *

A concrete, poly-kinded proxy type

Constructors

Proxy

Instances

Monad (Proxy *)

Methods

(>>=) :: Proxy * a -> (a -> Proxy * b) -> Proxy * b

(>>) :: Proxy * a -> Proxy * b -> Proxy * b

return :: a -> Proxy * a

fail :: String -> Proxy * a

Functor (Proxy *)

Methods

fmap :: (a -> b) -> Proxy * a -> Proxy * b

(<$) :: a -> Proxy * b -> Proxy * a

Applicative (Proxy *)

Methods

pure :: a -> Proxy * a

(<*>) :: Proxy * (a -> b) -> Proxy * a -> Proxy * b

(*>) :: Proxy * a -> Proxy * b -> Proxy * b

(<*) :: Proxy * a -> Proxy * b -> Proxy * a

Generic1 (Proxy *)

Associated Types

type Rep1 (Proxy * :: * -> *) :: * -> *

Methods

from1 :: Proxy * a -> Rep1 (Proxy *) a

to1 :: Rep1 (Proxy *) a -> Proxy * a

ToJSON1 (Proxy *)

Methods

liftToJSON :: (a -> Value) -> ([a] -> Value) -> Proxy * a -> Value

liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Proxy * a] -> Value

liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Proxy * a -> Encoding

liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Proxy * a] -> Encoding

FromJSON1 (Proxy *)

Methods

liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Proxy * a)

liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Proxy * a]

Alternative (Proxy *)

Methods

empty :: Proxy * a

(<|>) :: Proxy * a -> Proxy * a -> Proxy * a

some :: Proxy * a -> Proxy * [a]

many :: Proxy * a -> Proxy * [a]

MonadPlus (Proxy *)

Methods

mzero :: Proxy * a

mplus :: Proxy * a -> Proxy * a -> Proxy * a

Bounded (Proxy k s)

Methods

minBound :: Proxy k s

maxBound :: Proxy k s

Enum (Proxy k s)

Methods

succ :: Proxy k s -> Proxy k s

pred :: Proxy k s -> Proxy k s

toEnum :: Int -> Proxy k s

fromEnum :: Proxy k s -> Int

enumFrom :: Proxy k s -> [Proxy k s]

enumFromThen :: Proxy k s -> Proxy k s -> [Proxy k s]

enumFromTo :: Proxy k s -> Proxy k s -> [Proxy k s]

enumFromThenTo :: Proxy k s -> Proxy k s -> Proxy k s -> [Proxy k s]

Eq (Proxy k s)

Methods

(==) :: Proxy k s -> Proxy k s -> Bool

(/=) :: Proxy k s -> Proxy k s -> Bool

Ord (Proxy k s)

Methods

compare :: Proxy k s -> Proxy k s -> Ordering

(<) :: Proxy k s -> Proxy k s -> Bool

(<=) :: Proxy k s -> Proxy k s -> Bool

(>) :: Proxy k s -> Proxy k s -> Bool

(>=) :: Proxy k s -> Proxy k s -> Bool

max :: Proxy k s -> Proxy k s -> Proxy k s

min :: Proxy k s -> Proxy k s -> Proxy k s

Read (Proxy k s)

Methods

readsPrec :: Int -> ReadS (Proxy k s)

readList :: ReadS [Proxy k s]

readPrec :: ReadPrec (Proxy k s)

readListPrec :: ReadPrec [Proxy k s]

Show (Proxy k s)

Methods

showsPrec :: Int -> Proxy k s -> ShowS

show :: Proxy k s -> String

showList :: [Proxy k s] -> ShowS

Ix (Proxy k s)

Methods

range :: (Proxy k s, Proxy k s) -> [Proxy k s]

index :: (Proxy k s, Proxy k s) -> Proxy k s -> Int

unsafeIndex :: (Proxy k s, Proxy k s) -> Proxy k s -> Int

inRange :: (Proxy k s, Proxy k s) -> Proxy k s -> Bool

rangeSize :: (Proxy k s, Proxy k s) -> Int

unsafeRangeSize :: (Proxy k s, Proxy k s) -> Int

Generic (Proxy k t)

Associated Types

type Rep (Proxy k t) :: * -> *

Methods

from :: Proxy k t -> Rep (Proxy k t) x

to :: Rep (Proxy k t) x -> Proxy k t

Monoid (Proxy k s)

Methods

mempty :: Proxy k s

mappend :: Proxy k s -> Proxy k s -> Proxy k s

mconcat :: [Proxy k s] -> Proxy k s

ToJSON (Proxy k a)

Methods

toJSON :: Proxy k a -> Value

toEncoding :: Proxy k a -> Encoding

toJSONList :: [Proxy k a] -> Value

toEncodingList :: [Proxy k a] -> Encoding

FromJSON (Proxy k a)

Methods

parseJSON :: Value -> Parser (Proxy k a)

parseJSONList :: Value -> Parser [Proxy k a]

NFData (Proxy k a)

Since: 1.4.0.0

Methods

rnf :: Proxy k a -> ()

type Rep1 (Proxy *)

type Rep1 (Proxy *) = D1 (MetaData "Proxy" "Data.Proxy" "base" False) (C1 (MetaCons "Proxy" PrefixI False) U1)

type Rep (Proxy k t)

type Rep (Proxy k t) = D1 (MetaData "Proxy" "Data.Proxy" "base" False) (C1 (MetaCons "Proxy" PrefixI False) U1)

type family MaybeToList (a :: Maybe *) :: [*] where ...

Equations

MaybeToList (Just * r) = (:) * r ([] *)

MaybeToList (Nothing *) = [] *

(<//>) :: Path as Open -> Path bs ps -> Path (Append as bs) ps

var :: (Typeable * a, FromHttpApiData a) => Path ((:) * a ([] *)) Open

A route parameter

data Path as pathState :: [*] -> PathState -> * where

Constructors

Empty :: Path ([] *) Open

StaticCons :: Path as pathState

VarCons :: Path ((:) * a as1) pathState

Wildcard :: Path ((:) * Text as1) Closed

Instances

((~) [*] a ([] *), (~) PathState pathState Open) => IsString (Path a pathState)

Methods

fromString :: String -> Path a pathState

renderRoute :: AllHave ToHttpApiData as => Path as Open -> HVect as -> Text

class Generic a

Representable types of kind *. This class is derivable in GHC with the DeriveGeneric flag on.

Minimal complete definition

from, to

Instances

Generic Bool

Associated Types

type Rep Bool :: * -> *

Methods

from :: Bool -> Rep Bool x

to :: Rep Bool x -> Bool

Generic Ordering

Associated Types

type Rep Ordering :: * -> *

Methods

from :: Ordering -> Rep Ordering x

to :: Rep Ordering x -> Ordering

Generic ()

Associated Types

type Rep () :: * -> *

Methods

from :: () -> Rep () x

to :: Rep () x -> ()

Generic Version

Associated Types

type Rep Version :: * -> *

Methods

from :: Version -> Rep Version x

to :: Rep Version x -> Version

Generic Fixity

Associated Types

type Rep Fixity :: * -> *

Methods

from :: Fixity -> Rep Fixity x

to :: Rep Fixity x -> Fixity

Generic Associativity

Associated Types

type Rep Associativity :: * -> *

Methods

from :: Associativity -> Rep Associativity x

to :: Rep Associativity x -> Associativity

Generic SourceUnpackedness

Associated Types

type Rep SourceUnpackedness :: * -> *

Methods

from :: SourceUnpackedness -> Rep SourceUnpackedness x

to :: Rep SourceUnpackedness x -> SourceUnpackedness

Generic SourceStrictness

Associated Types

type Rep SourceStrictness :: * -> *

Methods

from :: SourceStrictness -> Rep SourceStrictness x

to :: Rep SourceStrictness x -> SourceStrictness

Generic DecidedStrictness

Associated Types

type Rep DecidedStrictness :: * -> *

Methods

from :: DecidedStrictness -> Rep DecidedStrictness x

to :: Rep DecidedStrictness x -> DecidedStrictness

Generic [a]

Associated Types

type Rep [a] :: * -> *

Methods

from :: [a] -> Rep [a] x

to :: Rep [a] x -> [a]

Generic (Maybe a)

Associated Types

type Rep (Maybe a) :: * -> *

Methods

from :: Maybe a -> Rep (Maybe a) x

to :: Rep (Maybe a) x -> Maybe a

Generic (V1 p)

Associated Types

type Rep (V1 p) :: * -> *

Methods

from :: V1 p -> Rep (V1 p) x

to :: Rep (V1 p) x -> V1 p

Generic (U1 p)

Associated Types

type Rep (U1 p) :: * -> *

Methods

from :: U1 p -> Rep (U1 p) x

to :: Rep (U1 p) x -> U1 p

Generic (Par1 p)

Associated Types

type Rep (Par1 p) :: * -> *

Methods

from :: Par1 p -> Rep (Par1 p) x

to :: Rep (Par1 p) x -> Par1 p

Generic (Complex a)

Associated Types

type Rep (Complex a) :: * -> *

Methods

from :: Complex a -> Rep (Complex a) x

to :: Rep (Complex a) x -> Complex a

Generic (Either a b)

Associated Types

type Rep (Either a b) :: * -> *

Methods

from :: Either a b -> Rep (Either a b) x

to :: Rep (Either a b) x -> Either a b

Generic (Rec1 f p)

Associated Types

type Rep (Rec1 f p) :: * -> *

Methods

from :: Rec1 f p -> Rep (Rec1 f p) x

to :: Rep (Rec1 f p) x -> Rec1 f p

Generic (URec Char p)

Associated Types

type Rep (URec Char p) :: * -> *

Methods

from :: URec Char p -> Rep (URec Char p) x

to :: Rep (URec Char p) x -> URec Char p

Generic (URec Double p)

Associated Types

type Rep (URec Double p) :: * -> *

Methods

from :: URec Double p -> Rep (URec Double p) x

to :: Rep (URec Double p) x -> URec Double p

Generic (URec Float p)

Associated Types

type Rep (URec Float p) :: * -> *

Methods

from :: URec Float p -> Rep (URec Float p) x

to :: Rep (URec Float p) x -> URec Float p

Generic (URec Int p)

Associated Types

type Rep (URec Int p) :: * -> *

Methods

from :: URec Int p -> Rep (URec Int p) x

to :: Rep (URec Int p) x -> URec Int p

Generic (URec Word p)

Associated Types

type Rep (URec Word p) :: * -> *

Methods

from :: URec Word p -> Rep (URec Word p) x

to :: Rep (URec Word p) x -> URec Word p

Generic (URec (Ptr ()) p)

Associated Types

type Rep (URec (Ptr ()) p) :: * -> *

Methods

from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x

to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p

Generic (a, b)

Associated Types

type Rep (a, b) :: * -> *

Methods

from :: (a, b) -> Rep (a, b) x

to :: Rep (a, b) x -> (a, b)

Generic (Proxy k t)

Associated Types

type Rep (Proxy k t) :: * -> *

Methods

from :: Proxy k t -> Rep (Proxy k t) x

to :: Rep (Proxy k t) x -> Proxy k t

Generic (K1 i c p)

Associated Types

type Rep (K1 i c p) :: * -> *

Methods

from :: K1 i c p -> Rep (K1 i c p) x

to :: Rep (K1 i c p) x -> K1 i c p

Generic ((:+:) f g p)

Associated Types

type Rep ((:+:) f g p) :: * -> *

Methods

from :: (f :+: g) p -> Rep ((f :+: g) p) x

to :: Rep ((f :+: g) p) x -> (f :+: g) p

Generic ((:*:) f g p)

Associated Types

type Rep ((:*:) f g p) :: * -> *

Methods

from :: (f :*: g) p -> Rep ((f :*: g) p) x

to :: Rep ((f :*: g) p) x -> (f :*: g) p

Generic ((:.:) f g p)

Associated Types

type Rep ((:.:) f g p) :: * -> *

Methods

from :: (f :.: g) p -> Rep ((f :.: g) p) x

to :: Rep ((f :.: g) p) x -> (f :.: g) p

Generic (a, b, c)

Associated Types

type Rep (a, b, c) :: * -> *

Methods

from :: (a, b, c) -> Rep (a, b, c) x

to :: Rep (a, b, c) x -> (a, b, c)

Generic (M1 i c f p)

Associated Types

type Rep (M1 i c f p) :: * -> *

Methods

from :: M1 i c f p -> Rep (M1 i c f p) x

to :: Rep (M1 i c f p) x -> M1 i c f p

Generic (a, b, c, d)

Associated Types

type Rep (a, b, c, d) :: * -> *

Methods

from :: (a, b, c, d) -> Rep (a, b, c, d) x

to :: Rep (a, b, c, d) x -> (a, b, c, d)

Generic (a, b, c, d, e)

Associated Types

type Rep (a, b, c, d, e) :: * -> *

Methods

from :: (a, b, c, d, e) -> Rep (a, b, c, d, e) x

to :: Rep (a, b, c, d, e) x -> (a, b, c, d, e)

Generic (a, b, c, d, e, f)

Associated Types

type Rep (a, b, c, d, e, f) :: * -> *

Methods

from :: (a, b, c, d, e, f) -> Rep (a, b, c, d, e, f) x

to :: Rep (a, b, c, d, e, f) x -> (a, b, c, d, e, f)

Generic (a, b, c, d, e, f, g)

Associated Types

type Rep (a, b, c, d, e, f, g) :: * -> *

Methods

from :: (a, b, c, d, e, f, g) -> Rep (a, b, c, d, e, f, g) x

to :: Rep (a, b, c, d, e, f, g) x -> (a, b, c, d, e, f, g)

class ToJSON a

A type that can be converted to JSON.

An example type and instance:

-- Allow ourselves to write Text literals.
{-# LANGUAGE OverloadedStrings #-}

data Coord = Coord { x :: Double, y :: Double }

instance ToJSON Coord where
  toJSON (Coord x y) = object ["x" .= x, "y" .= y]

  toEncoding (Coord x y) = pairs ("x" .= x <> "y" .= y)

Instead of manually writing your ToJSON instance, there are two options to do it automatically:

• Data.Aeson.TH provides Template Haskell functions which will derive an instance at compile time. The generated instance is optimized for your type so will probably be more efficient than the following two options:
• The compiler can provide a default generic implementation for toJSON.

To use the second, simply add a deriving Generic clause to your datatype and declare a ToJSON instance for your datatype without giving definitions for toJSON or toEncoding.

For example, the previous example can be simplified to a more minimal instance:

{-# LANGUAGE DeriveGeneric #-}

import GHC.Generics

data Coord = Coord { x :: Double, y :: Double } deriving Generic

instance ToJSON Coord where
    toEncoding = genericToEncoding defaultOptions

Why do we provide an implementation for toEncoding here? The toEncoding function is a relatively new addition to this class. To allow users of older versions of this library to upgrade without having to edit all of their instances or encounter surprising incompatibilities, the default implementation of toEncoding uses toJSON. This produces correct results, but since it performs an intermediate conversion to a Value, it will be less efficient than directly emitting an Encoding. Our one-liner definition of toEncoding above bypasses the intermediate Value.

If DefaultSignatures doesn't give exactly the results you want, you can customize the generic encoding with only a tiny amount of effort, using genericToJSON and genericToEncoding with your preferred Options:

instance ToJSON Coord where
    toJSON     = genericToJSON defaultOptions
    toEncoding = genericToEncoding defaultOptions

Instances

ToJSON Bool

Methods

toJSON :: Bool -> Value

toEncoding :: Bool -> Encoding

toJSONList :: [Bool] -> Value

toEncodingList :: [Bool] -> Encoding

ToJSON Char

Methods

toJSON :: Char -> Value

toEncoding :: Char -> Encoding

toJSONList :: [Char] -> Value

toEncodingList :: [Char] -> Encoding

ToJSON Double

Methods

toJSON :: Double -> Value

toEncoding :: Double -> Encoding

toJSONList :: [Double] -> Value

toEncodingList :: [Double] -> Encoding

ToJSON Float

Methods

toJSON :: Float -> Value

toEncoding :: Float -> Encoding

toJSONList :: [Float] -> Value

toEncodingList :: [Float] -> Encoding

ToJSON Int

Methods

toJSON :: Int -> Value

toEncoding :: Int -> Encoding

toJSONList :: [Int] -> Value

toEncodingList :: [Int] -> Encoding

ToJSON Int8

Methods

toJSON :: Int8 -> Value

toEncoding :: Int8 -> Encoding

toJSONList :: [Int8] -> Value

toEncodingList :: [Int8] -> Encoding

ToJSON Int16

Methods

toJSON :: Int16 -> Value

toEncoding :: Int16 -> Encoding

toJSONList :: [Int16] -> Value

toEncodingList :: [Int16] -> Encoding

ToJSON Int32

Methods

toJSON :: Int32 -> Value

toEncoding :: Int32 -> Encoding

toJSONList :: [Int32] -> Value

toEncodingList :: [Int32] -> Encoding

ToJSON Int64

Methods

toJSON :: Int64 -> Value

toEncoding :: Int64 -> Encoding

toJSONList :: [Int64] -> Value

toEncodingList :: [Int64] -> Encoding

ToJSON Integer

Methods

toJSON :: Integer -> Value

toEncoding :: Integer -> Encoding

toJSONList :: [Integer] -> Value

toEncodingList :: [Integer] -> Encoding

ToJSON Ordering

Methods

toJSON :: Ordering -> Value

toEncoding :: Ordering -> Encoding

toJSONList :: [Ordering] -> Value

toEncodingList :: [Ordering] -> Encoding

ToJSON Word

Methods

toJSON :: Word -> Value

toEncoding :: Word -> Encoding

toJSONList :: [Word] -> Value

toEncodingList :: [Word] -> Encoding

ToJSON Word8

Methods

toJSON :: Word8 -> Value

toEncoding :: Word8 -> Encoding

toJSONList :: [Word8] -> Value

toEncodingList :: [Word8] -> Encoding

ToJSON Word16

Methods

toJSON :: Word16 -> Value

toEncoding :: Word16 -> Encoding

toJSONList :: [Word16] -> Value

toEncodingList :: [Word16] -> Encoding

ToJSON Word32

Methods

toJSON :: Word32 -> Value

toEncoding :: Word32 -> Encoding

toJSONList :: [Word32] -> Value

toEncodingList :: [Word32] -> Encoding

ToJSON Word64

Methods

toJSON :: Word64 -> Value

toEncoding :: Word64 -> Encoding

toJSONList :: [Word64] -> Value

toEncodingList :: [Word64] -> Encoding

ToJSON ()

Methods

toJSON :: () -> Value

toEncoding :: () -> Encoding

toJSONList :: [()] -> Value

toEncodingList :: [()] -> Encoding

ToJSON Scientific

Methods

toJSON :: Scientific -> Value

toEncoding :: Scientific -> Encoding

toJSONList :: [Scientific] -> Value

toEncodingList :: [Scientific] -> Encoding

ToJSON Number

Methods

toJSON :: Number -> Value

toEncoding :: Number -> Encoding

toJSONList :: [Number] -> Value

toEncodingList :: [Number] -> Encoding

ToJSON Text

Methods

toJSON :: Text -> Value

toEncoding :: Text -> Encoding

toJSONList :: [Text] -> Value

toEncodingList :: [Text] -> Encoding

ToJSON UTCTime

Methods

toJSON :: UTCTime -> Value

toEncoding :: UTCTime -> Encoding

toJSONList :: [UTCTime] -> Value

toEncodingList :: [UTCTime] -> Encoding

ToJSON Value

Methods

toJSON :: Value -> Value

toEncoding :: Value -> Encoding

toJSONList :: [Value] -> Value

toEncodingList :: [Value] -> Encoding

ToJSON DotNetTime

Methods

toJSON :: DotNetTime -> Value

toEncoding :: DotNetTime -> Encoding

toJSONList :: [DotNetTime] -> Value

toEncodingList :: [DotNetTime] -> Encoding

ToJSON Text

Methods

toJSON :: Text -> Value

toEncoding :: Text -> Encoding

toJSONList :: [Text] -> Value

toEncodingList :: [Text] -> Encoding

ToJSON Natural

Methods

toJSON :: Natural -> Value

toEncoding :: Natural -> Encoding

toJSONList :: [Natural] -> Value

toEncodingList :: [Natural] -> Encoding

ToJSON Version

Methods

toJSON :: Version -> Value

toEncoding :: Version -> Encoding

toJSONList :: [Version] -> Value

toEncodingList :: [Version] -> Encoding

ToJSON IntSet

Methods

toJSON :: IntSet -> Value

toEncoding :: IntSet -> Encoding

toJSONList :: [IntSet] -> Value

toEncodingList :: [IntSet] -> Encoding

ToJSON LocalTime

Methods

toJSON :: LocalTime -> Value

toEncoding :: LocalTime -> Encoding

toJSONList :: [LocalTime] -> Value

toEncodingList :: [LocalTime] -> Encoding

ToJSON ZonedTime

Methods

toJSON :: ZonedTime -> Value

toEncoding :: ZonedTime -> Encoding

toJSONList :: [ZonedTime] -> Value

toEncodingList :: [ZonedTime] -> Encoding

ToJSON TimeOfDay

Methods

toJSON :: TimeOfDay -> Value

toEncoding :: TimeOfDay -> Encoding

toJSONList :: [TimeOfDay] -> Value

toEncodingList :: [TimeOfDay] -> Encoding

ToJSON NominalDiffTime

Methods

toJSON :: NominalDiffTime -> Value

toEncoding :: NominalDiffTime -> Encoding

toJSONList :: [NominalDiffTime] -> Value

toEncodingList :: [NominalDiffTime] -> Encoding

ToJSON Day

Methods

toJSON :: Day -> Value

toEncoding :: Day -> Encoding

toJSONList :: [Day] -> Value

toEncodingList :: [Day] -> Encoding

ToJSON UUID

Methods

toJSON :: UUID -> Value

toEncoding :: UUID -> Encoding

toJSONList :: [UUID] -> Value

toEncodingList :: [UUID] -> Encoding

ToJSON a => ToJSON [a]

Methods

toJSON :: [a] -> Value

toEncoding :: [a] -> Encoding

toJSONList :: [[a]] -> Value

toEncodingList :: [[a]] -> Encoding

ToJSON a => ToJSON (Maybe a)

Methods

toJSON :: Maybe a -> Value

toEncoding :: Maybe a -> Encoding

toJSONList :: [Maybe a] -> Value

toEncodingList :: [Maybe a] -> Encoding

(ToJSON a, Integral a) => ToJSON (Ratio a)

Methods

toJSON :: Ratio a -> Value

toEncoding :: Ratio a -> Encoding

toJSONList :: [Ratio a] -> Value

toEncodingList :: [Ratio a] -> Encoding

ToJSON a => ToJSON (Identity a)

Methods

toJSON :: Identity a -> Value

toEncoding :: Identity a -> Encoding

toJSONList :: [Identity a] -> Value

toEncodingList :: [Identity a] -> Encoding

ToJSON a => ToJSON (Min a)

Methods

toJSON :: Min a -> Value

toEncoding :: Min a -> Encoding

toJSONList :: [Min a] -> Value

toEncodingList :: [Min a] -> Encoding

ToJSON a => ToJSON (Max a)

Methods

toJSON :: Max a -> Value

toEncoding :: Max a -> Encoding

toJSONList :: [Max a] -> Value

toEncodingList :: [Max a] -> Encoding

ToJSON a => ToJSON (First a)

Methods

toJSON :: First a -> Value

toEncoding :: First a -> Encoding

toJSONList :: [First a] -> Value

toEncodingList :: [First a] -> Encoding

ToJSON a => ToJSON (Last a)

Methods

toJSON :: Last a -> Value

toEncoding :: Last a -> Encoding

toJSONList :: [Last a] -> Value

toEncodingList :: [Last a] -> Encoding

ToJSON a => ToJSON (WrappedMonoid a)

Methods

toJSON :: WrappedMonoid a -> Value

toEncoding :: WrappedMonoid a -> Encoding

toJSONList :: [WrappedMonoid a] -> Value

toEncodingList :: [WrappedMonoid a] -> Encoding

ToJSON a => ToJSON (Option a)

Methods

toJSON :: Option a -> Value

toEncoding :: Option a -> Encoding

toJSONList :: [Option a] -> Value

toEncodingList :: [Option a] -> Encoding

ToJSON a => ToJSON (NonEmpty a)

Methods

toJSON :: NonEmpty a -> Value

toEncoding :: NonEmpty a -> Encoding

toJSONList :: [NonEmpty a] -> Value

toEncodingList :: [NonEmpty a] -> Encoding

HasResolution a => ToJSON (Fixed a)

Methods

toJSON :: Fixed a -> Value

toEncoding :: Fixed a -> Encoding

toJSONList :: [Fixed a] -> Value

toEncodingList :: [Fixed a] -> Encoding

ToJSON a => ToJSON (Dual a)

Methods

toJSON :: Dual a -> Value

toEncoding :: Dual a -> Encoding

toJSONList :: [Dual a] -> Value

toEncodingList :: [Dual a] -> Encoding

ToJSON a => ToJSON (First a)

Methods

toJSON :: First a -> Value

toEncoding :: First a -> Encoding

toJSONList :: [First a] -> Value

toEncodingList :: [First a] -> Encoding

ToJSON a => ToJSON (Last a)

Methods

toJSON :: Last a -> Value

toEncoding :: Last a -> Encoding

toJSONList :: [Last a] -> Value

toEncodingList :: [Last a] -> Encoding

ToJSON a => ToJSON (IntMap a)

Methods

toJSON :: IntMap a -> Value

toEncoding :: IntMap a -> Encoding

toJSONList :: [IntMap a] -> Value

toEncodingList :: [IntMap a] -> Encoding

ToJSON v => ToJSON (Tree v)

Methods

toJSON :: Tree v -> Value

toEncoding :: Tree v -> Encoding

toJSONList :: [Tree v] -> Value

toEncodingList :: [Tree v] -> Encoding

ToJSON a => ToJSON (Seq a)

Methods

toJSON :: Seq a -> Value

toEncoding :: Seq a -> Encoding

toJSONList :: [Seq a] -> Value

toEncodingList :: [Seq a] -> Encoding

ToJSON a => ToJSON (Set a)

Methods

toJSON :: Set a -> Value

toEncoding :: Set a -> Encoding

toJSONList :: [Set a] -> Value

toEncodingList :: [Set a] -> Encoding

ToJSON a => ToJSON (DList a)

Methods

toJSON :: DList a -> Value

toEncoding :: DList a -> Encoding

toJSONList :: [DList a] -> Value

toEncodingList :: [DList a] -> Encoding

ToJSON a => ToJSON (HashSet a)

Methods

toJSON :: HashSet a -> Value

toEncoding :: HashSet a -> Encoding

toJSONList :: [HashSet a] -> Value

toEncodingList :: [HashSet a] -> Encoding

ToJSON a => ToJSON (Vector a)

Methods

toJSON :: Vector a -> Value

toEncoding :: Vector a -> Encoding

toJSONList :: [Vector a] -> Value

toEncodingList :: [Vector a] -> Encoding

(Storable a, ToJSON a) => ToJSON (Vector a)

Methods

toJSON :: Vector a -> Value

toEncoding :: Vector a -> Encoding

toJSONList :: [Vector a] -> Value

toEncodingList :: [Vector a] -> Encoding

(Vector Vector a, ToJSON a) => ToJSON (Vector a)

Methods

toJSON :: Vector a -> Value

toEncoding :: Vector a -> Encoding

toJSONList :: [Vector a] -> Value

toEncodingList :: [Vector a] -> Encoding

(Prim a, ToJSON a) => ToJSON (Vector a)

Methods

toJSON :: Vector a -> Value

toEncoding :: Vector a -> Encoding

toJSONList :: [Vector a] -> Value

toEncodingList :: [Vector a] -> Encoding

(ToJSON a, ToJSON b) => ToJSON (Either a b)

Methods

toJSON :: Either a b -> Value

toEncoding :: Either a b -> Encoding

toJSONList :: [Either a b] -> Value

toEncodingList :: [Either a b] -> Encoding

(ToJSON a, ToJSON b) => ToJSON (a, b)

Methods

toJSON :: (a, b) -> Value

toEncoding :: (a, b) -> Encoding

toJSONList :: [(a, b)] -> Value

toEncodingList :: [(a, b)] -> Encoding

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

Methods

toJSON :: HashMap k v -> Value

toEncoding :: HashMap k v -> Encoding

toJSONList :: [HashMap k v] -> Value

toEncodingList :: [HashMap k v] -> Encoding

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

Methods

toJSON :: Map k v -> Value

toEncoding :: Map k v -> Encoding

toJSONList :: [Map k v] -> Value

toEncodingList :: [Map k v] -> Encoding

ToJSON (Proxy k a)

Methods

toJSON :: Proxy k a -> Value

toEncoding :: Proxy k a -> Encoding

toJSONList :: [Proxy k a] -> Value

toEncodingList :: [Proxy k a] -> Encoding

(ToJSON a, ToJSON b, ToJSON c) => ToJSON (a, b, c)

Methods

toJSON :: (a, b, c) -> Value

toEncoding :: (a, b, c) -> Encoding

toJSONList :: [(a, b, c)] -> Value

toEncodingList :: [(a, b, c)] -> Encoding

ToJSON a => ToJSON (Const k a b)

Methods

toJSON :: Const k a b -> Value

toEncoding :: Const k a b -> Encoding

toJSONList :: [Const k a b] -> Value

toEncodingList :: [Const k a b] -> Encoding

ToJSON b => ToJSON (Tagged k a b)

Methods

toJSON :: Tagged k a b -> Value

toEncoding :: Tagged k a b -> Encoding

toJSONList :: [Tagged k a b] -> Value

toEncodingList :: [Tagged k a b] -> Encoding

(ToJSON a, ToJSON b, ToJSON c, ToJSON d) => ToJSON (a, b, c, d)

Methods

toJSON :: (a, b, c, d) -> Value

toEncoding :: (a, b, c, d) -> Encoding

toJSONList :: [(a, b, c, d)] -> Value

toEncodingList :: [(a, b, c, d)] -> Encoding

(ToJSON1 f, ToJSON1 g, ToJSON a) => ToJSON (Sum * f g a)

Methods

toJSON :: Sum * f g a -> Value

toEncoding :: Sum * f g a -> Encoding

toJSONList :: [Sum * f g a] -> Value

toEncodingList :: [Sum * f g a] -> Encoding

(ToJSON1 f, ToJSON1 g, ToJSON a) => ToJSON (Product * f g a)

Methods

toJSON :: Product * f g a -> Value

toEncoding :: Product * f g a -> Encoding

toJSONList :: [Product * f g a] -> Value

toEncodingList :: [Product * f g a] -> Encoding

(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e) => ToJSON (a, b, c, d, e)

Methods

toJSON :: (a, b, c, d, e) -> Value

toEncoding :: (a, b, c, d, e) -> Encoding

toJSONList :: [(a, b, c, d, e)] -> Value

toEncodingList :: [(a, b, c, d, e)] -> Encoding

(ToJSON1 f, ToJSON1 g, ToJSON a) => ToJSON (Compose * * f g a)

Methods

toJSON :: Compose * * f g a -> Value

toEncoding :: Compose * * f g a -> Encoding

toJSONList :: [Compose * * f g a] -> Value

toEncodingList :: [Compose * * f g a] -> Encoding

(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f) => ToJSON (a, b, c, d, e, f)

Methods

toJSON :: (a, b, c, d, e, f) -> Value

toEncoding :: (a, b, c, d, e, f) -> Encoding

toJSONList :: [(a, b, c, d, e, f)] -> Value

toEncodingList :: [(a, b, c, d, e, f)] -> Encoding

(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g) => ToJSON (a, b, c, d, e, f, g)

Methods

toJSON :: (a, b, c, d, e, f, g) -> Value

toEncoding :: (a, b, c, d, e, f, g) -> Encoding

toJSONList :: [(a, b, c, d, e, f, g)] -> Value

toEncodingList :: [(a, b, c, d, e, f, g)] -> Encoding

(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h) => ToJSON (a, b, c, d, e, f, g, h)

Methods

toJSON :: (a, b, c, d, e, f, g, h) -> Value

toEncoding :: (a, b, c, d, e, f, g, h) -> Encoding

toJSONList :: [(a, b, c, d, e, f, g, h)] -> Value

toEncodingList :: [(a, b, c, d, e, f, g, h)] -> Encoding

(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i) => ToJSON (a, b, c, d, e, f, g, h, i)

Methods

toJSON :: (a, b, c, d, e, f, g, h, i) -> Value

toEncoding :: (a, b, c, d, e, f, g, h, i) -> Encoding

toJSONList :: [(a, b, c, d, e, f, g, h, i)] -> Value

toEncodingList :: [(a, b, c, d, e, f, g, h, i)] -> Encoding

(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j) => ToJSON (a, b, c, d, e, f, g, h, i, j)

Methods

toJSON :: (a, b, c, d, e, f, g, h, i, j) -> Value

toEncoding :: (a, b, c, d, e, f, g, h, i, j) -> Encoding

toJSONList :: [(a, b, c, d, e, f, g, h, i, j)] -> Value

toEncodingList :: [(a, b, c, d, e, f, g, h, i, j)] -> Encoding

(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k) => ToJSON (a, b, c, d, e, f, g, h, i, j, k)

Methods

toJSON :: (a, b, c, d, e, f, g, h, i, j, k) -> Value

toEncoding :: (a, b, c, d, e, f, g, h, i, j, k) -> Encoding

toJSONList :: [(a, b, c, d, e, f, g, h, i, j, k)] -> Value

toEncodingList :: [(a, b, c, d, e, f, g, h, i, j, k)] -> Encoding

(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k, ToJSON l) => ToJSON (a, b, c, d, e, f, g, h, i, j, k, l)

Methods

toJSON :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Value

toEncoding :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Encoding

toJSONList :: [(a, b, c, d, e, f, g, h, i, j, k, l)] -> Value

toEncodingList :: [(a, b, c, d, e, f, g, h, i, j, k, l)] -> Encoding

(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k, ToJSON l, ToJSON m) => ToJSON (a, b, c, d, e, f, g, h, i, j, k, l, m)

Methods

toJSON :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Value

toEncoding :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Encoding

toJSONList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m)] -> Value

toEncodingList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m)] -> Encoding

(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k, ToJSON l, ToJSON m, ToJSON n) => ToJSON (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

Methods

toJSON :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Value

toEncoding :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Encoding

toJSONList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] -> Value

toEncodingList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] -> Encoding

(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k, ToJSON l, ToJSON m, ToJSON n, ToJSON o) => ToJSON (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

Methods

toJSON :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Value

toEncoding :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Encoding

toJSONList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] -> Value

toEncodingList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] -> Encoding

class FromJSON a

A type that can be converted from JSON, with the possibility of failure.

In many cases, you can get the compiler to generate parsing code for you (see below). To begin, let's cover writing an instance by hand.

There are various reasons a conversion could fail. For example, an Object could be missing a required key, an Array could be of the wrong size, or a value could be of an incompatible type.

The basic ways to signal a failed conversion are as follows:

• empty and mzero work, but are terse and uninformative
• fail yields a custom error message
• typeMismatch produces an informative message for cases when the value encountered is not of the expected type

An example type and instance:

-- Allow ourselves to write Text literals.
{-# LANGUAGE OverloadedStrings #-}

data Coord = Coord { x :: Double, y :: Double }

instance FromJSON Coord where
  parseJSON (Object v) = Coord    <$>
                         v .: "x" <*>
                         v .: "y"

  -- We do not expect a non-Object value here.
  -- We could use mzero to fail, but typeMismatch
  -- gives a much more informative error message.
  parseJSON invalid    = typeMismatch "Coord" invalid

Instead of manually writing your FromJSON instance, there are two options to do it automatically:

• Data.Aeson.TH provides Template Haskell functions which will derive an instance at compile time. The generated instance is optimized for your type so will probably be more efficient than the following two options:
• The compiler can provide a default generic implementation for parseJSON.

To use the second, simply add a deriving Generic clause to your datatype and declare a FromJSON instance for your datatype without giving a definition for parseJSON.

For example, the previous example can be simplified to just:

{-# LANGUAGE DeriveGeneric #-}

import GHC.Generics

data Coord = Coord { x :: Double, y :: Double } deriving Generic

instance FromJSON Coord

If DefaultSignatures doesn't give exactly the results you want, you can customize the generic decoding with only a tiny amount of effort, using genericParseJSON with your preferred Options:

instance FromJSON Coord where
    parseJSON = genericParseJSON defaultOptions

Instances

FromJSON Bool

Methods

parseJSON :: Value -> Parser Bool

parseJSONList :: Value -> Parser [Bool]

FromJSON Char

Methods

parseJSON :: Value -> Parser Char

parseJSONList :: Value -> Parser [Char]

FromJSON Double

Methods

parseJSON :: Value -> Parser Double

parseJSONList :: Value -> Parser [Double]

FromJSON Float

Methods

parseJSON :: Value -> Parser Float

parseJSONList :: Value -> Parser [Float]

FromJSON Int

Methods

parseJSON :: Value -> Parser Int

parseJSONList :: Value -> Parser [Int]

FromJSON Int8

Methods

parseJSON :: Value -> Parser Int8

parseJSONList :: Value -> Parser [Int8]

FromJSON Int16

Methods

parseJSON :: Value -> Parser Int16

parseJSONList :: Value -> Parser [Int16]

FromJSON Int32

Methods

parseJSON :: Value -> Parser Int32

parseJSONList :: Value -> Parser [Int32]

FromJSON Int64

Methods

parseJSON :: Value -> Parser Int64

parseJSONList :: Value -> Parser [Int64]

FromJSON Integer

WARNING: Only parse Integers from trusted input since an attacker could easily fill up the memory of the target system by specifying a scientific number with a big exponent like 1e1000000000.

Methods

parseJSON :: Value -> Parser Integer

parseJSONList :: Value -> Parser [Integer]

FromJSON Ordering

Methods

parseJSON :: Value -> Parser Ordering

parseJSONList :: Value -> Parser [Ordering]

FromJSON Word

Methods

parseJSON :: Value -> Parser Word

parseJSONList :: Value -> Parser [Word]

FromJSON Word8

Methods

parseJSON :: Value -> Parser Word8

parseJSONList :: Value -> Parser [Word8]

FromJSON Word16

Methods

parseJSON :: Value -> Parser Word16

parseJSONList :: Value -> Parser [Word16]

FromJSON Word32

Methods

parseJSON :: Value -> Parser Word32

parseJSONList :: Value -> Parser [Word32]

FromJSON Word64

Methods

parseJSON :: Value -> Parser Word64

parseJSONList :: Value -> Parser [Word64]

FromJSON ()

Methods

parseJSON :: Value -> Parser ()

parseJSONList :: Value -> Parser [()]

FromJSON Scientific

Methods

parseJSON :: Value -> Parser Scientific

parseJSONList :: Value -> Parser [Scientific]

FromJSON Number

Methods

parseJSON :: Value -> Parser Number

parseJSONList :: Value -> Parser [Number]

FromJSON Text

Methods

parseJSON :: Value -> Parser Text

parseJSONList :: Value -> Parser [Text]

FromJSON UTCTime

Methods

parseJSON :: Value -> Parser UTCTime

parseJSONList :: Value -> Parser [UTCTime]

FromJSON Value

Methods

parseJSON :: Value -> Parser Value

parseJSONList :: Value -> Parser [Value]

FromJSON DotNetTime

Methods

parseJSON :: Value -> Parser DotNetTime

parseJSONList :: Value -> Parser [DotNetTime]

FromJSON Text

Methods

parseJSON :: Value -> Parser Text

parseJSONList :: Value -> Parser [Text]

FromJSON Natural

Methods

parseJSON :: Value -> Parser Natural

parseJSONList :: Value -> Parser [Natural]

FromJSON Version

Methods

parseJSON :: Value -> Parser Version

parseJSONList :: Value -> Parser [Version]

FromJSON IntSet

Methods

parseJSON :: Value -> Parser IntSet

parseJSONList :: Value -> Parser [IntSet]

FromJSON LocalTime

Methods

parseJSON :: Value -> Parser LocalTime

parseJSONList :: Value -> Parser [LocalTime]

FromJSON ZonedTime

Methods

parseJSON :: Value -> Parser ZonedTime

parseJSONList :: Value -> Parser [ZonedTime]

FromJSON TimeOfDay

Methods

parseJSON :: Value -> Parser TimeOfDay

parseJSONList :: Value -> Parser [TimeOfDay]

FromJSON NominalDiffTime

WARNING: Only parse lengths of time from trusted input since an attacker could easily fill up the memory of the target system by specifying a scientific number with a big exponent like 1e1000000000.

Methods

parseJSON :: Value -> Parser NominalDiffTime

parseJSONList :: Value -> Parser [NominalDiffTime]

FromJSON Day

Methods

parseJSON :: Value -> Parser Day

parseJSONList :: Value -> Parser [Day]

FromJSON UUID

Methods

parseJSON :: Value -> Parser UUID

parseJSONList :: Value -> Parser [UUID]

FromJSON a => FromJSON [a]

Methods

parseJSON :: Value -> Parser [a]

parseJSONList :: Value -> Parser [[a]]

FromJSON a => FromJSON (Maybe a)

Methods

parseJSON :: Value -> Parser (Maybe a)

parseJSONList :: Value -> Parser [Maybe a]

(FromJSON a, Integral a) => FromJSON (Ratio a)

Methods

parseJSON :: Value -> Parser (Ratio a)

parseJSONList :: Value -> Parser [Ratio a]

FromJSON a => FromJSON (Identity a)

Methods

parseJSON :: Value -> Parser (Identity a)

parseJSONList :: Value -> Parser [Identity a]

FromJSON a => FromJSON (Min a)

Methods

parseJSON :: Value -> Parser (Min a)

parseJSONList :: Value -> Parser [Min a]

FromJSON a => FromJSON (Max a)

Methods

parseJSON :: Value -> Parser (Max a)

parseJSONList :: Value -> Parser [Max a]

FromJSON a => FromJSON (First a)

Methods

parseJSON :: Value -> Parser (First a)

parseJSONList :: Value -> Parser [First a]

FromJSON a => FromJSON (Last a)

Methods

parseJSON :: Value -> Parser (Last a)

parseJSONList :: Value -> Parser [Last a]

FromJSON a => FromJSON (WrappedMonoid a)

Methods

parseJSON :: Value -> Parser (WrappedMonoid a)

parseJSONList :: Value -> Parser [WrappedMonoid a]

FromJSON a => FromJSON (Option a)

Methods

parseJSON :: Value -> Parser (Option a)

parseJSONList :: Value -> Parser [Option a]

FromJSON a => FromJSON (NonEmpty a)

Methods

parseJSON :: Value -> Parser (NonEmpty a)

parseJSONList :: Value -> Parser [NonEmpty a]

HasResolution a => FromJSON (Fixed a)

WARNING: Only parse fixed-precision numbers from trusted input since an attacker could easily fill up the memory of the target system by specifying a scientific number with a big exponent like 1e1000000000.

Methods

parseJSON :: Value -> Parser (Fixed a)

parseJSONList :: Value -> Parser [Fixed a]

FromJSON a => FromJSON (Dual a)

Methods

parseJSON :: Value -> Parser (Dual a)

parseJSONList :: Value -> Parser [Dual a]

FromJSON a => FromJSON (First a)

Methods

parseJSON :: Value -> Parser (First a)

parseJSONList :: Value -> Parser [First a]

FromJSON a => FromJSON (Last a)

Methods

parseJSON :: Value -> Parser (Last a)

parseJSONList :: Value -> Parser [Last a]

FromJSON a => FromJSON (IntMap a)

Methods

parseJSON :: Value -> Parser (IntMap a)

parseJSONList :: Value -> Parser [IntMap a]

FromJSON v => FromJSON (Tree v)

Methods

parseJSON :: Value -> Parser (Tree v)

parseJSONList :: Value -> Parser [Tree v]

FromJSON a => FromJSON (Seq a)

Methods

parseJSON :: Value -> Parser (Seq a)

parseJSONList :: Value -> Parser [Seq a]

(Ord a, FromJSON a) => FromJSON (Set a)

Methods

parseJSON :: Value -> Parser (Set a)

parseJSONList :: Value -> Parser [Set a]

FromJSON a => FromJSON (DList a)

Methods

parseJSON :: Value -> Parser (DList a)

parseJSONList :: Value -> Parser [DList a]

(Eq a, Hashable a, FromJSON a) => FromJSON (HashSet a)

Methods

parseJSON :: Value -> Parser (HashSet a)

parseJSONList :: Value -> Parser [HashSet a]

FromJSON a => FromJSON (Vector a)

Methods

parseJSON :: Value -> Parser (Vector a)

parseJSONList :: Value -> Parser [Vector a]

(Storable a, FromJSON a) => FromJSON (Vector a)

Methods

parseJSON :: Value -> Parser (Vector a)

parseJSONList :: Value -> Parser [Vector a]

(Vector Vector a, FromJSON a) => FromJSON (Vector a)

Methods

parseJSON :: Value -> Parser (Vector a)

parseJSONList :: Value -> Parser [Vector a]

(Prim a, FromJSON a) => FromJSON (Vector a)

Methods

parseJSON :: Value -> Parser (Vector a)

parseJSONList :: Value -> Parser [Vector a]

(FromJSON a, FromJSON b) => FromJSON (Either a b)

Methods

parseJSON :: Value -> Parser (Either a b)

parseJSONList :: Value -> Parser [Either a b]

(FromJSON a, FromJSON b) => FromJSON (a, b)

Methods

parseJSON :: Value -> Parser (a, b)

parseJSONList :: Value -> Parser [(a, b)]

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

Methods

parseJSON :: Value -> Parser (HashMap k v)

parseJSONList :: Value -> Parser [HashMap k v]

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

Methods

parseJSON :: Value -> Parser (Map k v)

parseJSONList :: Value -> Parser [Map k v]

FromJSON (Proxy k a)

Methods

parseJSON :: Value -> Parser (Proxy k a)

parseJSONList :: Value -> Parser [Proxy k a]

(FromJSON a, FromJSON b, FromJSON c) => FromJSON (a, b, c)

Methods

parseJSON :: Value -> Parser (a, b, c)

parseJSONList :: Value -> Parser [(a, b, c)]

FromJSON a => FromJSON (Const k a b)

Methods

parseJSON :: Value -> Parser (Const k a b)

parseJSONList :: Value -> Parser [Const k a b]

FromJSON b => FromJSON (Tagged k a b)

Methods

parseJSON :: Value -> Parser (Tagged k a b)

parseJSONList :: Value -> Parser [Tagged k a b]

(FromJSON a, FromJSON b, FromJSON c, FromJSON d) => FromJSON (a, b, c, d)

Methods

parseJSON :: Value -> Parser (a, b, c, d)

parseJSONList :: Value -> Parser [(a, b, c, d)]

(FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (Sum * f g a)

Methods

parseJSON :: Value -> Parser (Sum * f g a)

parseJSONList :: Value -> Parser [Sum * f g a]

(FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (Product * f g a)

Methods

parseJSON :: Value -> Parser (Product * f g a)

parseJSONList :: Value -> Parser [Product * f g a]

(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e) => FromJSON (a, b, c, d, e)

Methods

parseJSON :: Value -> Parser (a, b, c, d, e)

parseJSONList :: Value -> Parser [(a, b, c, d, e)]

(FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (Compose * * f g a)

Methods

parseJSON :: Value -> Parser (Compose * * f g a)

parseJSONList :: Value -> Parser [Compose * * f g a]

(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f) => FromJSON (a, b, c, d, e, f)

Methods

parseJSON :: Value -> Parser (a, b, c, d, e, f)

parseJSONList :: Value -> Parser [(a, b, c, d, e, f)]

(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g) => FromJSON (a, b, c, d, e, f, g)

Methods

parseJSON :: Value -> Parser (a, b, c, d, e, f, g)

parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g)]

(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h) => FromJSON (a, b, c, d, e, f, g, h)

Methods

parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h)

parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h)]

(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i) => FromJSON (a, b, c, d, e, f, g, h, i)

Methods

parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i)

parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i)]

(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j) => FromJSON (a, b, c, d, e, f, g, h, i, j)

Methods

parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j)

parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j)]

(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k) => FromJSON (a, b, c, d, e, f, g, h, i, j, k)

Methods

parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k)

parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k)]

(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l) => FromJSON (a, b, c, d, e, f, g, h, i, j, k, l)

Methods

parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l)

parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l)]

(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l, FromJSON m) => FromJSON (a, b, c, d, e, f, g, h, i, j, k, l, m)

Methods

parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m)

parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, m)]

(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l, FromJSON m, FromJSON n) => FromJSON (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

Methods

parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)]

(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l, FromJSON m, FromJSON n, FromJSON o) => FromJSON (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

Methods

parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)]

class NFData a

A class of types that can be fully evaluated.

Since: 1.1.0.0

Instances

NFData Bool

Methods

rnf :: Bool -> ()

NFData Char

Methods

rnf :: Char -> ()

NFData Double

Methods

rnf :: Double -> ()

NFData Float

Methods

rnf :: Float -> ()

NFData Int

Methods

rnf :: Int -> ()

NFData Int8

Methods

rnf :: Int8 -> ()

NFData Int16

Methods

rnf :: Int16 -> ()

NFData Int32

Methods

rnf :: Int32 -> ()

NFData Int64

Methods

rnf :: Int64 -> ()

NFData Integer

Methods

rnf :: Integer -> ()

NFData Word

Methods

rnf :: Word -> ()

NFData Word8

Methods

rnf :: Word8 -> ()

NFData Word16

Methods

rnf :: Word16 -> ()

NFData Word32

Methods

rnf :: Word32 -> ()

NFData Word64

Methods

rnf :: Word64 -> ()

NFData CallStack

Since: 1.4.2.0

Methods

rnf :: CallStack -> ()

NFData TypeRep

NOTE: Only defined for base-4.8.0.0 and later

Since: 1.4.0.0

Methods

rnf :: TypeRep -> ()

NFData ()

Methods

rnf :: () -> ()

NFData TyCon

NOTE: Only defined for base-4.8.0.0 and later

Since: 1.4.0.0

Methods

rnf :: TyCon -> ()

NFData Natural

Since: 1.4.0.0

Methods

rnf :: Natural -> ()

NFData Void

Defined as rnf = absurd.

Since: 1.4.0.0

Methods

rnf :: Void -> ()

NFData Version

Since: 1.3.0.0

Methods

rnf :: Version -> ()

NFData Unique

Since: 1.4.0.0

Methods

rnf :: Unique -> ()

NFData ThreadId

Since: 1.4.0.0

Methods

rnf :: ThreadId -> ()

NFData ExitCode

Since: 1.4.2.0

Methods

rnf :: ExitCode -> ()

NFData CChar

Since: 1.4.0.0

Methods

rnf :: CChar -> ()

NFData CSChar

Since: 1.4.0.0

Methods

rnf :: CSChar -> ()

NFData CUChar

Since: 1.4.0.0

Methods

rnf :: CUChar -> ()

NFData CShort

Since: 1.4.0.0

Methods

rnf :: CShort -> ()

NFData CUShort

Since: 1.4.0.0

Methods

rnf :: CUShort -> ()

NFData CInt

Since: 1.4.0.0

Methods

rnf :: CInt -> ()

NFData CUInt

Since: 1.4.0.0

Methods

rnf :: CUInt -> ()

NFData CLong

Since: 1.4.0.0

Methods

rnf :: CLong -> ()

NFData CULong

Since: 1.4.0.0

Methods

rnf :: CULong -> ()

NFData CLLong

Since: 1.4.0.0

Methods

rnf :: CLLong -> ()

NFData CULLong

Since: 1.4.0.0

Methods

rnf :: CULLong -> ()

NFData CFloat

Since: 1.4.0.0

Methods

rnf :: CFloat -> ()

NFData CDouble

Since: 1.4.0.0

Methods

rnf :: CDouble -> ()

NFData CPtrdiff

Since: 1.4.0.0

Methods

rnf :: CPtrdiff -> ()

NFData CSize

Since: 1.4.0.0

Methods

rnf :: CSize -> ()

NFData CWchar

Since: 1.4.0.0

Methods

rnf :: CWchar -> ()

NFData CSigAtomic

Since: 1.4.0.0

Methods

rnf :: CSigAtomic -> ()

NFData CClock

Since: 1.4.0.0

Methods

rnf :: CClock -> ()

NFData CTime

Since: 1.4.0.0

Methods

rnf :: CTime -> ()

NFData CUSeconds

Since: 1.4.0.0

Methods

rnf :: CUSeconds -> ()

NFData CSUSeconds

Since: 1.4.0.0

Methods

rnf :: CSUSeconds -> ()

NFData CFile

Since: 1.4.0.0

Methods

rnf :: CFile -> ()

NFData CFpos

Since: 1.4.0.0

Methods

rnf :: CFpos -> ()

NFData CJmpBuf

Since: 1.4.0.0

Methods

rnf :: CJmpBuf -> ()

NFData CIntPtr

Since: 1.4.0.0

Methods

rnf :: CIntPtr -> ()

NFData CUIntPtr

Since: 1.4.0.0

Methods

rnf :: CUIntPtr -> ()

NFData CIntMax

Since: 1.4.0.0

Methods

rnf :: CIntMax -> ()

NFData CUIntMax

Since: 1.4.0.0

Methods

rnf :: CUIntMax -> ()

NFData All

Since: 1.4.0.0

Methods

rnf :: All -> ()

NFData Any

Since: 1.4.0.0

Methods

rnf :: Any -> ()

NFData Fingerprint

Since: 1.4.0.0

Methods

rnf :: Fingerprint -> ()

NFData SrcLoc

Since: 1.4.2.0

Methods

rnf :: SrcLoc -> ()

NFData LocalTime

Methods

rnf :: LocalTime -> ()

NFData ZonedTime

Methods

rnf :: ZonedTime -> ()

NFData a => NFData [a]

Methods

rnf :: [a] -> ()

NFData a => NFData (Maybe a)

Methods

rnf :: Maybe a -> ()

NFData a => NFData (Ratio a)

Methods

rnf :: Ratio a -> ()

NFData (Ptr a)

Since: 1.4.2.0

Methods

rnf :: Ptr a -> ()

NFData (FunPtr a)

Since: 1.4.2.0

Methods

rnf :: FunPtr a -> ()

NFData a => NFData (Identity a)

Since: 1.4.0.0

Methods

rnf :: Identity a -> ()

NFData a => NFData (Min a)

Since: 1.4.2.0

Methods

rnf :: Min a -> ()

NFData a => NFData (Max a)

Since: 1.4.2.0

Methods

rnf :: Max a -> ()

NFData a => NFData (First a)

Since: 1.4.2.0

Methods

rnf :: First a -> ()

NFData a => NFData (Last a)

Since: 1.4.2.0

Methods

rnf :: Last a -> ()

NFData m => NFData (WrappedMonoid m)

Since: 1.4.2.0

Methods

rnf :: WrappedMonoid m -> ()

NFData a => NFData (Option a)

Since: 1.4.2.0

Methods

rnf :: Option a -> ()

NFData a => NFData (NonEmpty a)

Since: 1.4.2.0

Methods

rnf :: NonEmpty a -> ()

NFData (Fixed a)

Since: 1.3.0.0

Methods

rnf :: Fixed a -> ()

NFData a => NFData (Complex a)

Methods

rnf :: Complex a -> ()

NFData (StableName a)

Since: 1.4.0.0

Methods

rnf :: StableName a -> ()

NFData a => NFData (ZipList a)

Since: 1.4.0.0

Methods

rnf :: ZipList a -> ()

NFData a => NFData (Dual a)

Since: 1.4.0.0

Methods

rnf :: Dual a -> ()

NFData a => NFData (Sum a)

Since: 1.4.0.0

Methods

rnf :: Sum a -> ()

NFData a => NFData (Product a)

Since: 1.4.0.0

Methods

rnf :: Product a -> ()

NFData a => NFData (First a)

Since: 1.4.0.0

Methods

rnf :: First a -> ()

NFData a => NFData (Last a)

Since: 1.4.0.0

Methods

rnf :: Last a -> ()

NFData (IORef a)

NOTE: Only strict in the reference and not the referenced value.

Since: 1.4.2.0

Methods

rnf :: IORef a -> ()

NFData a => NFData (Down a)

Since: 1.4.0.0

Methods

rnf :: Down a -> ()

NFData (MVar a)

NOTE: Only strict in the reference and not the referenced value.

Since: 1.4.2.0

Methods

rnf :: MVar a -> ()

NFData (Vector a)

Methods

rnf :: Vector a -> ()

NFData (a -> b)

This instance is for convenience and consistency with seq. This assumes that WHNF is equivalent to NF for functions.

Since: 1.3.0.0

Methods

rnf :: (a -> b) -> ()

(NFData a, NFData b) => NFData (Either a b)

Methods

rnf :: Either a b -> ()

(NFData a, NFData b) => NFData (a, b)

Methods

rnf :: (a, b) -> ()

(NFData a, NFData b) => NFData (Array a b)

Methods

rnf :: Array a b -> ()

(NFData a, NFData b) => NFData (Arg a b)

Since: 1.4.2.0

Methods

rnf :: Arg a b -> ()

NFData (Proxy k a)

Since: 1.4.0.0

Methods

rnf :: Proxy k a -> ()

NFData (STRef s a)

NOTE: Only strict in the reference and not the referenced value.

Since: 1.4.2.0

Methods

rnf :: STRef s a -> ()

NFData (MVector s a)

Methods

rnf :: MVector s a -> ()

(NFData a, NFData b, NFData c) => NFData (a, b, c)

Methods

rnf :: (a, b, c) -> ()

NFData a => NFData (Const k a b)

Since: 1.4.0.0

Methods

rnf :: Const k a b -> ()

(NFData a, NFData b, NFData c, NFData d) => NFData (a, b, c, d)

Methods

rnf :: (a, b, c, d) -> ()

(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5) => NFData (a1, a2, a3, a4, a5)

Methods

rnf :: (a1, a2, a3, a4, a5) -> ()

(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5, NFData a6) => NFData (a1, a2, a3, a4, a5, a6)

Methods

rnf :: (a1, a2, a3, a4, a5, a6) -> ()

(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5, NFData a6, NFData a7) => NFData (a1, a2, a3, a4, a5, a6, a7)

Methods

rnf :: (a1, a2, a3, a4, a5, a6, a7) -> ()

(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5, NFData a6, NFData a7, NFData a8) => NFData (a1, a2, a3, a4, a5, a6, a7, a8)

Methods

rnf :: (a1, a2, a3, a4, a5, a6, a7, a8) -> ()

(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5, NFData a6, NFData a7, NFData a8, NFData a9) => NFData (a1, a2, a3, a4, a5, a6, a7, a8, a9)

Methods

rnf :: (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> ()

class Typeable k a

The class Typeable allows a concrete representation of a type to be calculated.

Minimal complete definition

typeRep#