Distribution.Compat.FilePath

 splitFileName "/"            == ("/",    ".")
 splitFileName "/foo/bar.ext" == ("/foo", "bar.ext")
 splitFileName "bar.ext"      == (".",    "bar.ext")
 splitFileName "/foo/."       == ("/foo", ".")
 splitFileName "/foo/.."      == ("/foo", "..")

[Windows]

 splitFileName "\\"               == ("\\",      "")
 splitFileName "c:\\foo\\bar.ext" == ("c:\\foo", "bar.ext")
 splitFileName "bar.ext"          == (".",       "bar.ext")
 splitFileName "c:\\foo\\."       == ("c:\\foo", ".")
 splitFileName "c:\\foo\\.."      == ("c:\\foo", "..")

The first case in the Windows examples returns an empty file name. This is a special case because the "\\" path doesn't refer to an object (file or directory) which resides within a directory.

splitFileExt :: FilePath -> (String, String)

Split the path into file name and extension. If the file doesn't have extension, the function will return empty string. The extension doesn't include a leading period.

Examples:

 splitFileExt "foo.ext" == ("foo", "ext")
 splitFileExt "foo"     == ("foo", "")
 splitFileExt "."       == (".",   "")
 splitFileExt ".."      == ("..",  "")
 splitFileExt "foo.bar."== ("foo.bar.", "")

splitFilePath :: FilePath -> (String, String, String)

Split the path into directory, file name and extension. The function is an optimized version of the following equation:

 splitFilePath path = (dir,name,ext)
   where
     (dir,basename) = splitFileName path
     (name,ext)     = splitFileExt  basename

joinFileName :: String -> String -> FilePath

The joinFileName function is the opposite of splitFileName. It joins directory and file names to form a complete file path.

The general rule is:

 dir `joinFileName` basename == path
   where
     (dir,basename) = splitFileName path

There might be an exceptions to the rule but in any case the reconstructed path will refer to the same object (file or directory). An example exception is that on Windows some slashes might be converted to backslashes.

joinFileExt :: String -> String -> FilePath

The joinFileExt function is the opposite of splitFileExt. It joins a file name and an extension to form a complete file path.

The general rule is:

 filename `joinFileExt` ext == path
   where
     (filename,ext) = splitFileExt path

joinPaths :: FilePath -> FilePath -> FilePath

Given a directory path "dir" and a file/directory path "rel", returns a merged path "full" with the property that (cd dir; do_something_with rel) is equivalent to (do_something_with full). If the "rel" path is an absolute path then the returned path is equal to "rel"

changeFileExt

:: FilePath	The path information to modify.
-> String	The new extension (without a leading period). Specify an empty string to remove an existing extension from path.
-> FilePath	A string containing the modified path information.
Changes the extension of a file path.

isRootedPath :: FilePath -> Bool

On Unix and Macintosh the isRootedPath function is a synonym to isAbsolutePath. The difference is important only on Windows. The rooted path must start from the root directory but may not include the drive letter while the absolute path always includes the drive letter and the full file path.

isAbsolutePath :: FilePath -> Bool

Returns True if this path's meaning is independent of any OS "working directory", or False if it isn't.

dropAbsolutePrefix :: FilePath -> FilePath

If the function is applied to an absolute path then it returns a local path droping the absolute prefix in the path. Under Windows the prefix is "\", "c:" or "c:\". Under Unix the prefix is always "/".

breakFilePath :: FilePath -> [String]

Split the path into a list of strings constituting the filepath

  breakFilePath "/usr/bin/ls" == ["/","usr","bin","ls"]

dropPrefix :: FilePath -> FilePath -> FilePath

Drops a specified prefix from a filepath.

  stripPrefix "." "Src/Test.hs" == "Src/Test.hs"
  stripPrefix "Src" "Src/Test.hs" == "Test.hs"

pathParents :: FilePath -> [FilePath]

Gets this path and all its parents. The function is useful in case if you want to create some file but you aren't sure whether all directories in the path exist or if you want to search upward for some file.

Some examples:

[Posix]

  pathParents "/"          == ["/"]
  pathParents "/dir1"      == ["/", "/dir1"]
  pathParents "/dir1/dir2" == ["/", "/dir1", "/dir1/dir2"]
  pathParents "dir1"       == [".", "dir1"]
  pathParents "dir1/dir2"  == [".", "dir1", "dir1/dir2"]

[Windows]

  pathParents "c:"             == ["c:."]
  pathParents "c:\\"           == ["c:\\"]
  pathParents "c:\\dir1"       == ["c:\\", "c:\\dir1"]
  pathParents "c:\\dir1\\dir2" == ["c:\\", "c:\\dir1", "c:\\dir1\\dir2"]
  pathParents "c:dir1"         == ["c:.","c:dir1"]
  pathParents "dir1\\dir2"     == [".", "dir1", "dir1\\dir2"]

Note that if the file is relative then the current directory (".") will be explicitly listed.

commonParent :: [FilePath] -> Maybe FilePath

Given a list of file paths, returns the longest common parent.

Search path

parseSearchPath :: String -> [FilePath]

The function splits the given string to substrings using the searchPathSeparator.

mkSearchPath :: [FilePath] -> String

The function concatenates the given paths to form a single string where the paths are separated with searchPathSeparator.

Separators

isPathSeparator :: Char -> Bool

Checks whether the character is a valid path separator for the host platform. The valid character is a pathSeparator but since the Windows operating system also accepts a slash ("/") since DOS 2, the function checks for it on this platform, too.

pathSeparator :: Char

Provides a platform-specific character used to separate directory levels in a path string that reflects a hierarchical file system organization. The separator is a slash ("/") on Unix and Macintosh, and a backslash ("\") on the Windows operating system.

searchPathSeparator :: Char

A platform-specific character used to separate search path strings in environment variables. The separator is a colon (":") on Unix and Macintosh, and a semicolon (";") on the Windows operating system.

Filename extensions

exeExtension :: String

Extension for executable files (typically "" on Unix and "exe" on Windows or OS/2)

objExtension :: String

Extension for object files. For GHC and NHC the extension is "o". Hugs uses either "o" or "obj" depending on the used C compiler.

dllExtension :: String

Extension for dynamically linked (or shared) libraries (typically "so" on Unix and "dll" on Windows)

Produced by Haddock version 0.7