If the operating system has a notion of current directories, getCurrentDirectory returns an absolute path to the current directory of the calling process.

The operation may fail with:

• HardwareFault A physical I/O error has occurred. [EIO]
• isDoesNotExistError / NoSuchThing There is no path referring to the current directory. [EPERM, ENOENT, ESTALE...]
• isPermissionError / PermissionDenied The process has insufficient privileges to perform the operation. [EACCES]
• ResourceExhausted Insufficient resources are available to perform the operation.
• UnsupportedOperation The operating system has no notion of current directory.

Returns the current user's home directory.

The directory returned is expected to be writable by the current user, but note that it isn't generally considered good practice to store application-specific data here; use getAppUserDataDirectory instead.

On Unix, getHomeDirectory returns the value of the HOME environment variable. On Windows, the system is queried for a suitable path; a typical path might be C:Documents And Settingsuser.

The operation may fail with:

• UnsupportedOperation The operating system has no notion of home directory.
• isDoesNotExistError The home directory for the current user does not exist, or cannot be found.

Returns the current user's home directory from the HOME environment variable.

Returns the pathname of a directory in which application-specific data for the current user can be stored. The result of getAppUserDataDirectory for a given application is specific to the current user.

The argument should be the name of the application, which will be used to construct the pathname (so avoid using unusual characters that might result in an invalid pathname).

Note: the directory may not actually exist, and may need to be created first. It is expected that the parent directory exists and is writable.

On Unix, this function returns $HOME/.appName. On Windows, a typical path might be

C:/Documents And Settings/user/Application Data/appName

The operation may fail with:

• UnsupportedOperation The operating system has no notion of application-specific data directory.
• isDoesNotExistError The home directory for the current user does not exist, or cannot be found.

Returns the current user's document directory.

The directory returned is expected to be writable by the current user, but note that it isn't generally considered good practice to store application-specific data here; use getAppUserDataDirectory instead.

On Unix, getUserDocumentsDirectory returns the value of the HOME environment variable. On Windows, the system is queried for a suitable path; a typical path might be C:/Documents and Settings/user/My Documents.

The operation may fail with:

• UnsupportedOperation The operating system has no notion of document directory.
• isDoesNotExistError The document directory for the current user does not exist, or cannot be found.

Returns the current directory for temporary files.

On Unix, getTemporaryDirectory returns the value of the TMPDIR environment variable or "/tmp" if the variable isn't defined. On Windows, the function checks for the existence of environment variables in the following order and uses the first path found:

• TMP environment variable.
• TEMP environment variable.
• USERPROFILE environment variable.
• The Windows directory

The operation may fail with:

• UnsupportedOperation The operating system has no notion of temporary directory.

The function doesn't verify whether the path exists.

This function copy the permission of the first file to the second.

The getCreationTime operation returns the UTC time at which the file or directory was created. The time is only available on Windows.

The getChangeTime operation returns the UTC time at which the file or directory was changed. The time is only available on Unix and Mac. Note that Unix's rename() does not change ctime but MacOS's rename() does.

The getModificationTime operation returns the UTC time at which the file or directory was last modified.

The operation may fail with:

• isPermissionError if the user is not permitted to access the modification time; or
• isDoesNotExistError if the file or directory does not exist.

The getModificationTime operation returns the UTC time at which the file or directory was last accessed.

Getting the size of the file.

Since: 0.2.0.

Setting the size of the file.

Since: 0.2.4.

This function tells whether or not a file/directory is symbolic link.

This function returns the link counter of a file/directory.

This function returns whether or not a directory has sub-directories.

The character that separates directories.

pathSeparator ==  '/'
isPathSeparator pathSeparator

The list of all possible separators.

Windows: pathSeparators == ['\\', '/']
Posix:   pathSeparators == ['/']
pathSeparator `elem` pathSeparators

Rather than using (== pathSeparator), use this. Test if something is a path separator.

isPathSeparator a == (a `elem` pathSeparators)

File extension character

extSeparator == '.'

Is the character an extension character?

isExtSeparator a == (a == extSeparator)

Split on the extension. addExtension is the inverse.

uncurry (++) (splitExtension x) == x
uncurry addExtension (splitExtension x) == x
splitExtension "file.txt" == ("file",".txt")
splitExtension "file" == ("file","")
splitExtension "file/file.txt" == ("file/file",".txt")
splitExtension "file.txt/boris" == ("file.txt/boris","")
splitExtension "file.txt/boris.ext" == ("file.txt/boris",".ext")
splitExtension "file/path.txt.bob.fred" == ("file/path.txt.bob",".fred")
splitExtension "file/path.txt/" == ("file/path.txt/","")

Get the extension of a file, returns "" for no extension, .ext otherwise.

takeExtension x == snd (splitExtension x)
Valid x => takeExtension (addExtension x "ext") == ".ext"
Valid x => takeExtension (replaceExtension x "ext") == ".ext"

Set the extension of a file, overwriting one if already present.

replaceExtension "file.txt" ".bob" == "file.bob"
replaceExtension "file.txt" "bob" == "file.bob"
replaceExtension "file" ".bob" == "file.bob"
replaceExtension "file.txt" "" == "file"
replaceExtension "file.fred.bob" "txt" == "file.fred.txt"

Remove last extension, and the "." preceding it.

dropExtension x == fst (splitExtension x)

Add an extension, even if there is already one there. E.g. addExtension "foo.txt" "bat" -> "foo.txt.bat".

addExtension "file.txt" "bib" == "file.txt.bib"
addExtension "file." ".bib" == "file..bib"
addExtension "file" ".bib" == "file.bib"
addExtension "/" "x" == "/.x"
Valid x => takeFileName (addExtension (addTrailingPathSeparator x) "ext") == ".ext"
Windows: addExtension "\\\\share" ".txt" == "\\\\share\\.txt"

Does the given filename have an extension?

null (takeExtension x) == not (hasExtension x)

Alias to addExtension, for people who like that sort of thing.

Split on all extensions

splitExtensions "file.tar.gz" == ("file",".tar.gz")

Drop all extensions

not $ hasExtension (dropExtensions x)

Get all extensions

takeExtensions "file.tar.gz" == ".tar.gz"

Split a path into a drive and a path. On Unix, / is a Drive.

uncurry (++) (splitDrive x) == x
Windows: splitDrive "file" == ("","file")
Windows: splitDrive "c:/file" == ("c:/","file")
Windows: splitDrive "\\\\shared\\test" == ("\\\\shared\\","test")
Windows: splitDrive "\\\\shared" == ("\\\\shared","")
Windows: splitDrive "\\\\?\\UNC\\shared\\file" == ("\\\\?\\UNC\\shared\\","file")
Windows: splitDrive "\\\\?\\UNCshared\\file" == ("\\\\?\\","UNCshared\\file")
Windows: splitDrive "\\\\?\\d:\\file" == ("\\\\?\\d:\\","file")
Windows: splitDrive "/d" == ("","/d") -- xxx
Posix:   splitDrive "/test" == ("/","test") -- xxx
Posix:   splitDrive "//test" == ("//","test")
Posix:   splitDrive "test/file" == ("","test/file")
Posix:   splitDrive "file" == ("","file")

Join a drive and the rest of the path.

         uncurry joinDrive (splitDrive x) == x
Windows: joinDrive "C:" "foo" == "C:foo"
Windows: joinDrive "C:/" "bar" == "C:/bar"
Windows: joinDrive "\\\\share" "foo" == "\\\\share/foo" -- xxx
Windows: joinDrive "/:" "foo" == "/:/foo" -- xxx

Get the drive from a filepath.

takeDrive x == fst (splitDrive x)

Does a path have a drive.

not (hasDrive x) == null (takeDrive x)

Delete the drive, if it exists.

dropDrive x == snd (splitDrive x)

Is an element a drive

Split a filename into directory and file. combine is the inverse.

uncurry (++) (splitFileName x) == x
Valid x => uncurry combine (splitFileName x) == x
splitFileName "file/bob.txt" == ("file/", "bob.txt")
splitFileName "file/" == ("file/", "")
splitFileName "bob" == ("", "bob")
Posix:   splitFileName "/" == ("/","")
Windows: splitFileName "c:" == ("c:","")

Get the file name.

takeFileName "test/" == ""
takeFileName x `isSuffixOf` x
takeFileName x == snd (splitFileName x)
Valid x => takeFileName (replaceFileName x "fred") == "fred"
Valid x => takeFileName (x </> "fred") == "fred"
Valid x => isRelative (takeFileName x)

Set the filename.

Valid x => replaceFileName x (takeFileName x) == x

Drop the filename.

dropFileName x == fst (splitFileName x)

Get the base name, without an extension or path.

takeBaseName "file/test.txt" == "test"
takeBaseName "dave.ext" == "dave"
takeBaseName "" == ""
takeBaseName "test" == "test"
takeBaseName (addTrailingPathSeparator x) == ""
takeBaseName "file/file.tar.gz" == "file.tar"

Set the base name.

replaceBaseName "file/test.txt" "bob" == "file/bob.txt"
replaceBaseName "fred" "bill" == "bill"
replaceBaseName "/dave/fred/bob.gz.tar" "new" == "/dave/fred/new.tar"
replaceBaseName x (takeBaseName x) == x

Get the directory name, move up one level.

          takeDirectory x `isPrefixOf` x
          takeDirectory "foo" == ""
          takeDirectory "/foo/bar/baz" == "/foo/bar"
          takeDirectory "/foo/bar/baz/" == "/foo/bar/baz"
          takeDirectory "foo/bar/baz" == "foo/bar"
Windows:  takeDirectory "foo\\bar\\\\" == "foo\\bar" -- xxx
Windows:  takeDirectory "C:/" == "C:/"

Set the directory, keeping the filename the same.

replaceDirectory x (takeDirectory x) `equalFilePath` x

Combine two paths, if the second path isAbsolute, then it returns the second.

Valid x => combine (takeDirectory x) (takeFileName x) `equalFilePath` x
combine "/" "test" == "/test"
combine "home" "bob" == "home/bob"

A nice alias for combine.

Split a path by the directory separator.

concat (splitPath x) == x
splitPath "test//item/" == ["test//","item/"]
splitPath "test/item/file" == ["test/","item/","file"]
splitPath "" == []
Windows: splitPath "c:/test/path" == ["c:/","test/","path"]
Posix:   splitPath "/file/test" == ["/","file/","test"]

Join path elements back together.

Valid x => joinPath (splitPath x) == x
joinPath [] == ""
Posix: joinPath ["test","file","path"] == "test/file/path"

Just as splitPath, but don't add the trailing slashes to each element.

splitDirectories "test/file" == ["test","file"]
splitDirectories "/test/file" == ["/","test","file"]
Valid x => joinPath (splitDirectories x) `equalFilePath` x
splitDirectories "" == []

Is an item either a directory or the last character a path separator?

hasTrailingPathSeparator "test" == False
hasTrailingPathSeparator "test/" == True

Add a trailing file path separator if one is not already present.

hasTrailingPathSeparator (addTrailingPathSeparator x)
hasTrailingPathSeparator x ==> addTrailingPathSeparator x == x
addTrailingPathSeparator "test/rest" == "test/rest/"

Remove any trailing path separators

dropTrailingPathSeparator "file/test/" == "file/test"
not (hasTrailingPathSeparator (dropTrailingPathSeparator x)) || isDrive x
dropTrailingPathSeparator "/" == "/"

Normalise a file

• // outside of the drive can be made blank
• / -> pathSeparator
• ./ -> ""

Posix:   normalise "/file/\\test////" == "/file/\\test/"
Posix:   normalise "/file/./test" == "/file/test"
Posix:   normalise "/test/file/../bob/fred/" == "/test/file/../bob/fred/"
Posix:   normalise "../bob/fred/" == "../bob/fred/"
Posix:   normalise "./bob/fred/" == "bob/fred/"
Windows: normalise "c:\\file/bob\\" == "C:/file/bob/"
Windows: normalise "c:/" == "C:/"
Windows: normalise "\\\\server\\test" == "\\\\server\\test" -- xxx
Windows: normalise "." == "."
Posix:   normalise "./" == "./"

Equality of two FilePaths. If you call System.Directory.canonicalizePath first this has a much better chance of working. Note that this doesn't follow symlinks or DOSNAM~1s.

         x == y ==> equalFilePath x y
         normalise x == normalise y ==> equalFilePath x y
Posix:   equalFilePath "foo" "foo/"
Posix:   not (equalFilePath "foo" "/foo")
Posix:   not (equalFilePath "foo" "FOO")
Windows: equalFilePath "foo" "FOO"

Contract a filename, based on a relative path.

There is no corresponding makeAbsolute function, instead use System.Directory.canonicalizePath which has the same effect.

         Valid y => equalFilePath x y || (isRelative x && makeRelative y x == x) || equalFilePath (y </> makeRelative y x) x
         makeRelative x x == "."
         null y || equalFilePath (makeRelative x (x </> y)) y || null (takeFileName x)
Windows: makeRelative "C:/Home" "c:/home/bob" == "bob"
Windows: makeRelative "C:/Home" "D:/Home/Bob" == "D:/Home/Bob"
Windows: makeRelative "C:/Home" "C:Home/Bob" == "C:Home/Bob"
Windows: makeRelative "/Home" "/home/bob" == "bob"
Posix:   makeRelative "/Home" "/home/bob" == "/home/bob"
Posix:   makeRelative "/home/" "/home/bob/foo/bar" == "bob/foo/bar"
Posix:   makeRelative "/fred" "bob" == "bob"
Posix:   makeRelative "/file/test" "/file/test/fred" == "fred"
Posix:   makeRelative "/file/test" "/file/test/fred/" == "fred/"
Posix:   makeRelative "some/path" "some/path/a/b/c" == "a/b/c"

Is a path relative, or is it fixed to the root?

Windows: isRelative "path\\test" == True
Windows: isRelative "c:\\test" == False
Windows: isRelative "c:test" == True
Windows: isRelative "c:" == True
Windows: isRelative "\\\\foo" == False
Windows: isRelative "/foo" == True
Posix:   isRelative "test/path" == True
Posix:   isRelative "/test" == False

not . isRelative

isAbsolute x == not (isRelative x)