ToText Bool
ToText Double
ToText Int
ToText Int64
ToText Integer
ToText ByteString
ToText Text
ToText StdMethod
ToText Natural
ToText Query
ToText Base64
ToText Nat
ToText POSIX
ToText AWSTime
ToText BasicTime
ToText ISO8601
ToText RFC822
ToText Action
ToText Region
ToText SecurityToken
ToText SecretKey
ToText AccessKey
ToText a => ToText [a]
ToText a => ToText (CI a)
ToText (Digest a)
ToText (Response a)
ToText a => ToText (Sensitive a)
(ToText a, ToText b) => ToText (a, b)

showText :: ToText a => a -> String Source

Numeric

newtype Nat Source

Constructors

Nat
Fields unNat :: Natural

Instances

Enum Nat
Eq Nat
Integral Nat
Num Nat
Ord Nat
Real Nat
Show Nat
ToJSON Nat
FromJSON Nat
Whole Nat
ToText Nat
FromText Nat
ToByteString Nat
ToQuery Nat
ToXML Nat
FromXML Nat

_Nat :: Iso' Nat Natural Source

Time

data Format Source

Constructors

RFC822Format
ISO8601Format
BasicFormat
AWSFormat
POSIXFormat

Instances

Eq Format
Show Format

data Time :: Format -> * where Source

Constructors

Time :: UTCTime -> Time a
LocaleTime :: TimeLocale -> UTCTime -> Time a

_Time :: Iso' (Time a) UTCTime Source

This is a poorly behaved isomorphism, due to the fact LocaleTime only exists for testing purposes, and we wish to compose using mapping in actual usage.

See: convert.

data UTCTime :: *

This is the simplest representation of UTC. It consists of the day number, and a time offset from midnight. Note that if a day has a leap second added to it, it will have 86401 seconds.

type RFC822 = Time RFC822Format Source

type ISO8601 = Time ISO8601Format Source

type BasicTime = Time BasicFormat Source

type AWSTime = Time AWSFormat Source

type POSIX = Time POSIXFormat Source

Sensitive

newtype Sensitive a Source

Constructors

Sensitive
Fields desensitise :: a

Instances

Eq a => Eq (Sensitive a)
Ord a => Ord (Sensitive a)
Show (Sensitive a)
IsString a => IsString (Sensitive a)
ToJSON a => ToJSON (Sensitive a)
FromJSON a => FromJSON (Sensitive a)
Monoid a => Monoid (Sensitive a)
ToText a => ToText (Sensitive a)
FromText a => FromText (Sensitive a)
ToByteString a => ToByteString (Sensitive a)
ToQuery a => ToQuery (Sensitive a)
ToXML a => ToXML (Sensitive a)
FromXML a => FromXML (Sensitive a)

_Sensitive :: Iso' (Sensitive a) a Source

HTTP

Body

data RsBody Source

Constructors

RsBody (ResumableSource (ResourceT IO) ByteString)

Instances

Show RsBody
ToBuilder RsBody

_RsBody :: Iso' RsBody (ResumableSource (ResourceT IO) ByteString) Source

connectBody :: MonadResource m => RsBody -> Sink ByteString m a -> m a Source

data RqBody Source

Constructors

RqBody
Fields _bdyHash :: Digest SHA256 _bdyBody :: RequestBody

Instances

Show RqBody
IsString RqBody
ToBuilder RqBody
ToBody RqBody

bdyHash :: Lens' RqBody (Digest SHA256) Source

bdyBody :: Lens' RqBody RequestBody Source

bodyHash :: RqBody -> ByteString Source

class ToBody a where Source

Minimal complete definition

Nothing

Methods

toBody :: a -> RqBody Source

Instances

ToBody ByteString
ToBody ByteString
ToBody Value
ToBody RqBody

sourceBody :: Digest SHA256 -> Int64 -> Source IO ByteString -> RqBody Source

sourceHandle :: Digest SHA256 -> Int64 -> Handle -> RqBody Source

sourceFile :: Digest SHA256 -> Int64 -> FilePath -> RqBody Source

sourceFileIO :: MonadIO m => FilePath -> m RqBody Source

sourcePopper :: Source IO ByteString -> GivesPopper () Source

Headers

(~:) :: FromText a => ResponseHeaders -> HeaderName -> Either String a Source

(~:?) :: FromText a => ResponseHeaders -> HeaderName -> Either String (Maybe a) Source

class ToHeaders a where Source

Minimal complete definition

Nothing

Methods

toHeaders :: a -> [Header] Source

(=:) :: ToHeader a => HeaderName -> a -> [Header] Source

hdr :: HeaderName -> ByteString -> [Header] -> [Header] Source

hdrs :: [Header] -> [Header] -> [Header] Source

toHeaderText :: ToText a => HeaderName -> a -> [Header] Source

class ToHeader a where Source

Minimal complete definition

Nothing

Methods

toHeader :: HeaderName -> a -> [Header] Source

Instances

ToHeader ByteString
ToHeader Text
ToByteString a => ToHeader (Maybe a)
(ToByteString k, ToByteString v) => ToHeader (HashMap k v)
ToHeader (Map (CI Text) Text)

hHost :: HeaderName Source

hAMZToken :: HeaderName Source

hAMZTarget :: HeaderName Source

hAMZAlgorithm :: HeaderName Source

hAMZCredential :: HeaderName Source

hAMZExpires :: HeaderName Source

hAMZSignedHeaders :: HeaderName Source

hAMZContentSHA256 :: HeaderName Source

hAMZAuth :: HeaderName Source

hAMZDate :: HeaderName Source

hMetaPrefix :: HeaderName Source

Path

class ToPath a where Source

Minimal complete definition

Nothing

Methods

toPath :: a -> Text Source

Instances

ToPath Text
ToPath Info
ToPath Interface
ToPath Mapping
ToPath Metadata
ToPath Dynamic

Query

class ToQuery a where Source

Minimal complete definition

Nothing

Methods

toQuery :: a -> Query Source

Instances

ToQuery Bool
ToQuery Char
ToQuery Double
ToQuery Int
ToQuery Integer
ToQuery ByteString
ToQuery Text
ToQuery Natural
ToQuery Query
ToQuery Base64
ToQuery Nat
ToQuery AWSTime
ToQuery BasicTime
ToQuery ISO8601
ToQuery RFC822
ToQuery a => ToQuery [a]
ToQuery a => ToQuery (Maybe a)
ToQuery a => ToQuery (Sensitive a)
(ToByteString k, ToQuery v) => ToQuery (k, v)
(KnownSymbol e, ToQuery a) => ToQuery (List1 e a)
(KnownSymbol e, ToQuery a) => ToQuery (List e a)
(KnownSymbol e, KnownSymbol i, KnownSymbol j, Eq k, Hashable k, ToQuery k, ToQuery v) => ToQuery (EMap e i j k v)

renderQuery :: Query -> ByteString Source

data Query Source

Instances

Eq Query
Data Query
Show Query
IsString Query
Monoid Query
Plated Query
ToText Query
ToBuilder Query
ToByteString Query
ToQuery Query
Typeable * Query

valuesOf :: Traversal' Query (Maybe ByteString) Source

pair :: ToQuery a => ByteString -> a -> Query -> Query Source

(=?) :: ToQuery a => ByteString -> a -> Query Source

URI

collapseURI :: ByteString -> ByteString Source

XML

FromXML

class FromXML a where Source

Methods

parseXML :: [Node] -> Either String a Source

Instances

FromXML Bool
FromXML Double
FromXML Int
FromXML Integer
FromXML Text
FromXML Natural
FromXML Base64
FromXML Nat
FromXML POSIX
FromXML AWSTime
FromXML BasicTime
FromXML ISO8601
FromXML RFC822
FromXML Region
FromXML RESTError
FromXML ErrorType
FromXML a => FromXML (Maybe a)
FromXML a => FromXML (Sensitive a)
(KnownSymbol e, FromXML a) => FromXML (List1 e a)
(KnownSymbol e, FromXML a) => FromXML (List e a)
(KnownSymbol e, KnownSymbol i, KnownSymbol j, Eq k, Hashable k, FromXML k, FromXML v) => FromXML (EMap e i j k v)

decodeXML :: LazyByteString -> Either String [Node] Source

parseXMLText :: FromText a => String -> [Node] -> Either String a Source

childNodes :: Text -> Node -> Maybe [Node] Source

findElement :: Text -> [Node] -> Either String [Node] Source

withContent :: String -> (Text -> Either String a) -> [Node] -> Either String a Source

withElement :: Text -> ([Node] -> Either String a) -> [Node] -> Either String a Source

withNode :: String -> (Node -> Either String a) -> [Node] -> Either String a Source

localName :: Node -> Maybe Text Source

(.@) :: FromXML a => [Node] -> Text -> Either String a Source

(.@?) :: FromXML a => [Node] -> Text -> Either String (Maybe a) Source

(.!@) :: Either String (Maybe a) -> a -> Either String a Source

ToXML

class ToXML a where Source

Minimal complete definition

Nothing

Methods

toXML :: a -> [Node] Source

Instances

ToXML Bool
ToXML Double
ToXML Int
ToXML Integer
ToXML Text
ToXML Natural
ToXML Base64
ToXML Nat
ToXML POSIX
ToXML AWSTime
ToXML BasicTime
ToXML ISO8601
ToXML RFC822
ToXML Region
ToXML a => ToXML (Maybe a)
ToXML a => ToXML (Sensitive a)
(KnownSymbol e, ToXML a) => ToXML (List1 e a)
(KnownSymbol e, ToXML a) => ToXML (List e a)
(KnownSymbol e, KnownSymbol i, KnownSymbol j, Eq k, Hashable k, ToXML k, ToXML v) => ToXML (EMap e i j k v)

class ToXMLRoot a where Source

Methods

toXMLRoot :: a -> Element Source

encodeXML :: ToXMLRoot a => a -> LazyByteString Source

toXMLText :: ToText a => a -> [Node] Source

namespaced :: Text -> Text -> [Node] -> Element Source

element :: Name -> [Node] -> Element Source

nodes :: Name -> [Node] -> [Node] Source

(=@) :: ToXML a => Name -> a -> Node Source

unsafeToXML :: (Show a, ToXML a) => a -> Node Source

Caution: This is for use with types which are flattened in AWS service model terminology. It is applied by the generator/templating in safe contexts only.

JSON

FromJSON

class FromJSON a where

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

When writing an instance, use empty, mzero, or fail to make a conversion fail, e.g. if an Object is missing a required key, or the value is of the wrong type.

An example type and instance:

@{-# LANGUAGE OverloadedStrings #-}

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

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

-- A non-Object value is of the wrong type, so use mzero to fail. parseJSON _ = mzero @

Note the use of the OverloadedStrings language extension which enables Text values to be written as string literals.

Instead of manually writing your FromJSON instance, there are three 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:
Data.Aeson.Generic provides a generic fromJSON function that parses to any type which is an instance of Data.
If your compiler has support for the DeriveGeneric and DefaultSignatures language extensions, parseJSON will have a default generic implementation.

To use this, 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 @

Note that, instead of using DefaultSignatures, it's also possible to parameterize the generic decoding using genericParseJSON applied to your encoding/decoding Options:

instance FromJSON Coord where
    parseJSON = genericParseJSON defaultOptions

Minimal complete definition

Nothing

Methods

parseJSON :: Value -> Parser a

Instances

FromJSON Bool
FromJSON Char
FromJSON Double
FromJSON Float
FromJSON Int
FromJSON Int8
FromJSON Int16
FromJSON Int32
FromJSON 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`.
FromJSON Word
FromJSON Word8
FromJSON Word16
FromJSON Word32
FromJSON Word64
FromJSON ()
FromJSON Scientific
FromJSON Number
FromJSON Text
FromJSON UTCTime
FromJSON Value
FromJSON DotNetTime
FromJSON Text
FromJSON IntSet
FromJSON ZonedTime
FromJSON Base64
FromJSON Nat
FromJSON POSIX
FromJSON AWSTime
FromJSON BasicTime
FromJSON ISO8601
FromJSON RFC822
FromJSON AuthEnv
FromJSON JSONError
FromJSON [Char]
FromJSON a => FromJSON [a]
FromJSON (Ratio Integer)
FromJSON a => FromJSON (Maybe 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`.
FromJSON a => FromJSON (Dual a)
FromJSON a => FromJSON (First a)
FromJSON a => FromJSON (Last a)
FromJSON a => FromJSON (IntMap a)
(Ord a, FromJSON a) => FromJSON (Set a)
FromJSON v => FromJSON (Tree v)
FromJSON a => FromJSON (Vector a)
(Prim a, FromJSON a) => FromJSON (Vector a)
(Storable a, FromJSON a) => FromJSON (Vector a)
(Vector Vector a, FromJSON a) => FromJSON (Vector a)
(Eq a, Hashable a, FromJSON a) => FromJSON (HashSet a)
FromJSON a => FromJSON (Sensitive a)
(FromJSON a, FromJSON b) => FromJSON (Either a b)
(FromJSON a, FromJSON b) => FromJSON (a, b)
FromJSON v => FromJSON (HashMap String v)
FromJSON v => FromJSON (HashMap Text v)
FromJSON v => FromJSON (HashMap Text v)
FromJSON v => FromJSON (Map String v)
FromJSON v => FromJSON (Map Text v)
FromJSON v => FromJSON (Map Text v)
FromJSON a => FromJSON (List1 e a)
FromJSON a => FromJSON (List e a)
(Eq k, Hashable k, FromText k, FromJSON v) => FromJSON (Map k v)
(FromJSON a, FromJSON b, FromJSON c) => FromJSON (a, b, c)
(FromJSON a, FromJSON b, FromJSON c, FromJSON d) => FromJSON (a, b, c, d)
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e) => FromJSON (a, b, c, d, e)
(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f) => FromJSON (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)
(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)
(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)
(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)
(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)
(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)
(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)
(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)
(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)

parseJSONText :: FromText a => String -> Value -> Parser a Source

eitherDecode' :: FromJSON a => ByteString -> Either String a

Like decode' but returns an error message when decoding fails.

Parser a

withObject :: String -> (Object -> Parser a) -> Value -> Parser a

withObject expected f value applies f to the Object when value is an Object and fails using typeMismatch expected otherwise.

(.:) :: FromJSON a => Object -> Text -> Parser a

Retrieve the value associated with the given key of an Object. The result is empty if the key is not present or the value cannot be converted to the desired type.

This accessor is appropriate if the key and value must be present in an object for it to be valid. If the key and value are optional, use '(.:?)' instead.

(.:?) :: FromJSON a => Object -> Text -> Parser (Maybe a)

Retrieve the value associated with the given key of an Object. The result is Nothing if the key is not present, or empty if the value cannot be converted to the desired type.

This accessor is most useful if the key and value can be absent from an object without affecting its validity. If the key and value are mandatory, use '(.:)' instead.

(.!=) :: Parser (Maybe a) -> a -> Parser a

Helper for use in combination with .:? to provide default values for optional JSON object fields.

This combinator is most useful if the key and value can be absent from an object without affecting its validity and we know a default value to assign in that case. If the key and value are mandatory, use '(.:)' instead.

Example usage:

 v1 <- o .:? "opt_field_with_dfl" .!= "default_val"
 v2 <- o .:  "mandatory_field"
 v3 <- o .:? "opt_field2"

Either String a

(.:>) :: FromJSON a => Object -> Text -> Either String a Source

(.:?>) :: FromJSON a => Object -> Text -> Either String (Maybe a) Source

ToJSON

class ToJSON a where

A type that can be converted to JSON.

An example type and instance:

@{-# LANGUAGE OverloadedStrings #-}

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

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

Note the use of the OverloadedStrings language extension which enables Text values to be written as string literals.

Instead of manually writing your ToJSON instance, there are three 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:
Data.Aeson.Generic provides a generic toJSON function that accepts any type which is an instance of Data.
If your compiler has support for the DeriveGeneric and DefaultSignatures language extensions (GHC 7.2 and newer), toJSON will have a default generic implementation.

To use the latter option, simply add a deriving Generic clause to your datatype and declare a ToJSON instance for your datatype without giving a definition for toJSON.

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 ToJSON Coord @

Note that, instead of using DefaultSignatures, it's also possible to parameterize the generic encoding using genericToJSON applied to your encoding/decoding Options:

instance ToJSON Coord where
    toJSON = genericToJSON defaultOptions

Minimal complete definition

Nothing

Methods

toJSON :: a -> Value

Instances

ToJSON Bool
ToJSON Char
ToJSON Double
ToJSON Float
ToJSON Int
ToJSON Int8
ToJSON Int16
ToJSON Int32
ToJSON Int64
ToJSON Integer
ToJSON Word
ToJSON Word8
ToJSON Word16
ToJSON Word32
ToJSON Word64
ToJSON ()
ToJSON Scientific
ToJSON Number
ToJSON Text
ToJSON UTCTime
ToJSON Value
ToJSON DotNetTime
ToJSON Text
ToJSON IntSet
ToJSON ZonedTime
ToJSON Base64
ToJSON Nat
ToJSON POSIX
ToJSON AWSTime
ToJSON BasicTime
ToJSON ISO8601
ToJSON RFC822
ToJSON Empty
ToJSON [Char]
ToJSON a => ToJSON [a]
ToJSON (Ratio Integer)
ToJSON a => ToJSON (Maybe a)
HasResolution a => ToJSON (Fixed a)
ToJSON a => ToJSON (Dual a)
ToJSON a => ToJSON (First a)
ToJSON a => ToJSON (Last a)
ToJSON a => ToJSON (IntMap a)
ToJSON a => ToJSON (Set a)
ToJSON v => ToJSON (Tree v)
ToJSON a => ToJSON (Vector a)
(Prim a, ToJSON a) => ToJSON (Vector a)
(Storable a, ToJSON a) => ToJSON (Vector a)
(Vector Vector a, ToJSON a) => ToJSON (Vector a)
ToJSON a => ToJSON (HashSet a)
ToJSON a => ToJSON (Sensitive a)
(ToJSON a, ToJSON b) => ToJSON (Either a b)
(ToJSON a, ToJSON b) => ToJSON (a, b)
ToJSON v => ToJSON (HashMap String v)
ToJSON v => ToJSON (HashMap Text v)
ToJSON v => ToJSON (HashMap Text v)
ToJSON v => ToJSON (Map String v)
ToJSON v => ToJSON (Map Text v)
ToJSON v => ToJSON (Map Text v)
ToJSON a => ToJSON (List1 e a)
ToJSON a => ToJSON (List e a)
(Eq k, Hashable k, ToText k, ToJSON v) => ToJSON (Map k v)
(ToJSON a, ToJSON b, ToJSON c) => ToJSON (a, b, c)
(ToJSON a, ToJSON b, ToJSON c, ToJSON d) => ToJSON (a, b, c, d)
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e) => ToJSON (a, b, c, d, e)
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f) => ToJSON (a, b, c, d, e, f)
(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g) => ToJSON (a, b, c, d, e, f, g)
(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)
(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)
(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)
(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)
(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)
(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)
(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)
(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)

toJSONText :: ToText a => a -> Value Source

object :: [Pair] -> Value

Create a Value from a list of name/value Pairs. If duplicate keys arise, earlier keys and their associated values win.

(.=) :: ToJSON a => Text -> a -> Pair

Construct a Pair from a key and a value.

Collections

newtype List e a Source

Constructors

List
Fields list :: [a]

Instances

IsList (List e a)
Eq a => Eq (List e a)
Ord a => Ord (List e a)
Show a => Show (List e a)
ToJSON a => ToJSON (List e a)
FromJSON a => FromJSON (List e a)
Monoid (List e a)
Semigroup (List e a)
(KnownSymbol e, ToQuery a) => ToQuery (List e a)
(KnownSymbol e, ToXML a) => ToXML (List e a)
(KnownSymbol e, FromXML a) => FromXML (List e a)
type Item (List e a) = a

newtype List1 e a Source

Constructors

List1
Fields list1 :: NonEmpty a

Instances

Functor (List1 e)
Foldable (List1 e)
Traversable (List1 e)
Eq a => Eq (List1 e a)
Ord a => Ord (List1 e a)
Show a => Show (List1 e a)
ToJSON a => ToJSON (List1 e a)
FromJSON a => FromJSON (List1 e a)
Semigroup (List1 e a)
(KnownSymbol e, ToQuery a) => ToQuery (List1 e a)
(KnownSymbol e, ToXML a) => ToXML (List1 e a)
(KnownSymbol e, FromXML a) => FromXML (List1 e a)

_List :: (Coercible a b, Coercible b a) => Iso' (List e a) [b] Source

_List1 :: (Coercible a b, Coercible b a) => Iso' (List1 e a) (NonEmpty b) Source

fromList1 :: List1 e a -> List e a Source

toList1 :: List e a -> Either String (List1 e a) Source

toQueryList :: ToQuery a => ByteString -> [a] -> Query Source

newtype Map k v Source

Constructors

Map
Fields fromMap :: HashMap k v

Instances

(Eq k, Hashable k) => IsList (Map k v)
(Eq k, Eq v) => Eq (Map k v)
(Show k, Show v) => Show (Map k v)
(Eq k, Hashable k, ToText k, ToJSON v) => ToJSON (Map k v)
(Eq k, Hashable k, FromText k, FromJSON v) => FromJSON (Map k v)
(Eq k, Hashable k) => Monoid (Map k v)
(Eq k, Hashable k) => Semigroup (Map k v)
ToHeader (Map (CI Text) Text)
type Item (Map k v) = (k, v)

_Map :: (Coercible a b, Coercible b a) => Iso' (Map k a) (HashMap k b) Source

(~::) :: ResponseHeaders -> CI Text -> Either String (Map (CI Text) Text) Source

newtype EMap e i j k v Source

Constructors

EMap
Fields fromEMap :: HashMap k v

Instances

(Eq k, Hashable k) => IsList (EMap e i j k v)
(Eq k, Eq v) => Eq (EMap e i j k v)
(Show k, Show v) => Show (EMap e i j k v)
(Eq k, Hashable k) => Monoid (EMap e i j k v)
(Eq k, Hashable k) => Semigroup (EMap e i j k v)
(KnownSymbol e, KnownSymbol i, KnownSymbol j, Eq k, Hashable k, ToQuery k, ToQuery v) => ToQuery (EMap e i j k v)
(KnownSymbol e, KnownSymbol i, KnownSymbol j, Eq k, Hashable k, ToXML k, ToXML v) => ToXML (EMap e i j k v)
(KnownSymbol e, KnownSymbol i, KnownSymbol j, Eq k, Hashable k, FromXML k, FromXML v) => FromXML (EMap e i j k v)
type Item (EMap e i j k v) = (k, v)

_EMap :: (Coercible a b, Coercible b a) => Iso' (EMap e i j k a) (HashMap k b) Source

ToByteString Double
ToByteString Int
ToByteString Integer
ToByteString ByteString
ToByteString Builder
ToByteString Text
ToByteString UTCTime
ToByteString StdMethod
ToByteString Natural
ToByteString LazyByteString
ToByteString Query
ToByteString Base64
ToByteString Nat
ToByteString AWSTime
ToByteString BasicTime
ToByteString ISO8601
ToByteString RFC822
ToByteString Action
ToByteString Region
ToByteString SecurityToken
ToByteString SecretKey
ToByteString AccessKey
ToByteString a => ToByteString (CI a)
ToByteString (Digest a)
ToByteString a => ToByteString (Sensitive a)

ToBuilder Bool
ToBuilder Char
ToBuilder Double
ToBuilder Int
ToBuilder Int64
ToBuilder Integer
ToBuilder ByteString
ToBuilder Builder
ToBuilder Text
ToBuilder UTCTime
ToBuilder RequestBody
ToBuilder Request
ToBuilder StdMethod
ToBuilder HttpVersion
ToBuilder Natural
ToBuilder LazyByteString
ToBuilder RsBody
ToBuilder RqBody
ToBuilder Query
ToBuilder Region
ToBuilder Auth
ToBuilder AuthEnv
ToBuilder AccessKey
ToBuilder [Char]
ToBuilder [Header]
ToBuilder a => ToBuilder (Maybe a)
ToBuilder a => ToBuilder (CI a)
ToBuilder (Digest a)
ToBuilder (Response a)
ToBuilder (Request a)
ToBuilder (Meta V2)
ToBuilder (Meta V3)
ToBuilder (Meta V4)

Eq Base64
Ord Base64
Show Base64
Generic Base64
ToJSON Base64
FromJSON Base64
ToText Base64
FromText Base64
ToByteString Base64
ToQuery Base64
ToXML Base64
FromXML Base64
type Rep Base64

FromText Bool
FromText Double
FromText Int
FromText Integer
FromText ByteString
FromText Text
FromText Natural
FromText Base64
FromText Nat
FromText POSIX
FromText AWSTime
FromText BasicTime
FromText ISO8601
FromText RFC822
FromText Region
FromText ErrorType
FromText a => FromText (Sensitive a)

Eq UTCTime
Data UTCTime
Ord UTCTime
Read UTCTime
Show UTCTime
ToJSON UTCTime
FromJSON UTCTime
NFData UTCTime
FormatTime UTCTime
ParseTime UTCTime
ToBuilder UTCTime
ToByteString UTCTime
Typeable * UTCTime