Network.HTTP.Media

An HTTP media type, consisting of the type, subtype, and parameters.

Builds a MediaType without parameters. Can produce an error if either type is invalid.

Adds a parameter to a MediaType. Can produce an error if either string is invalid.

Retrieves the main type of a MediaType.

Retrieves the sub type of a MediaType.

Retrieves the parameters of a MediaType.

Evaluates if a MediaType has a parameter of the given name.

Retrieves a parameter from a MediaType.

Suitable for HTTP charset as defined in RFC7231.

Specifically:

charset = token / "*"

Suitable for HTTP encoding as defined in RFC7231.

Specifically:

codings = content-coding / "identity" / "*"

Suitable for HTTP language-ranges as defined in RFC4647.

Specifically:

language-range = (1*8ALPHA *("-" 1*8alphanum)) / "*"

Converts Language to a list of its language parts. The wildcard produces an empty list.

Matches a list of server-side resource options against a quality-marked list of client-side preferences. A result of Nothing means that nothing matched (which should indicate a 406 error). If two or more results arise with the same quality level and specificity, then the first one in the server list is chosen.

The use of the Accept type class allows the application of either MediaType for the standard Accept header or ByteString for any other Accept header which can be marked with a quality value.

matchAccept ["text/html", "application/json"] <$> getHeader

For more information on the matching process see RFC 2616, section 14.1-4.

The equivalent of matchAccept above, except the resulting choice is mapped to another value. Convenient for specifying how to translate the resource into each of its available formats.

getHeader >>= maybe render406Error renderResource . mapAccept
    [ ("text" // "html",        asHtml)
    , ("application" // "json", asJson)
    ]

A specialisation of mapAccept that only takes MediaType as its input, to avoid ambiguous-type errors when using string literal overloading.

getHeader >>= maybe render406Error renderResource . mapAcceptMedia
    [ ("text/html",        asHtml)
    , ("application/json", asJson)
    ]

A specialisation of mapAccept that only takes Charset as its input, to avoid ambiguous-type errors when using string literal overloading.

getHeader >>= maybe render406Error renderResource . mapAcceptCharset
    [ ("utf-8",    inUtf8)
    , ("us-ascii", inAscii)
    ]

A specialisation of mapAccept that only takes Encoding as its input, to avoid ambiguous-type errors when using string literal overloading.

getHeader >>= maybe render406Error renderResource . mapAcceptEncoding
    [ ("compress", compress)
    , ("identity", id)
    ]

A specialisation of mapAccept that only takes Language as its input, to avoid ambiguous-type errors when using string literal overloading.

getHeader >>= maybe render406Error renderResource . mapAcceptLanguage
    [ ("en-gb", inBritishEnglish)
    , ("fr",    inFrench)
    ]

A specialisation of mapAccept that only takes ByteString as its input, to avoid ambiguous-type errors when using string literal overloading.

getHeader >>= maybe render406Error encodeResourceWith . mapAcceptBytes
    [ ("abc", abc)
    , ("xyz", xyz)
    ]

Matches a list of server-side parsing options against a the client-side content value. A result of Nothing means that nothing matched (which should indicate a 415 error).

matchContent ["application/json", "text/plain"] <$> getContentType

For more information on the matching process see RFC 2616, section 14.17.

The equivalent of matchContent above, except the resulting choice is mapped to another value.

getContentType >>= maybe send415Error readRequestBodyWith . mapContent
    [ ("application" // "json", parseJson)
    , ("text" // "plain",       parseText)
    ]

A specialisation of mapContent that only takes MediaType as its input, to avoid ambiguous-type errors when using string literal overloading.

getContentType >>=
    maybe send415Error readRequestBodyWith . mapContentMedia
        [ ("application/json", parseJson)
        , ("text/plain",       parseText)
        ]

A specialisation of mapContent that only takes Charset as its input, to avoid ambiguous-type errors when using string literal overloading.

getContentCharset >>=
    maybe send415Error readRequestBodyWith . mapContentCharset
        [ ("utf-8",    parseUtf8)
        , ("us-ascii", parseAscii)
        ]

A specialisation of mapContent that only takes Encoding as its input, to avoid ambiguous-type errors when using string literal overloading.

getContentEncoding >>=
    maybe send415Error readRequestBodyWith . mapContentEncoding
        [ ("compress", decompress)
        , ("identity", id)
        ]

A specialisation of mapContent that only takes Language as its input, to avoid ambiguous-type errors when using string literal overloading.

getContentLanguage >>=
    maybe send415Error readRequestBodyWith . mapContentLanguage
        [ ("en-gb", parseBritishEnglish)
        , ("fr",    parseFrench)
        ]

Attaches a quality value to data.

Manually construct a quality value.

An opaque ordered representation of quality values without attached data.

Remove the attached data from a quality value, retaining only the priority of the quality parameter.

Whether the quality value is greater than zero; otherwise the value should never be accepted, even when no other options are available.

Attaches the quality value '1'.

Attaches the quality value '0'.

Parses a full Accept header into a list of quality-valued media types.

Matches a list of server-side resource options against a pre-parsed quality-marked list of client-side preferences. A result of Nothing means that nothing matched (which should indicate a 406 error). If two or more results arise with the same quality level and specificity, then the first one in the server list is chosen.

The use of the Accept type class allows the application of either MediaType for the standard Accept header or ByteString for any other Accept header which can be marked with a quality value.

matchQuality ["text/html", "application/json"] <$> parseQuality header

For more information on the matching process see RFC 2616, section 14.1-4.

The equivalent of matchQuality above, except the resulting choice is mapped to another value. Convenient for specifying how to translate the resource into each of its available formats.

parseQuality header >>= maybe render406Error renderResource . mapQuality
    [ ("text" // "html",        asHtml)
    , ("application" // "json", asJson)
    ]

Defines methods for a type whose values can be matched against each other in terms of an HTTP Accept-* header.

This allows functions to work on both the standard Accept header and others such as Accept-Language that still may use quality values.

A class for header values, so they may be rendered to their ByteString representation. Lists of header values and quality-marked header values will render appropriately.