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

Enum Format

Eq Format

Ord Format

Show Format

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)

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)

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)

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)

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)

Ord (Input i)

Show (Input i)

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)

Ord (Output o)

Show (Output o)

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)

Ord (Error e)

Show (Error e)

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

Show Xml

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

Show Json

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)

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 :: *

Instances

type FromMaybe b (Nothing *) = b

type FromMaybe b (Just * a) = a