Required first component to referring to a specification for the remainder of the URI's components, e.g. "http" or "https"

While some libraries have chosen to limit this to a Word16, the spec only specifies that the string be comprised of digits.

Note: URI fragment does not include the #

URI Parser Types

Options for the parser. You will probably want to use either "strictURIParserOptions" or "laxURIParserOptions"

Strict URI Parser config. Follows RFC3986 as-specified. Use this if you can be certain that your URIs are properly encoded or if you want parsing to fail if they deviate from the spec at all.

Lax URI Parser config. Use this if you you want to handle common deviations from the spec gracefully.

• Allows non-encoded [ and ] in query string

All normalization options disabled

Only normalizations deemed appropriate for all protocols by RFC3986 enabled, namely:

• Downcase Scheme
• Downcase Host
• Remove Dot Segments

The same as rfc3986Normalization but with additional enabled features if you're working with HTTP URIs:

• Drop Default Port (with httpDefaultPorts)
• Drop Extra Slashes

All options enabled

The set of known default ports to schemes. Currently only contains http/80 and https/443. Feel free to extend it if needed with unoDefaultPorts.

toAbsolute scheme ref converts ref to an absolute URI. If ref is already absolute, then it is unchanged.

Parse a strict ByteString into a URI or an error.

Example:

>>> parseURI strictURIParserOptions "http://www.example.org/foo?bar=baz#quux"
Right (URI {uriScheme = Scheme {schemeBS = "http"}, uriAuthority = Just (Authority {authorityUserInfo = Nothing, authorityHost = Host {hostBS = "www.example.org"}, authorityPort = Nothing}), uriPath = "/foo", uriQuery = Query {queryPairs = [("bar","baz")]}, uriFragment = Just "quux"})

>>> parseURI strictURIParserOptions "$$$$://badurl.example.org"
Left (MalformedScheme NonAlphaLeading)

There are some urls that you'll encounter which defy the spec, such as those with square brackets in the query string. If you must be able to parse those, you can use "laxURIParserOptions" or specify your own

>>> parseURI strictURIParserOptions "http://www.example.org/foo?bar[]=baz"
Left MalformedQuery

>>> parseURI laxURIParserOptions "http://www.example.org/foo?bar[]=baz"
Right (URI {uriScheme = Scheme {schemeBS = "http"}, uriAuthority = Just (Authority {authorityUserInfo = Nothing, authorityHost = Host {hostBS = "www.example.org"}, authorityPort = Nothing}), uriPath = "/foo", uriQuery = Query {queryPairs = [("bar[]","baz")]}, uriFragment = Nothing})

>>> let myLaxOptions = URIParserOptions { upoValidQueryChar = liftA2 (||) (upoValidQueryChar strictURIParserOptions) (inClass "[]")}
>>> parseURI myLaxOptions "http://www.example.org/foo?bar[]=baz"
Right (URI {uriScheme = Scheme {schemeBS = "http"}, uriAuthority = Just (Authority {authorityUserInfo = Nothing, authorityHost = Host {hostBS = "www.example.org"}, authorityPort = Nothing}), uriPath = "/foo", uriQuery = Query {queryPairs = [("bar[]","baz")]}, uriFragment = Nothing})

Like parseURI, but do not parse scheme.

Underlying attoparsec parser. Useful for composing with your own parsers.

Underlying attoparsec parser. Useful for composing with your own parsers.

URI Serializer

Serialize a URI reference into a Builder.

Example of serializing + converting to a lazy Data.ByteString.Lazy.ByteString:

>>> BB.toLazyByteString $ serializeURIRef $ URI {uriScheme = Scheme {schemeBS = "http"}, uriAuthority = Just (Authority {authorityUserInfo = Nothing, authorityHost = Host {hostBS = "www.example.org"}, authorityPort = Nothing}), uriPath = "/foo", uriQuery = Query {queryPairs = [("bar","baz")]}, uriFragment = Just "quux"}
"http://www.example.org/foo?bar=baz#quux"

Like serializeURIRef, with conversion into a strict ByteString.

Serialize the query part of a url serializeQuery opts mempty = "" serializeQuery opts (Query [("a","b"),("c","d")]) = "?a=b&c=d"

Similar to serializeURIRef but performs configurable degrees of URI normalization. If your goal is the fastest serialization speed possible, serializeURIRef will be fine. If you intend on comparing URIs (say for caching purposes), you'll want to use this.

This function was extracted from the http-types package. The license can be found in licenseshttp-typesLICENSE

ByteString Utilities

Decoding specifically for the query string, which decodes + as space. Shorthand for urlDecode True

Encode a ByteString for use in the query section of a URL

Encode a ByteString for use in the path section of a URL

Percent-encoding for URLs. Specify a list of additional unreserved characters to permit.

Serialize a URI into a Builder.

Like serializeURI, with conversion into a strict ByteString.

Like serializeURI, but do not render scheme.

Like serializeRelativeRef, with conversion into a strict ByteString.