Represents a general universal resource identifier using its component parts.

For example, for the URI

  foo://anonymous@www.haskell.org:42/ghc?query#frag

the components are:

Type for authority value within a URI

Blank URI

Blank URIAuth.

Given a URI in "nonstandard" form (lacking required separator characters), return one that is standard.

Given a URIAuth in "nonstandard" form (lacking required separator characters), return one that is standard.

Turn a string containing a URI into a URI. Returns Nothing if the string is not a valid URI; (an absolute URI with optional fragment identifier).

NOTE: this is different from the previous network.URI, whose parseURI function works like parseURIReference in this module.

Parse a URI reference to a URI value. Returns Nothing if the string is not a valid URI reference. (an absolute or relative URI with optional fragment identifier).

Parse a relative URI to a URI value. Returns Nothing if the string is not a valid relative URI. (a relative URI with optional fragment identifier).

Parse an absolute URI to a URI value. Returns Nothing if the string is not a valid absolute URI. (an absolute URI without a fragment identifier).

Test if string contains a valid URI (an absolute URI with optional fragment identifier).

Test if string contains a valid URI reference (an absolute or relative URI with optional fragment identifier).

Test if string contains a valid relative URI (a relative URI with optional fragment identifier).

Test if string contains a valid absolute URI (an absolute URI without a fragment identifier).

Test if string contains a valid IPv6 address

Test if string contains a valid IPv4 address

Returns a new URI which represents the value of the first URI interpreted as relative to the second URI.

Algorithm from RFC3986 [3], section 5.2

Returns a new URI which represents the value of the first URI interpreted as relative to the second URI. For example:

"foo" `relativeTo` "http://bar.org/" = "http://bar.org/foo"
"http:foo" `nonStrictRelativeTo` "http://bar.org/" = "http://bar.org/foo"

Algorithm from RFC3986 [3], section 5.2.2

Returns a new URI which represents the relative location of the first URI with respect to the second URI. Thus, the values supplied are expected to be absolute URIs, and the result returned may be a relative URI.

Example:

"http://example.com/Root/sub1/name2#frag"
  `relativeFrom` "http://example.com/Root/sub2/name2#frag"
  == "../sub1/name2#frag"

There is no single correct implementation of this function, but any acceptable implementation must satisfy the following:

(uabs `relativeFrom` ubase) `relativeTo` ubase == uabs

For any valid absolute URI. (cf. http://lists.w3.org/Archives/Public/uri/2003Jan/0008.html http://lists.w3.org/Archives/Public/uri/2003Jan/0005.html)

Turn a URI into a string.

Uses a supplied function to map the userinfo part of the URI.

The Show instance for URI uses a mapping that hides any password that may be present in the URI. Use this function with argument id to preserve the password in the formatted output.

Returns True if the character is a "reserved" character in a URI. To include a literal instance of one of these characters in a component of a URI, it must be escaped.

Returns True if the character is an "unreserved" character in a URI. These characters do not need to be escaped in a URI. The only characters allowed in a URI are either "reserved", "unreserved", or an escape sequence (% followed by two hex digits).

Returns True if the character is allowed in a URI.

Returns True if the character is allowed unescaped in a URI.

>>> escapeURIString isUnescapedInURI "http://haskell.org:80?some_param=true&other_param=їґ"
"http://haskell.org:80?some_param=true&other_param=%D1%97%D2%91"

Returns True if the character is allowed unescaped in a URI component.

>>> escapeURIString isUnescapedInURIComponent "http://haskell.org:80?some_param=true&other_param=їґ"
"http%3A%2F%2Fhaskell.org%3A80%3Fsome_param%3Dtrue%26other_param%3D%D1%97%D2%91"

Escape character if supplied predicate is not satisfied, otherwise return character as singleton string.

Can be used to make a string valid for use in a URI.

Turns all instances of escaped characters in the string back into literal characters.

Returns the segments of the path component. E.g., pathSegments $ parseURI "http://example.org/foo/bar/baz" == ["foo", "bar", "baz"]

Case normalization; cf. RFC3986 section 6.2.2.1 NOTE: authority case normalization is not performed

Encoding normalization; cf. RFC3986 section 6.2.2.2

Path segment normalization; cf. RFC3986 section 6.2.2.3