Rest.Dictionary.Types

Possible I/O formats.

data Format

The Format datatype enumerates all input and output formats we might recognize.

Constructors

XmlFormat

JsonFormat

StringFormat

FileFormat

MultipartFormat

NoFormat

Instances

Bounded Format

Methods

minBound :: Format

maxBound :: Format

Enum Format

Methods

succ :: Format -> Format

pred :: Format -> Format

toEnum :: Int -> Format

fromEnum :: Format -> Int

enumFrom :: Format -> [Format]

enumFromThen :: Format -> Format -> [Format]

enumFromTo :: Format -> Format -> [Format]

enumFromThenTo :: Format -> Format -> Format -> [Format]

Eq Format

Methods

(==) :: Format -> Format -> Bool

(/=) :: Format -> Format -> Bool

Ord Format

Methods

compare :: Format -> Format -> Ordering

(<) :: Format -> Format -> Bool

(<=) :: Format -> Format -> Bool

(>) :: Format -> Format -> Bool

(>=) :: Format -> Format -> Bool

max :: Format -> Format -> Format

min :: Format -> Format -> Format

Show Format

Methods

showsPrec :: Int -> Format -> ShowS

show :: Format -> String

showList :: [Format] -> ShowS

The dictionary type.

data Dict h p i o e

The Dict datatype containing sub-dictionaries for translation of identifiers (i), headers (h), parameters (p), inputs (i), outputs (o), and errors (e). Inputs, outputs and errors can have multiple associated dictionaries.

Instances

Show (Dict h p i o e)

Methods

showsPrec :: Int -> Dict h p i o e -> ShowS

show :: Dict h p i o e -> String

showList :: [Dict h p i o e] -> ShowS

headers :: forall cat h p i o e a. ArrowApply cat => Lens cat (Dict h p i o e -> Dict a p i o e) (Header h -> Header a)

params :: forall cat h p i o e a. ArrowApply cat => Lens cat (Dict h p i o e -> Dict h a i o e) (Param p -> Param a)

inputs :: forall cat h p i o e a. ArrowApply cat => Lens cat (Dict h p i o e -> Dict h p a o e) (Inputs i -> Inputs a)

outputs :: forall cat h p i o e a. ArrowApply cat => Lens cat (Dict h p i o e -> Dict h p i a e) (Outputs o -> Outputs a)

errors :: forall cat h p i o e a. ArrowApply cat => Lens cat (Dict h p i o e -> Dict h p i o a) (Errors e -> Errors a)

empty :: Dict () () Nothing Nothing Nothing

The empty dictionary, recognizing no types.

type Modifier h p i o e = Dict () () Nothing Nothing Nothing -> Dict h p i o e

Type synonym for dictionary modification.

Dictionary aspects.

data Ident id where

The explicit dictionary Ident describes how to translate a resource identifier (originating from a request URI) to a Haskell value. We allow plain String identifiers or all Haskell types that have a Read instance.

Constructors

ReadId :: (Info id, Read id) => Ident id

StringId :: Ident String

Instances

Show (Ident id)

Methods

showsPrec :: Int -> Ident id -> ShowS

show :: Ident id -> String

showList :: [Ident id] -> ShowS

data Header h where

The explicit dictionary Header describes how to translate HTTP request headers to some Haskell value. The first field in the Header constructor is a white list of headers we can recognize, used in generic validation and for generating documentation. The second field is a custom parser that can fail with a DataError or can produce a some value. When explicitly not interested in the headers we can use NoHeader.

Constructors

NoHeader :: Header ()

Header :: [String] -> ([Maybe String] -> Either DataError h) -> Header h

TwoHeaders :: Header h -> Header k -> Header (h, k)

Instances

Show (Header h)

Methods

showsPrec :: Int -> Header h -> ShowS

show :: Header h -> String

showList :: [Header h] -> ShowS

data Param p where

The explicit dictionary Param describes how to translate the request parameters to some Haskell value. The first field in the Param constructor is a white list of paramters we can recognize, used in generic validation and for generating documentation. The second field is a custom parser that can fail with a DataError or can produce a some value. When explicitly not interested in the parameters we can use NoParam.

Constructors

NoParam :: Param ()

Param :: [String] -> ([Maybe String] -> Either DataError p) -> Param p

TwoParams :: Param p -> Param q -> Param (p, q)

Instances

Show (Param p)

Methods

showsPrec :: Int -> Param p -> ShowS

show :: Param p -> String

showList :: [Param p] -> ShowS

data Input i where

The explicit dictionary Input describes how to translate the request body into some Haskell value. We currently use a constructor for every combination of input type to output type. For example, we can use XML input in multiple ways, parsed, as plain/text or as raw bytes, depending on the needs of the backend resource.

Constructors

JsonI :: (Typeable i, FromJSON i, JSONSchema i) => Input i

ReadI :: (Info i, Read i, Show i) => Input i

StringI :: Input String

FileI :: Input ByteString

XmlI :: (Typeable i, XmlPickler i) => Input i

XmlTextI :: Input Text

RawJsonI :: Input ByteString

RawXmlI :: Input ByteString

RawJsonAndXmlI :: Input (Either Json Xml)

Instances

Eq (Input i)

Methods

(==) :: Input i -> Input i -> Bool

(/=) :: Input i -> Input i -> Bool

Ord (Input i)

Methods

compare :: Input i -> Input i -> Ordering

(<) :: Input i -> Input i -> Bool

(<=) :: Input i -> Input i -> Bool

(>) :: Input i -> Input i -> Bool

(>=) :: Input i -> Input i -> Bool

max :: Input i -> Input i -> Input i

min :: Input i -> Input i -> Input i

Show (Input i)

Methods

showsPrec :: Int -> Input i -> ShowS

show :: Input i -> String

showList :: [Input i] -> ShowS

data Output o where

The explicit dictionary Output describes how to translate some Haskell value to a response body. We currently use a constructor for every combination of input type to output type.

Constructors

FileO :: Output (ByteString, String, Bool)

RawJsonO :: Output ByteString

RawXmlO :: Output ByteString

JsonO :: (Typeable o, ToJSON o, JSONSchema o) => Output o

XmlO :: (Typeable o, XmlPickler o) => Output o

StringO :: Output String

RawJsonAndXmlO :: Output ByteString

MultipartO :: Output [BodyPart]

Instances

Eq (Output o)

Methods

(==) :: Output o -> Output o -> Bool

(/=) :: Output o -> Output o -> Bool

Ord (Output o)

Methods

compare :: Output o -> Output o -> Ordering

(<) :: Output o -> Output o -> Bool

(<=) :: Output o -> Output o -> Bool

(>) :: Output o -> Output o -> Bool

(>=) :: Output o -> Output o -> Bool

max :: Output o -> Output o -> Output o

min :: Output o -> Output o -> Output o

Show (Output o)

Methods

showsPrec :: Int -> Output o -> ShowS

show :: Output o -> String

showList :: [Output o] -> ShowS

data Error e where

The explicit dictionary Error describes how to translate some Haskell error value to a response body.

Constructors

JsonE :: (ToResponseCode e, Typeable e, ToJSON e, JSONSchema e) => Error e

XmlE :: (ToResponseCode e, Typeable e, XmlPickler e) => Error e

Instances

Eq (Error e)

Methods

(==) :: Error e -> Error e -> Bool

(/=) :: Error e -> Error e -> Bool

Ord (Error e)

Methods

compare :: Error e -> Error e -> Ordering

(<) :: Error e -> Error e -> Bool

(<=) :: Error e -> Error e -> Bool

(>) :: Error e -> Error e -> Bool

(>=) :: Error e -> Error e -> Bool

max :: Error e -> Error e -> Error e

min :: Error e -> Error e -> Error e

Show (Error e)

Methods

showsPrec :: Int -> Error e -> ShowS

show :: Error e -> String

showList :: [Error e] -> ShowS

newtype Xml

Newtype around ByteStrings used in RawJsonAndXmlI to add some protection from parsing the input incorrectly.

Constructors

Xml

Fields

• unXml :: ByteString

Instances

Eq Xml

Methods

(==) :: Xml -> Xml -> Bool

(/=) :: Xml -> Xml -> Bool

Show Xml

Methods

showsPrec :: Int -> Xml -> ShowS

show :: Xml -> String

showList :: [Xml] -> ShowS

newtype Json

Newtype around ByteStrings used in RawJsonAndXmlI to add some protection from parsing the input incorrectly.

Constructors

Json

Fields

• unJson :: ByteString

Instances

Eq Json

Methods

(==) :: Json -> Json -> Bool

(/=) :: Json -> Json -> Bool

Show Json

Methods

showsPrec :: Int -> Json -> ShowS

show :: Json -> String

showList :: [Json] -> ShowS

Plural dictionaries.

data Dicts f a where

Constructors

None :: Dicts f Nothing

Dicts :: [f a] -> Dicts f (Just a)

Instances

Show (f (FromMaybe Void a)) => Show (Dicts f a)

Methods

showsPrec :: Int -> Dicts f a -> ShowS

show :: Dicts f a -> String

showList :: [Dicts f a] -> ShowS

dicts :: forall a o f. o ~ FromMaybe o a => Dicts f a :-> [f o]

Deprecated: The modifier for this lens doesn't do anything when Dicts is None. Use getDicts and modDicts instead.

getDicts :: o ~ FromMaybe o a => Dicts f a -> [f o]

Get the list of dictionaries. If there are none, you get a [o]. If this is too polymorphic, try getDicts_.

getDicts_ :: o ~ FromMaybe () a => Dicts f a -> [f o]

Get the list of dictionaries. If there are none, you get a [()]. Sometimes useful to constraint the types if the element type of the list isn't clear from the context.

modDicts :: FromMaybe o i ~ o => ([f o] -> [f o]) -> Dicts f i -> Dicts f (Just o)

type Inputs i = Dicts Input i

type Outputs o = Dicts Output o

type Errors e = Dicts Error e

data SomeError where

Custom existential packing an error together with a Reason.

Constructors

SomeError :: Errors e -> Reason (FromMaybe Void e) -> SomeError

type family FromMaybe d (m :: Maybe *) :: *

Instances

type FromMaybe b (Nothing *)

type FromMaybe b (Nothing *) = b

type FromMaybe b (Just * a)

type FromMaybe b (Just * a) = a