http-types-0.9.1: Generic HTTP types for Haskell (for both client and server code).

Safe HaskellNone
LanguageHaskell98

Network.HTTP.Types

Contents

Synopsis

Methods

type Method = ByteString #

HTTP method (flat string type).

methodGet :: Method #

HTTP Method constants.

methodPost :: Method #

HTTP Method constants.

methodHead :: Method #

HTTP Method constants.

methodPut :: Method #

HTTP Method constants.

methodDelete :: Method #

HTTP Method constants.

methodTrace :: Method #

HTTP Method constants.

methodConnect :: Method #

HTTP Method constants.

methodOptions :: Method #

HTTP Method constants.

methodPatch :: Method #

HTTP Method constants.

data StdMethod #

HTTP standard method (as defined by RFC 2616, and PATCH which is defined by RFC 5789).

Constructors

GET 
POST 
HEAD 
PUT 
DELETE 
TRACE 
CONNECT 
OPTIONS 
PATCH 

parseMethod :: Method -> Either ByteString StdMethod #

Convert a method ByteString to a StdMethod if possible.

renderMethod :: Either ByteString StdMethod -> Method #

Convert an algebraic method to a ByteString.

renderStdMethod :: StdMethod -> Method #

Convert a StdMethod to a ByteString.

Versions

http09 :: HttpVersion #

HTTP 0.9

http10 :: HttpVersion #

HTTP 1.0

http11 :: HttpVersion #

HTTP 1.1

Status

data Status #

HTTP Status.

Only the statusCode is used for comparisons.

Please use mkStatus to create status codes from code and message, or the Enum instance or the status code constants (like ok200). There might be additional record members in the future.

Note that the Show instance is only for debugging.

Constructors

Status 

mkStatus :: Int -> ByteString -> Status #

Create a Status from status code and message.

status100 :: Status #

Continue 100

continue100 :: Status #

Continue 100

status101 :: Status #

Switching Protocols 101

switchingProtocols101 :: Status #

Switching Protocols 101

status200 :: Status #

OK 200

ok200 :: Status #

OK 200

status201 :: Status #

Created 201

created201 :: Status #

Created 201

status202 :: Status #

Accepted 202

accepted202 :: Status #

Accepted 202

status203 :: Status #

Non-Authoritative Information 203

nonAuthoritative203 :: Status #

Non-Authoritative Information 203

status204 :: Status #

No Content 204

noContent204 :: Status #

No Content 204

status205 :: Status #

Reset Content 205

resetContent205 :: Status #

Reset Content 205

status206 :: Status #

Partial Content 206

partialContent206 :: Status #

Partial Content 206

status300 :: Status #

Multiple Choices 300

multipleChoices300 :: Status #

Multiple Choices 300

status301 :: Status #

Moved Permanently 301

movedPermanently301 :: Status #

Moved Permanently 301

status302 :: Status #

Found 302

found302 :: Status #

Found 302

status303 :: Status #

See Other 303

seeOther303 :: Status #

See Other 303

status304 :: Status #

Not Modified 304

notModified304 :: Status #

Not Modified 304

status305 :: Status #

Use Proxy 305

useProxy305 :: Status #

Use Proxy 305

status307 :: Status #

Temporary Redirect 307

temporaryRedirect307 :: Status #

Temporary Redirect 307

status400 :: Status #

Bad Request 400

badRequest400 :: Status #

Bad Request 400

status401 :: Status #

Unauthorized 401

unauthorized401 :: Status #

Unauthorized 401

status402 :: Status #

Payment Required 402

paymentRequired402 :: Status #

Payment Required 402

status403 :: Status #

Forbidden 403

forbidden403 :: Status #

Forbidden 403

status404 :: Status #

Not Found 404

notFound404 :: Status #

Not Found 404

status405 :: Status #

Method Not Allowed 405

methodNotAllowed405 :: Status #

Method Not Allowed 405

status406 :: Status #

Not Acceptable 406

notAcceptable406 :: Status #

Not Acceptable 406

status407 :: Status #

Proxy Authentication Required 407

proxyAuthenticationRequired407 :: Status #

Proxy Authentication Required 407

status408 :: Status #

Request Timeout 408

requestTimeout408 :: Status #

Request Timeout 408

status409 :: Status #

Conflict 409

conflict409 :: Status #

Conflict 409

status410 :: Status #

Gone 410

gone410 :: Status #

Gone 410

status411 :: Status #

Length Required 411

lengthRequired411 :: Status #

Length Required 411

status412 :: Status #

Precondition Failed 412

preconditionFailed412 :: Status #

Precondition Failed 412

status413 :: Status #

Request Entity Too Large 413

requestEntityTooLarge413 :: Status #

Request Entity Too Large 413

status414 :: Status #

Request-URI Too Long 414

requestURITooLong414 :: Status #

Request-URI Too Long 414

status415 :: Status #

Unsupported Media Type 415

unsupportedMediaType415 :: Status #

Unsupported Media Type 415

status416 :: Status #

Requested Range Not Satisfiable 416

requestedRangeNotSatisfiable416 :: Status #

Requested Range Not Satisfiable 416

status417 :: Status #

Expectation Failed 417

expectationFailed417 :: Status #

Expectation Failed 417

status418 :: Status #

I'm a teapot 418

imATeaPot418 :: Status #

I'm a teapot 418

status500 :: Status #

Internal Server Error 500

internalServerError500 :: Status #

Internal Server Error 500

status501 :: Status #

Not Implemented 501

notImplemented501 :: Status #

Not Implemented 501

status502 :: Status #

Bad Gateway 502

badGateway502 :: Status #

Bad Gateway 502

status503 :: Status #

Service Unavailable 503

serviceUnavailable503 :: Status #

Service Unavailable 503

status504 :: Status #

Gateway Timeout 504

gatewayTimeout504 :: Status #

Gateway Timeout 504

status505 :: Status #

HTTP Version Not Supported 505

httpVersionNotSupported505 :: Status #

HTTP Version Not Supported 505

statusIsInformational :: Status -> Bool #

Informational class

statusIsSuccessful :: Status -> Bool #

Successful class

statusIsRedirection :: Status -> Bool #

Redirection class

statusIsClientError :: Status -> Bool #

Client Error class

statusIsServerError :: Status -> Bool #

Server Error class

Headers

Types

type Header = (HeaderName, ByteString) #

Header

type HeaderName = CI ByteString #

Header name

type RequestHeaders = [Header] #

Request Headers

type ResponseHeaders = [Header] #

Response Headers

Common headers

Byte ranges

data ByteRange #

RFC 2616 Byte range (individual).

Negative indices are not allowed!

Instances

Eq ByteRange # 
Data ByteRange # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ByteRange -> c ByteRange #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ByteRange #

toConstr :: ByteRange -> Constr #

dataTypeOf :: ByteRange -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ByteRange) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ByteRange) #

gmapT :: (forall b. Data b => b -> b) -> ByteRange -> ByteRange #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ByteRange -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ByteRange -> r #

gmapQ :: (forall d. Data d => d -> u) -> ByteRange -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ByteRange -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ByteRange -> m ByteRange #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteRange -> m ByteRange #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteRange -> m ByteRange #

Ord ByteRange # 
Show ByteRange # 

type ByteRanges = [ByteRange] #

RFC 2616 Byte ranges (set).

parseByteRanges :: ByteString -> Maybe ByteRanges #

Parse the value of a Range header into a ByteRanges.

>>> parseByteRanges "error"
Nothing
>>> parseByteRanges "bytes=0-499"
Just [ByteRangeFromTo 0 499]
>>> parseByteRanges "bytes=500-999"
Just [ByteRangeFromTo 500 999]
>>> parseByteRanges "bytes=-500"
Just [ByteRangeSuffix 500]
>>> parseByteRanges "bytes=9500-"
Just [ByteRangeFrom 9500]
>>> parseByteRanges "bytes=0-0,-1"
Just [ByteRangeFromTo 0 0,ByteRangeSuffix 1]
>>> parseByteRanges "bytes=500-600,601-999"
Just [ByteRangeFromTo 500 600,ByteRangeFromTo 601 999]
>>> parseByteRanges "bytes=500-700,601-999"
Just [ByteRangeFromTo 500 700,ByteRangeFromTo 601 999]

URI

Query string

type QueryItem = (ByteString, Maybe ByteString) #

Query item

type Query = [QueryItem] #

Query.

General form: a=b&c=d, but if the value is Nothing, it becomes a&c=d.

type SimpleQueryItem = (ByteString, ByteString) #

Simplified Query item type without support for parameter-less items.

type SimpleQuery = [SimpleQueryItem] #

Simplified Query type without support for parameter-less items.

renderQuery #

Arguments

:: Bool

prepend question mark?

-> Query 
-> ByteString 

Convert Query to ByteString.

renderQueryBuilder #

Arguments

:: Bool

prepend a question mark?

-> Query 
-> Builder 

Convert Query to a Builder.

renderSimpleQuery #

Arguments

:: Bool

prepend question mark?

-> SimpleQuery 
-> ByteString 

Convert SimpleQuery to ByteString.

parseQuery :: ByteString -> Query #

Split out the query string into a list of keys and values. A few importants points:

  • The result returned is still bytestrings, since we perform no character decoding here. Most likely, you will want to use UTF-8 decoding, but this is left to the user of the library.
  • Percent decoding errors are ignored. In particular, "%Q" will be output as "%Q".

parseSimpleQuery :: ByteString -> SimpleQuery #

Parse SimpleQuery from a ByteString.

Text query string (UTF8 encoded)

type QueryText = [(Text, Maybe Text)] #

Like Query, but with Text instead of ByteString (UTF8-encoded).

queryToQueryText :: Query -> QueryText #

Convert Query to QueryText (leniently decoding the UTF-8).

renderQueryText #

Arguments

:: Bool

prepend a question mark?

-> QueryText 
-> Builder 

Convert QueryText to a Builder.

parseQueryText :: ByteString -> QueryText #

Parse QueryText from a ByteString. See parseQuery for details.

Generalized query types

class QueryLike a where #

Types which can, and commonly are, converted to Query are in this class.

You can use lists of simple key value pairs, with ByteString (strict, or lazy: ByteString), Text, or String as the key/value types. You can also have the value type lifted into a Maybe to support keys without values; and finally it is possible to put each pair into a Maybe for key-value pairs that aren't always present.

Minimal complete definition

toQuery

Methods

toQuery :: a -> Query #

Convert to Query.

Instances

(QueryKeyLike k, QueryValueLike v) => QueryLike [Maybe (k, v)] # 

Methods

toQuery :: [Maybe (k, v)] -> Query #

(QueryKeyLike k, QueryValueLike v) => QueryLike [(k, v)] # 

Methods

toQuery :: [(k, v)] -> Query #

Path segments

encodePathSegments :: [Text] -> Builder #

Encodes a list of path segments into a valid URL fragment.

This function takes the following three steps:

  • UTF-8 encodes the characters.
  • Performs percent encoding on all unreserved characters, as well as :@=+$,
  • Prepends each segment with a slash.

For example:

encodePathSegments [\"foo\", \"bar\", \"baz\"]

"/foo/bar/baz"

encodePathSegments [\"foo bar\", \"baz\/bin\"]

"/foo%20bar/baz%2Fbin"

encodePathSegments [\"שלום\"]

"/%D7%A9%D7%9C%D7%95%D7%9D"

Huge thanks to Jeremy Shaw who created the original implementation of this function in web-routes and did such thorough research to determine all correct escaping procedures.

decodePathSegments :: ByteString -> [Text] #

Parse a list of path segments from a valid URL fragment.

encodePathSegmentsRelative :: [Text] -> Builder #

Like encodePathSegments, but without the initial slash.

Path (segments + query string)

extractPath :: ByteString -> ByteString #

Extract whole path (path segments + query) from a RFC 2616 Request-URI.

>>> extractPath "/path"
"/path"
>>> extractPath "http://example.com:8080/path"
"/path"
>>> extractPath "http://example.com"
"/"
>>> extractPath ""
"/"

encodePath :: [Text] -> Query -> Builder #

Encode a whole path (path segments + query).

decodePath :: ByteString -> ([Text], Query) #

Decode a whole path (path segments + query).

URL encoding / decoding

urlEncodeBuilder #

Arguments

:: Bool

Whether input is in query string. True: Query string, False: Path element

-> ByteString 
-> Builder 

Percent-encoding for URLs (using Builder).

urlEncode #

Arguments

:: Bool

Whether to decode + to ' '

-> ByteString

The ByteString to encode as URL

-> ByteString

The encoded URL

Percent-encoding for URLs.

urlDecode #

Arguments

:: Bool

Whether to decode + to ' '

-> ByteString 
-> ByteString 

Percent-decoding.