Haskell Core Libraries (Cabal package)ContentsIndex
Distribution.Compat.FilePath
Contents
File path
Search path
Separators
Filename extensions
Synopsis
FilePath
splitFileName :: FilePath -> (String, String)
splitFileExt :: FilePath -> (String, String)
splitFilePath :: FilePath -> (String, String, String)
joinFileName :: String -> String -> FilePath
joinFileExt :: String -> String -> FilePath
joinPaths :: FilePath -> FilePath -> FilePath
changeFileExt :: FilePath -> String -> FilePath
isRootedPath :: FilePath -> Bool
isAbsolutePath :: FilePath -> Bool
dropAbsolutePrefix :: FilePath -> FilePath
breakFilePath :: FilePath -> [String]
dropPrefix :: FilePath -> FilePath -> FilePath
pathParents :: FilePath -> [FilePath]
commonParent :: [FilePath] -> Maybe FilePath
parseSearchPath :: String -> [FilePath]
mkSearchPath :: [FilePath] -> String
isPathSeparator :: Char -> Bool
pathSeparator :: Char
searchPathSeparator :: Char
platformPath :: FilePath -> FilePath
exeExtension :: String
objExtension :: String
dllExtension :: String
File path
FilePath
splitFileName :: FilePath -> (String, String)

Split the path into directory and file name

Examples:

[Posix]

 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.", "")
 splitFileExt "foo.tar.gz" == ("foo.tar","gz")
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
:: FilePathThe path information to modify.
-> StringThe new extension (without a leading period). Specify an empty string to remove an existing extension from path.
-> FilePathA 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.
platformPath :: FilePath -> FilePath
Convert Unix-style path separators to the path separators for this platform.
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