Symantic.HTTP.API

Combinators to build a Web API.

Class Cat

class Cat repr where

A soft and cute animal asking strokes and croquettes. Or rather here a composition of two combinators (as in a category without an identity morphism).

Note that the order of combinators generally matters (the left one is applied first), with the notable exception of the server instance where some HTTP error codes must be prioritized.

Methods

(<.>) :: repr a b -> repr b c -> repr a c infixl 4

Class Alt

class Alt repr where

There are two choices, either the right one or the left one. The (:!:) data type will be used in the instances to get multiple client callers or to supply multiple server handlers.

Methods

(<!>) :: repr a k -> repr b k -> repr (a :!: b) k infixl 3

Type (:!:)

data a :!: b infixl 3

Like (,) but infixl. Used to get alternative commands from a Client or to supply alternative handlers to a Server.

Constructors

a :!: b infixl 3

Class Pro

class Pro repr where

Mainly useful to write a combinator which is a specialization of another (eg. queryFlag wrt. queryParams), by calling it directly in the class declaration instead of rewriting its logic in the instance declaration.

Because type a is asked by a Client but given to a Server, both a->b and b->a are used. This is reminiscent of a Profunctor. Hence the names Pro and dimap.

Methods

dimap :: (a -> b) -> (b -> a) -> repr (a -> k) k -> repr (b -> k) k

Class HTTP_Path

class HTTP_Path repr where

Associated Types

type PathConstraint repr a :: Constraint

Methods

segment :: Segment -> repr k k

capture' :: PathConstraint repr a => Name -> repr (a -> k) k

captureAll :: repr ([Segment] -> k) k

(</>) :: Cat repr => HTTP_Path repr => Segment -> repr a b -> repr a b infixr 5

Convenient wrapper of segment.

capture :: forall a k repr. HTTP_Path repr => PathConstraint repr a => Name -> repr (a -> k) k

Like capture' but with the type variable a first instead or repr so it can be passed using TypeApplications without adding a @_ for repr.

type Segment = Text

type Path = [Segment]

type Name = String

Class HTTP_Header

class HTTP_Header repr where

Methods

header :: HeaderName -> repr (HeaderValue -> k) k

type HeaderValue = ByteString

Class HTTP_Body

class HTTP_Body repr where

Associated Types

type BodyArg repr a (ts :: [*]) :: *

type BodyConstraint repr a (ts :: [*]) :: Constraint

Methods

body' :: forall a (ts :: [*]) k. BodyConstraint repr a ts => repr (BodyArg repr a ts -> k) k

body :: forall a ts k repr. HTTP_Body repr => BodyConstraint repr a ts => repr (BodyArg repr a ts -> k) k

Like body' but with the type variables a and ts first instead or repr, so it can be passed using TypeApplications without adding a @_ for repr.

Class HTTP_BodyStream

class HTTP_BodyStream repr where

Associated Types

type BodyStreamArg repr as (ts :: [*]) framing :: *

type BodyStreamConstraint repr as (ts :: [*]) framing :: Constraint

Methods

bodyStream' :: BodyStreamConstraint repr as ts framing => repr (BodyStreamArg repr as ts framing -> k) k

bodyStream :: forall as ts framing k repr. HTTP_BodyStream repr => BodyStreamConstraint repr as ts framing => repr (BodyStreamArg repr as ts framing -> k) k

Like bodyStream' but with the type variables as, ts and framing first instead or repr, so it can be passed using TypeApplications without adding a @_ for repr.

Class HTTP_Query

class HTTP_Query repr where

Minimal complete definition

queryParams'

Associated Types

type QueryConstraint repr a :: Constraint

Methods

queryParams' :: QueryConstraint repr a => QueryName -> repr ([a] -> k) k

queryFlag :: QueryConstraint repr Bool => QueryName -> repr (Bool -> k) k

queryFlag :: Pro repr => QueryConstraint repr Bool => QueryName -> repr (Bool -> k) k

type QueryName = ByteString

type QueryValue = ByteString

queryParams :: forall a k repr. HTTP_Query repr => QueryConstraint repr a => QueryName -> repr ([a] -> k) k

Like capture' but with the type variable a first instead or repr so it can be passed using TypeApplications without adding a @_ for repr.

Class HTTP_BasicAuth

class HTTP_BasicAuth repr where

Basic Access Authentication

Associated Types

type BasicAuthConstraint repr a :: Constraint

type BasicAuthArgs repr a k :: *

Methods

basicAuth' :: BasicAuthConstraint repr a => BasicAuthRealm -> repr (BasicAuthArgs repr a k) k

basicAuth :: forall a k repr. HTTP_BasicAuth repr => BasicAuthConstraint repr a => BasicAuthRealm -> repr (BasicAuthArgs repr a k) k

Like basicAuth' but with the type variable a first instead or repr so it can be passed using TypeApplications without adding a @_ for repr.

Type BasicAuth

data BasicAuth usr

Constructors

BasicAuth_Authorized usr

BasicAuth_BadPassword

BasicAuth_NoSuchUser

BasicAuth_Unauthorized

Instances

Functor BasicAuth

Defined in Symantic.HTTP.API

Methods

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

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

Eq usr => Eq (BasicAuth usr)

Defined in Symantic.HTTP.API

Methods

(==) :: BasicAuth usr -> BasicAuth usr -> Bool

(/=) :: BasicAuth usr -> BasicAuth usr -> Bool

Show usr => Show (BasicAuth usr)

Defined in Symantic.HTTP.API

Methods

showsPrec :: Int -> BasicAuth usr -> ShowS

show :: BasicAuth usr -> String

showList :: [BasicAuth usr] -> ShowS

type BasicAuthRealm = Text

type BasicAuthUser = Text

type BasicAuthPass = Text

Class HTTP_Version

class HTTP_Version repr where

Methods

version :: HttpVersion -> repr k k

Class HTTP_Response

class HTTP_Response repr where

Associated Types

type ResponseConstraint repr a (ts :: [*]) :: Constraint

type ResponseArgs repr a (ts :: [*]) :: *

type Response repr :: *

Methods

response :: ResponseConstraint repr a ts => Method -> repr (ResponseArgs repr a ts) (Response repr)

get :: forall a ts repr. HTTP_Response repr => ResponseConstraint repr a ts => repr (ResponseArgs repr a ts) (Response repr)

Wrap response by giving it the corresponding Method, and put the type variables a then ts first instead or repr so they can be passed using TypeApplications without adding a |@_| for repr.

head :: forall a ts repr. HTTP_Response repr => ResponseConstraint repr a ts => repr (ResponseArgs repr a ts) (Response repr)

Wrap response by giving it the corresponding Method, and put the type variables a then ts first instead or repr so they can be passed using TypeApplications without adding a |@_| for repr.

put :: forall a ts repr. HTTP_Response repr => ResponseConstraint repr a ts => repr (ResponseArgs repr a ts) (Response repr)

Wrap response by giving it the corresponding Method, and put the type variables a then ts first instead or repr so they can be passed using TypeApplications without adding a |@_| for repr.

post :: forall a ts repr. HTTP_Response repr => ResponseConstraint repr a ts => repr (ResponseArgs repr a ts) (Response repr)

Wrap response by giving it the corresponding Method, and put the type variables a then ts first instead or repr so they can be passed using TypeApplications without adding a |@_| for repr.

delete :: forall a ts repr. HTTP_Response repr => ResponseConstraint repr a ts => repr (ResponseArgs repr a ts) (Response repr)

Wrap response by giving it the corresponding Method, and put the type variables a then ts first instead or repr so they can be passed using TypeApplications without adding a |@_| for repr.

trace :: forall a ts repr. HTTP_Response repr => ResponseConstraint repr a ts => repr (ResponseArgs repr a ts) (Response repr)

Wrap response by giving it the corresponding Method, and put the type variables a then ts first instead or repr so they can be passed using TypeApplications without adding a |@_| for repr.

connect :: forall a ts repr. HTTP_Response repr => ResponseConstraint repr a ts => repr (ResponseArgs repr a ts) (Response repr)

Wrap response by giving it the corresponding Method, and put the type variables a then ts first instead or repr so they can be passed using TypeApplications without adding a |@_| for repr.

options :: forall a ts repr. HTTP_Response repr => ResponseConstraint repr a ts => repr (ResponseArgs repr a ts) (Response repr)

Wrap response by giving it the corresponding Method, and put the type variables a then ts first instead or repr so they can be passed using TypeApplications without adding a |@_| for repr.

patch :: forall a ts repr. HTTP_Response repr => ResponseConstraint repr a ts => repr (ResponseArgs repr a ts) (Response repr)

Wrap response by giving it the corresponding Method, and put the type variables a then ts first instead or repr so they can be passed using TypeApplications without adding a |@_| for repr.

Class HTTP_ResponseStream

class HTTP_ResponseStream repr where

Associated Types

type ResponseStreamConstraint repr as (ts :: [*]) framing :: Constraint

type ResponseStreamArgs repr as (ts :: [*]) framing :: *

type ResponseStream repr :: *

Methods

responseStream :: ResponseStreamConstraint repr as ts framing => Method -> repr (ResponseStreamArgs repr as ts framing) (ResponseStream repr)

getStream :: forall as ts framing repr. HTTP_ResponseStream repr => ResponseStreamConstraint repr as ts framing => repr (ResponseStreamArgs repr as ts framing) (ResponseStream repr)

headStream :: forall as ts framing repr. HTTP_ResponseStream repr => ResponseStreamConstraint repr as ts framing => repr (ResponseStreamArgs repr as ts framing) (ResponseStream repr)

putStream :: forall as ts framing repr. HTTP_ResponseStream repr => ResponseStreamConstraint repr as ts framing => repr (ResponseStreamArgs repr as ts framing) (ResponseStream repr)

postStream :: forall as ts framing repr. HTTP_ResponseStream repr => ResponseStreamConstraint repr as ts framing => repr (ResponseStreamArgs repr as ts framing) (ResponseStream repr)

deleteStream :: forall as ts framing repr. HTTP_ResponseStream repr => ResponseStreamConstraint repr as ts framing => repr (ResponseStreamArgs repr as ts framing) (ResponseStream repr)

traceStream :: forall as ts framing repr. HTTP_ResponseStream repr => ResponseStreamConstraint repr as ts framing => repr (ResponseStreamArgs repr as ts framing) (ResponseStream repr)

connectStream :: forall as ts framing repr. HTTP_ResponseStream repr => ResponseStreamConstraint repr as ts framing => repr (ResponseStreamArgs repr as ts framing) (ResponseStream repr)

optionsStream :: forall as ts framing repr. HTTP_ResponseStream repr => ResponseStreamConstraint repr as ts framing => repr (ResponseStreamArgs repr as ts framing) (ResponseStream repr)

patchStream :: forall as ts framing repr. HTTP_ResponseStream repr => ResponseStreamConstraint repr as ts framing => repr (ResponseStreamArgs repr as ts framing) (ResponseStream repr)

Framing

Type family FramingMonad

type family FramingMonad p :: * -> *

Type family FramingYield

type family FramingYield p :: *

Type family FramingReturn

type family FramingReturn p :: *

Class FramingEncode

class FramingEncode framing p where

Methods

framingEncode :: Proxy framing -> (FramingYield p -> ByteString) -> p -> IO (Either (FramingReturn p) (ByteString, p))

Class FramingDecode

class FramingDecode framing p where

Methods

framingDecode :: FramingMonad p ~ m => Monad m => Proxy framing -> (ByteString -> Either String (FramingYield p)) -> m ByteString -> p

Type NoFraming

data NoFraming

A framing strategy that does not do any framing at all, it just passes the input data. Most of the time this will be used with binary data, such as files.

Type NewlineFraming

data NewlineFraming

A simple framing strategy that has no header, and inserts a newline character after each frame. WARNING: this assumes that it is used with a Content-Type that encodes without newlines (e.g. JSON).

Type NetstringFraming

data NetstringFraming

The netstring framing strategy as defined by djb: http://cr.yp.to/proto/netstrings.txt

Any string of 8-bit bytes may be encoded as [len]":"[string]",". Here [string] is the string and [len] is a nonempty sequence of ASCII digits giving the length of [string] in decimal. The ASCII digits are 30 for 0, 31 for 1, and so on up through 39 for 9. Extra zeros at the front of [len] are prohibited: [len] begins with 30 exactly when [string] is empty.

For example, the string "hello world!" is encoded as 32 3a 68 65 6c 6c 6f 20 77 6f 72 6c 64 21 2c, i.e., "12:hello world!,". The empty string is encoded as "0:,".