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


-- | High-level, byte-based file and directory path manipulations
--   
--   High-level, byte-based file and directory path manipulations
@package system-filepath
@version 0.1.1


-- | High-level, byte-based file and directory path manipulations. You
--   probably want to import <a>System.FilePath.CurrentOS</a> instead,
--   since it handles detecting which rules to use in the current
--   compilation.
module System.FilePath
data FilePath

-- | A file path with no root, components, or filename
empty :: FilePath

-- | <pre>
--   null p == (p == <a>empty</a>)
--   </pre>
null :: FilePath -> Bool

-- | Retrieves the <a>FilePath</a>'s root.
root :: FilePath -> FilePath

-- | Retrieves the <a>FilePath</a>'s directory. If the path is already a
--   directory, it is returned unchanged.
directory :: FilePath -> FilePath

-- | Retrieves the <a>FilePath</a>'s parent directory.
parent :: FilePath -> FilePath

-- | Retrieve the filename component of a <a>FilePath</a>. <tt>filename
--   "foo/bar.txt" == "bar.txt"</tt>.
filename :: FilePath -> FilePath

-- | Retrieve the basename component of a <a>FilePath</a>. <tt>filename
--   "foo/bar.txt" == "bar"</tt>.
basename :: FilePath -> FilePath

-- | Return whether the path is absolute.
absolute :: FilePath -> Bool

-- | Return whether the path is relative.
relative :: FilePath -> Bool

-- | Appends two <a>FilePath</a>s. If the second path is absolute, it is
--   returned unchanged.
append :: FilePath -> FilePath -> FilePath

-- | An alias for <a>append</a>.
(</>) :: FilePath -> FilePath -> FilePath

-- | A fold over <a>append</a>.
concat :: [FilePath] -> FilePath

-- | Find the greatest common prefix between two <a>FilePath</a>s.
commonPrefix :: [FilePath] -> FilePath

-- | Get a <a>FilePath</a>'s last extension, or <a>Nothing</a> if it has no
--   extensions.
extension :: FilePath -> Maybe ByteString

-- | Get a <a>FilePath</a>'s full extension list.
extensions :: FilePath -> [ByteString]

-- | Get whether a <a>FilePath</a>'s last extension is the predicate.
hasExtension :: FilePath -> ByteString -> Bool

-- | Append an extension to the end of a <a>FilePath</a>.
addExtension :: FilePath -> ByteString -> FilePath

-- | An alias for <a>addExtension</a>.
(<.>) :: FilePath -> ByteString -> FilePath

-- | Remove a <a>FilePath</a>'s last extension.
dropExtension :: FilePath -> FilePath

-- | Replace a <a>FilePath</a>'s last extension.
replaceExtension :: FilePath -> ByteString -> FilePath

-- | Append many extensions to the end of a <a>FilePath</a>.
addExtensions :: FilePath -> [ByteString] -> FilePath

-- | Remove all extensions from a <a>FilePath</a>.
dropExtensions :: FilePath -> FilePath

-- | Remove all extensions from a <a>FilePath</a>, and replace them with a
--   new list.
replaceExtensions :: FilePath -> [ByteString] -> FilePath

-- | <pre>
--   splitExtension p = (<a>dropExtension</a> p, <a>extension</a> p)
--   </pre>
splitExtension :: FilePath -> (FilePath, Maybe ByteString)

-- | <pre>
--   splitExtensions p = (<a>dropExtensions</a> p, <a>extensions</a> p)
--   </pre>
splitExtensions :: FilePath -> (FilePath, [ByteString])
instance Monoid FilePath


module System.FilePath.Rules
data Rules
posix :: Rules
windows :: Rules

-- | Check if a <a>FilePath</a> is valid; that is, it must not contain any
--   illegal characters, and must have a root appropriate to the current
--   <a>Rules</a>.
valid :: Rules -> FilePath -> Bool

-- | Remove redundant characters. On case-insensitive platforms, also
--   lowercases any ASCII uppercase characters.
normalise :: Rules -> FilePath -> FilePath

-- | Check if two different <a>FilePath</a>s refer to the same file. This
--   does not perform any link resolution, so some equivalent files might
--   be missed.
equivalent :: Rules -> FilePath -> FilePath -> Bool

-- | Convert a <a>FilePath</a> into a strict <a>ByteString</a>, suitable
--   for passing to OS libraries.
toBytes :: Rules -> FilePath -> ByteString

-- | Convert a <a>FilePath</a> into a lazy <a>ByteString</a>.
toLazyBytes :: Rules -> FilePath -> ByteString

-- | Convert a <a>FilePath</a> into a lazy <a>String</a>. This is useful
--   for interoperating with legacy libraries. No decoding is performed;
--   the string's character ordinals are equal to the path's original
--   bytes. If you need to display a <a>FilePath</a> to the user, use
--   <a>toLazyBytes</a> and an appropriate decoding function.
toString :: Rules -> FilePath -> String

-- | Parse a strict <a>ByteString</a>, such as those received from OS
--   libraries, into a <a>FilePath</a>.
fromBytes :: Rules -> ByteString -> FilePath

-- | Parse a lazy <a>ByteString</a> into a <a>FilePath</a>.
fromLazyBytes :: Rules -> ByteString -> FilePath

-- | Parse a lazy <a>String</a> into a <a>FilePath</a>. This is useful for
--   interoperating with legacy libraries. No encoding is performed;
--   characters are truncated to 8 bits. If you need to accept a
--   <a>FilePath</a> from the user, use <a>fromLazyBytes</a> and an
--   appropriate encoding function.
fromString :: Rules -> String -> FilePath

-- | Split a search path, such as <tt>$PATH</tt> or <tt>$PYTHONPATH</tt>,
--   into a list of <a>FilePath</a>s.
splitSearchPath :: Rules -> ByteString -> [FilePath]


-- | Re-exports contents of <a>System.FilePath.Rules</a>, defaulting to the
--   current OS's rules when needed.
--   
--   Also enables <a>Show</a> and <a>IsString</a> instances for
--   <a>FilePath</a>.
module System.FilePath.CurrentOS
currentOS :: Rules

-- | See <a>valid</a>
valid :: FilePath -> Bool

-- | See <a>normalise</a>
normalise :: FilePath -> FilePath

-- | See <a>equivalent</a>
equivalent :: FilePath -> FilePath -> Bool

-- | See <a>toBytes</a>
toBytes :: FilePath -> ByteString

-- | See <a>toLazyBytes</a>
toLazyBytes :: FilePath -> ByteString

-- | See <a>toString</a>
toString :: FilePath -> String

-- | See <a>fromBytes</a>
fromBytes :: ByteString -> FilePath

-- | See <a>fromLazyBytes</a>
fromLazyBytes :: ByteString -> FilePath

-- | See <a>fromString</a>
fromString :: String -> FilePath

-- | See <a>splitSearchPath</a>
splitSearchPath :: ByteString -> [FilePath]
instance Show FilePath
instance IsString FilePath