-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/

-- | URI manipulation
--   
--   This package provides facilities for parsing and unparsing URIs, and
--   creating and resolving relative URI references, closely following the
--   URI spec, IETF RFC 3986.
--   
--   
Backward-compatibility
--   
--   In network-2.6 the Network.URI module was split off
--   from the network package into this package. If you're using
--   the Network.URI module you can be backward compatible and
--   automatically get it from the right package by using the
--   network-uri-flag pseudo-package in your .cabal file's
--   build-depends (along with dependencies for both network-uri
--   and network):
--   
--   
--   build-depends:
--      network-uri-flag == 0.1.*
--   
--   
--   Or you can do the same manually by adding this boilerplate to your
--   .cabal file:
--   
--   
--   flag network-uri
--     description: Get Network.URI from the network-uri package
--     default: True
--   
--   library
--     -- ...
--     if flag(network-uri)
--       build-depends: network-uri >= 2.6, network >= 2.6
--     else
--       build-depends: network-uri < 2.6, network < 2.6
--   
--   
--   That is, get the module from either network < 2.6 or from
--   network-uri >= 2.6.
@package network-uri
@version 2.6.4.2

-- | This module defines functions for handling URIs. It presents
--   substantially the same interface as the older GHC Network.URI module,
--   but is implemented using Parsec rather than a Regex library that is
--   not available with Hugs. The internal representation of URI has been
--   changed so that URI strings are more completely preserved when
--   round-tripping to a URI value and back.
--   
--   In addition, four methods are provided for parsing different kinds of
--   URI string (as noted in RFC3986): parseURI,
--   parseURIReference, parseRelativeReference and
--   parseAbsoluteURI.
--   
--   Further, four methods are provided for classifying different kinds of
--   URI string (as noted in RFC3986): isURI, isURIReference,
--   isRelativeReference and isAbsoluteURI.
--   
--   The long-standing official reference for URI handling was RFC2396 [1],
--   as updated by RFC 2732 [2], but this was replaced by a new
--   specification, RFC3986 [3] in January 2005. This latter specification
--   has been used as the primary reference for constructing the URI parser
--   implemented here, and it is intended that there is a direct
--   relationship between the syntax definition in that document and this
--   parser implementation.
--   
--   RFC 1808 [4] contains a number of test cases for relative URI
--   handling. Dan Connolly's Python module uripath.py [5] also
--   contains useful details and test cases.
--   
--   Some of the code has been copied from the previous GHC implementation,
--   but the parser is replaced with one that performs more complete syntax
--   checking of the URI itself, according to RFC3986 [3].
--   
--   References
--   
--   
--   
- http://www.ietf.org/rfc/rfc2396.txt
--   
- http://www.ietf.org/rfc/rfc2732.txt
--   
- http://www.ietf.org/rfc/rfc3986.txt
--   
- http://www.ietf.org/rfc/rfc1808.txt
--   
- http://www.w3.org/2000/10/swap/uripath.py
--   
module Network.URI

-- | 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:
data URI
URI :: String -> Maybe URIAuth -> String -> String -> String -> URI

-- | 
--   foo:
--   
[uriScheme] :: URI -> String

-- | 
--   //anonymous@www.haskell.org:42
--   
[uriAuthority] :: URI -> Maybe URIAuth

-- | 
--   /ghc
--   
[uriPath] :: URI -> String

-- | 
--   ?query
--   
[uriQuery] :: URI -> String

-- | 
--   #frag
--   
[uriFragment] :: URI -> String

-- | Type for authority value within a URI
data URIAuth
URIAuth :: String -> String -> String -> URIAuth

-- | 
--   anonymous@
--   
[uriUserInfo] :: URIAuth -> String

-- | 
--   www.haskell.org
--   
[uriRegName] :: URIAuth -> String

-- | 
--   :42
--   
[uriPort] :: URIAuth -> String

-- | Blank URI
nullURI :: URI

-- | Blank URIAuth.
nullURIAuth :: URIAuth

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

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

-- | 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.
parseURI :: String -> Maybe URI

-- | 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).
parseURIReference :: String -> Maybe URI

-- | 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).
parseRelativeReference :: String -> Maybe URI

-- | 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).
parseAbsoluteURI :: String -> Maybe URI

-- | Test if string contains a valid URI (an absolute URI with optional
--   fragment identifier).
isURI :: String -> Bool

-- | Test if string contains a valid URI reference (an absolute or relative
--   URI with optional fragment identifier).
isURIReference :: String -> Bool

-- | Test if string contains a valid relative URI (a relative URI with
--   optional fragment identifier).
isRelativeReference :: String -> Bool

-- | Test if string contains a valid absolute URI (an absolute URI without
--   a fragment identifier).
isAbsoluteURI :: String -> Bool

-- | Test if string contains a valid IPv6 address
isIPv6address :: String -> Bool

-- | Test if string contains a valid IPv4 address
isIPv4address :: String -> Bool
uriIsAbsolute :: URI -> Bool
uriIsRelative :: URI -> Bool

-- | 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
relativeTo :: URI -> URI -> URI

-- | 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
nonStrictRelativeTo :: URI -> URI -> URI

-- | 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)
relativeFrom :: URI -> URI -> URI

-- | 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.
uriToString :: (String -> String) -> URI -> ShowS
uriAuthToString :: (String -> String) -> Maybe URIAuth -> ShowS

-- | 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.
isReserved :: Char -> Bool

-- | 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).
isUnreserved :: Char -> Bool

-- | Returns True if the character is allowed in a URI.
isAllowedInURI :: Char -> Bool

-- | 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"
--   
isUnescapedInURI :: Char -> Bool

-- | 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"
--   
isUnescapedInURIComponent :: Char -> Bool

-- | Escape character if supplied predicate is not satisfied, otherwise
--   return character as singleton string.
escapeURIChar :: (Char -> Bool) -> Char -> String

-- | Can be used to make a string valid for use in a URI.
escapeURIString :: (Char -> Bool) -> String -> String

-- | Turns all instances of escaped characters in the string back into
--   literal characters.
unEscapeString :: String -> String

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

-- | Case normalization; cf. RFC3986 section 6.2.2.1 NOTE: authority case
--   normalization is not performed
normalizeCase :: String -> String

-- | Encoding normalization; cf. RFC3986 section 6.2.2.2
normalizeEscape :: String -> String

-- | Path segment normalization; cf. RFC3986 section 6.2.2.3
normalizePathSegments :: String -> String

-- | Deprecated: use parseAbsoluteURI
parseabsoluteURI :: String -> Maybe URI

-- | Deprecated: use escapeURIString, and note the flipped arguments
escapeString :: String -> (Char -> Bool) -> String

-- | Deprecated: use isReserved
reserved :: Char -> Bool

-- | Deprecated: use isUnreserved
unreserved :: Char -> Bool

-- | Deprecated: use uriScheme
scheme :: URI -> String

-- | Deprecated: use uriAuthority, and note changed functionality
authority :: URI -> String

-- | Deprecated: use uriPath
path :: URI -> String

-- | Deprecated: use uriQuery, and note changed functionality
query :: URI -> String

-- | Deprecated: use uriFragment, and note changed functionality
fragment :: URI -> String
instance GHC.Internal.Data.Data.Data Network.URI.URI
instance GHC.Internal.Data.Data.Data Network.URI.URIAuth
instance GHC.Classes.Eq Network.URI.URI
instance GHC.Classes.Eq Network.URI.URIAuth
instance GHC.Internal.Generics.Generic Network.URI.URI
instance GHC.Internal.Generics.Generic Network.URI.URIAuth
instance Language.Haskell.TH.Syntax.Lift Network.URI.URI
instance Language.Haskell.TH.Syntax.Lift Network.URI.URIAuth
instance Control.DeepSeq.NFData Network.URI.URI
instance Control.DeepSeq.NFData Network.URI.URIAuth
instance GHC.Classes.Ord Network.URI.URI
instance GHC.Classes.Ord Network.URI.URIAuth
instance GHC.Internal.Show.Show Network.URI.URI
instance GHC.Internal.Show.Show Network.URI.URIAuth

-- | Network uri lenses
module Network.URI.Lens
uriRegNameLens :: Lens' URIAuth String
uriUserInfoLens :: Lens' URIAuth String
uriPortLens :: Lens' URIAuth String
uriAuthorityLens :: Lens' URI (Maybe URIAuth)
uriSchemeLens :: Lens' URI String
uriPathLens :: Lens' URI String
uriQueryLens :: Lens' URI String
uriFragmentLens :: Lens' URI String

module Network.URI.Static

-- | uri is a quasi quoter for staticURI.
--   
--   
--   >>> [uri|http://www.google.com/|]
--   http://www.google.com/
--   
--   
--   
--   >>> [uri|http://www.google.com/##|]
--   
--   <interactive>...
--   ... Invalid URI: http://www.google.com/##
--   ...
--   
uri :: QuasiQuoter

-- | staticURI parses a specified string at compile time and return
--   an expression representing the URI when it's a valid URI. Otherwise,
--   it emits an error.
--   
--   
--   >>> $$(staticURI "http://www.google.com/")
--   http://www.google.com/
--   
--   
--   
--   >>> $$(staticURI "http://www.google.com/##")
--   
--   <interactive>...
--   ... Invalid URI: http://www.google.com/##
--   ...
--   
staticURI :: String -> SpliceQ URI

-- | staticURI' parses a specified string at compile time.
--   
--   The typed template haskell staticURI is available only with
--   GHC-7.8+.
staticURI' :: String -> ExpQ

-- | relativeReference is a quasi quoter for
--   staticRelativeReference.
--   
--   
--   >>> [relativeReference|/foo?bar=baz#quux|]
--   /foo?bar=baz#quux
--   
--   
--   
--   >>> [relativeReference|http://www.google.com/|]
--   
--   <interactive>...
--   ... Invalid relative reference: http://www.google.com/
--   ...
--   
relativeReference :: QuasiQuoter

-- | staticRelativeReference parses a specified string at compile
--   time and return an expression representing the URI when it's a valid
--   relative reference. Otherwise, it emits an error.
--   
--   
--   >>> $$(staticRelativeReference "/foo?bar=baz#quux")
--   /foo?bar=baz#quux
--   
--   
--   
--   >>> $$(staticRelativeReference "http://www.google.com/")
--   
--   <interactive>...
--   ... Invalid relative reference: http://www.google.com/
--   ...
--   
staticRelativeReference :: String -> SpliceQ URI

-- | staticRelativeReference' parses a specified string at compile
--   time and return an expression representing the URI when it's a valid
--   relative reference. Otherwise, it emits an error.
--   
--   The typed template haskell staticRelativeReference is available
--   only with GHC-7.8+.
staticRelativeReference' :: String -> ExpQ
