Ƴ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Safe1Path of some base and type.FInternally is a ByteString. The ByteString can be of two formats only: !without trailing path separator: file.txt,  foo/bar.txt,  /foo/bar.txtwith trailing path separator: foo/,  /foo/bar/(There are no duplicate path separators //, no .., no ./, no ~/, etc.Same as  .The following property holds: x == y "a show x == show yByteString ordering.The following property holds: 'show x `compare` show y "a x `compare` yByteString equality.The following property holds: show x == show y "a x == ySafe~Returns True if posix-paths was compiled with support for the provided flag. (As of this writing, the only flag for which this check may be necessary is $; all other flags will always yield True.) O_CLOEXEC0 is not supported on every POSIX platform. Use  oCloexec to determine if support for  O_CLOEXEC@ was compiled into your version of posix-paths. (If not, using oCloexec will throw an exception.)       2016 Julian OspaldBSD3"Julian Ospald <hasufell@posteo.de> experimentalportableSafeN"$*Open and optionally create this file. See   $ for information on how to use the FileMode type.Note that passing Just x# as the 4th argument triggers the 1 status flag, which must be set when you pass in 0 to the status flags. Also see the manpage for open(2).$status flags of open(2)Just xJ => creates the file with the given modes, Nothing => the file must exist.$$ 2016 Julian OspaldBSD3"Julian Ospald <hasufell@posteo.de> experimentalportableSafeN.%Path separator character&*Check if a character is the path separator+\n -> (_chr n == '/') == isPathSeparator n'Search path separator(1Check if a character is the search path separator0\n -> (_chr n == ':') == isSearchPathSeparator n)File extension separator*4Check if a character is the file extension separator)\n -> (_chr n == '.') == isExtSeparator n+#Take a ByteString, split it on the ' . Blank items are converted to .. Follows the recommendations in Fhttp://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap08.html#splitSearchPath "File1:File2:File3"["File1","File2","File3"]$splitSearchPath "File1::File2:File3"["File1",".","File2","File3"]splitSearchPath ""["."],Get a list of s in the $PATH variable.-Split a # into a path+filename and extensionsplitExtension "file.exe"("file",".exe")splitExtension "file" ("file","")"splitExtension "/path/file.tar.gz"("/path/file.tar",".gz"):\path -> uncurry (BS.append) (splitExtension path) == path.Get the final extension from a takeExtension "file.exe"".exe"takeExtension "file"""!takeExtension "/path/file.tar.gz"".gz"/Change a file's extensionJ\path -> let ext = takeExtension path in replaceExtension path ext == path0 Drop the final extension from a dropExtension "file.exe""file"dropExtension "file""file"!dropExtension "/path/file.tar.gz""/path/file.tar"1Add an extension to a addExtension "file" ".exe" "file.exe"addExtension "file.tar" ".gz" "file.tar.gz"addExtension "/path/" ".ext" "/path/.ext"2 Check if a  has an extensionhasExtension "file"FalsehasExtension "file.tar"TruehasExtension "/path.part1/"False3Operator version of 14Split a  on the first extension.#splitExtensions "/path/file.tar.gz"("/path/file",".tar.gz")<\path -> uncurry addExtension (splitExtensions path) == path5Remove all extensions from a "dropExtensions "/path/file.tar.gz" "/path/file"6Take all extensions from a "takeExtensions "/path/file.tar.gz" ".tar.gz"72Drop the given extension from a FilePath, and the "." preceding it. Returns 8 if the FilePath does not have the given extension, or . and the part before the extension if it does.+This function can be more predictable than 53, especially if the filename might itself contain . characters."stripExtension "hs.o" "foo.x.hs.o" Just "foo.x""stripExtension "hi.o" "foo.x.hs.o"NothingstripExtension ".c.d" "a.b.c.d" Just "a.b" stripExtension ".c.d" "a.b..c.d" Just "a.b."stripExtension "baz" "foo.bar"NothingstripExtension "bar" "foobar"Nothing,\path -> stripExtension "" path == Just pathS\path -> dropExtension path == fromJust (stripExtension (takeExtension path) path)T\path -> dropExtensions path == fromJust (stripExtension (takeExtensions path) path)8Split a  into (path,file). @ is the inversesplitFileName "path/file.txt"("path/","file.txt")splitFileName "path/" ("path/","")splitFileName "file.txt"("./","file.txt")Y\path -> uncurry combine (splitFileName path) == path || fst (splitFileName path) == "./"9Get the file nametakeFileName "path/file.txt" "file.txt"takeFileName "path/""":Change the file name9\path -> replaceFileName path (takeFileName path) == path;Drop the file namedropFileName "path/file.txt""path/"dropFileName "file.txt""./"</Get the file name, without a trailing extensiontakeBaseName "path/file.tar.gz" "file.tar"takeBaseName """"=Change the base name(replaceBaseName "path/file.tar.gz" "bob" "path/bob.gz"9\path -> replaceBaseName path (takeBaseName path) == path>BGet the directory, moving up one level if it's already a directorytakeDirectory "path/file.txt""path"takeDirectory "file""."takeDirectory "/path/to/" "/path/to"takeDirectory "/path/to""/path"?$Change the directory component of a e\path -> replaceDirectory path (takeDirectory path) `equalFilePath` path || takeDirectory path == "."@Join two paths togethercombine "/" "file""/file"combine "/path/to" "file""/path/to/file"combine "file" "/absolute/path""/absolute/path"AOperator version of combineB'Split a path into a list of components:splitPath "/path/to/file.txt"["/","path/","to/","file.txt"]+\path -> BS.concat (splitPath path) == pathCJoin a split path back together*\path -> joinPath (splitPath path) == path!joinPath ["path","to","file.txt"]"path/to/file.txt"DLike B, but without trailing slashes$splitDirectories "/path/to/file.txt"["/","path","to","file.txt"]splitDirectories ""[]E!Check if the last character of a  is .!hasTrailingPathSeparator "/path/"TruehasTrailingPathSeparator "/"True hasTrailingPathSeparator "/path"FalseFAdd a trailing path separator. addTrailingPathSeparator "/path""/path/"!addTrailingPathSeparator "/path/""/path/"addTrailingPathSeparator "/""/"G Remove a trailing path separator"dropTrailingPathSeparator "/path/""/path"%dropTrailingPathSeparator "/path////""/path"dropTrailingPathSeparator "/""/"dropTrailingPathSeparator "//""/"HNormalise a file. normalise "/file/\\test////""/file/\\test/"normalise "/file/./test" "/file/test"#normalise "/test/file/../bob/fred/""/test/file/../bob/fred/"normalise "../bob/fred/""../bob/fred/"normalise "./bob/fred/" "bob/fred/",normalise "./bob////.fred/./...///./..///#.""bob/.fred/.../../#." normalise ".""."normalise "./""./"normalise "./.""./"normalise "/./""/" normalise "/""/"normalise "bob/fred/." "bob/fred/"normalise "//home""/home"IbContract a filename, based on a relative path. Note that the resulting path will never introduce ..+ paths, as the presence of symlinks means ../b may not reach a/b if it starts from a/c. For a worked example see  Vhttp://neilmitchell.blogspot.co.uk/2015/10/filepaths-are-subtle-symlinks-are-hard.htmlthis blog post./makeRelative "/directory" "/directory/file.ext" "file.ext" makeRelative "/Home" "/home/bob" "/home/bob")makeRelative "/home/" "/home/bob/foo/bar" "bob/foo/bar"makeRelative "/fred" "bob""bob"+makeRelative "/file/test" "/file/test/fred""fred",makeRelative "/file/test" "/file/test/fred/""fred/"*makeRelative "some/path" "some/path/a/b/c""a/b/c"\p -> makeRelative p p == "."E\p -> makeRelative (takeDirectory p) p `equalFilePath` takeFileName p]prop x y -> equalFilePath x y || (isRelative x && makeRelative y x == x) || equalFilePath (y  / makeRelative y x) xJbEquality of two filepaths. The filepaths are normalised and trailing path separators are dropped.equalFilePath "foo" "foo"TrueequalFilePath "foo" "foo/"TrueequalFilePath "foo" "./foo"TrueequalFilePath "" ""TrueequalFilePath "foo" "/foo"FalseequalFilePath "foo" "FOO"FalseequalFilePath "foo" "../foo"False\p -> equalFilePath p pKCheck if a path is relative+\path -> isRelative path /= isAbsolute pathLCheck if a path is absoluteisAbsolute "/path"TrueisAbsolute "path"False isAbsolute ""FalseM:Is a FilePath valid, i.e. could you create a file like it? isValid ""False isValid "\0"FalseisValid "/random_ path:*"TrueNKTake a FilePath and make it valid; does not change already valid FilePaths. makeValid """_"makeValid "file\0name" "file_name">\p -> if isValid p then makeValid p == p else makeValid p /= p\p -> isValid (makeValid p)O@Is the given path a valid filename? This includes "." and "..".isFileName "lal"TrueisFileName "."TrueisFileName ".."True isFileName ""FalseisFileName "\0"FalseisFileName "/random_ path:*"FalseP7Check if the filepath has any parent directories in it.hasParentDir "/.."TruehasParentDir "foo/bar/.."TruehasParentDir "foo/../bar/."TruehasParentDir "foo/bar"FalsehasParentDir "foo"FalsehasParentDir ""FalsehasParentDir ".."FalseQ"Whether the file is a hidden file.hiddenFile ".foo"TruehiddenFile "..foo.bar"TruehiddenFile "some/path/.bar"TruehiddenFile "..."TruehiddenFile "dod.bar"FalsehiddenFile "."FalsehiddenFile ".."False hiddenFile ""False0Combine two paths, assuming rhs is NOT absolute.;%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQ-%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQ 2016 Julian OspaldBSD3"Julian Ospald <hasufell@posteo.de> experimentalportableNone%NU9R6Get all files from a directory and its subdirectories.Upon entering a directory, Ry will get all entries strictly. However the returned list is lazy in that directories will only be accessed on demand.)Follows symbolic links for the input dir.S?Get all files from a directory and its subdirectories strictly.)Follows symbolic links for the input dir.TRecursively apply the action7 to the parent directory and all files/subdirectories.5This function allows for memory-efficient traversals.)Follows symbolic links for the input dir.X.Gets all directory contents (not recursively).Y Binding to  fdopendir(3).ZLike X except for a file descriptor.;To avoid complicated error checks, the file descriptor is always closed, even if Y2 fails. Usually, this only happens on successful YD and after the directory stream is closed. Also see the manpage of  fdopendir(3) for more details.[*return the canonicalized absolute pathname like canonicalizePath, but uses  realpath(3) RSTUVWXYZ[ XZRSTWVUY[+ 2015 2016 FP Complete, 2016 Julian Ospald BSD 3 clause"Julian Ospald <hasufell@posteo.de> experimentalportableSafe1d^"Exception when parsing a location._A filename, without any .`$A relative path; one without a root.aAn absolute path.c@Get a location for an absolute path. Produces a normalised path.Throws: ^,parseAbs "/abc" :: Maybe (Path Abs) Just "/abc",parseAbs "/" :: Maybe (Path Abs)Just "/",parseAbs "/abc/def" :: Maybe (Path Abs)Just "/abc/def",parseAbs "/abc/def/.///" :: Maybe (Path Abs)Just "/abc/def/",parseAbs "abc" :: Maybe (Path Abs)Nothing,parseAbs "" :: Maybe (Path Abs)Nothing,parseAbs "/abc/../foo" :: Maybe (Path Abs)Nothingd@Get a location for a relative path. Produces a normalised path. Note that filepath may contain any number of ./ but may not consist solely of ./$. It also may not contain a single .. anywhere.Throws: ^ )parseRel "abc" :: Maybe (Path Rel) Just "abc")parseRel "def/" :: Maybe (Path Rel) Just "def/")parseRel "abc/def" :: Maybe (Path Rel)Just "abc/def")parseRel "abc/def/." :: Maybe (Path Rel)Just "abc/def/")parseRel "/abc" :: Maybe (Path Rel)Nothing)parseRel "" :: Maybe (Path Rel)Nothing)parseRel "abc/../foo" :: Maybe (Path Rel)Nothing)parseRel "." :: Maybe (Path Rel)Nothing)parseRel ".." :: Maybe (Path Rel)NothingeAParses a filename. Filenames must not contain slashes. Excludes  and '..'.Throws: ^ 'parseFn "abc" :: Maybe (Path Fn) Just "abc"'parseFn "..." :: Maybe (Path Fn) Just "..."'parseFn "def/" :: Maybe (Path Fn)Nothing'parseFn "abc/def" :: Maybe (Path Fn)Nothing'parseFn "abc/def/." :: Maybe (Path Fn)Nothing'parseFn "/abc" :: Maybe (Path Fn)Nothing'parseFn "" :: Maybe (Path Fn)Nothing'parseFn "abc/../foo" :: Maybe (Path Fn)Nothing'parseFn "." :: Maybe (Path Fn)Nothing'parseFn ".." :: Maybe (Path Fn)Nothingf&Convert any Path to a ByteString type.g.Convert an absolute Path to a ByteString type.h-Convert a relative Path to a ByteString type.iAppend two paths.bThe second argument must always be a relative path, which ensures that undefinable things like `"abc" <> "/def"` cannot happen.Technically, the first argument can be a path that points to a non-directory, because this library is IO-agnostic and makes no assumptions about file types.7(MkPath "/") </> (MkPath "file" :: Path Rel)"/file"7(MkPath "/path/to") </> (MkPath "file" :: Path Rel)"/path/to/file"7(MkPath "/") </> (MkPath "file/lal" :: Path Rel) "/file/lal"7(MkPath "/") </> (MkPath "file/" :: Path Rel)"/file/"jIStrip directory from path, making it relative to that directory. Throws Couldn'tStripPrefixDir* if directory is not a parent of the path.The bases must match.N(MkPath "/lal/lad") `stripDir` (MkPath "/lal/lad/fad") :: Maybe (Path Rel) Just "fad"N(MkPath "lal/lad") `stripDir` (MkPath "lal/lad/fad") :: Maybe (Path Rel) Just "fad"N(MkPath "/") `stripDir` (MkPath "/") :: Maybe (Path Rel)NothingN(MkPath "/lal/lad/fad") `stripDir` (MkPath "/lal/lad") :: Maybe (Path Rel)NothingN(MkPath "fad") `stripDir` (MkPath "fad") :: Maybe (Path Rel)Nothingk>Is p a parent of the given location? Implemented in terms of j. The bases must match.<(MkPath "/lal/lad") `isParentOf` (MkPath "/lal/lad/fad")True;(MkPath "lal/lad") `isParentOf` (MkPath "lal/lad/fad")True1(MkPath "/") `isParentOf` (MkPath "/")False8(MkPath "/lal/lad/fad") `isParentOf` (MkPath "/lal/lad")False3(MkPath "fad") `isParentOf` (MkPath "fad")FalselGet all parents of a path.%getAllParents (MkPath "/abs/def/dod")["/abs/def","/abs","/"]getAllParents (MkPath "/")[]m%Extract the directory name of a path.dirname (MkPath "/abc/def/dod") "/abc/def"dirname (MkPath "/")"/"n Extract the file part of a path.The following properties hold:  basename (p </> a) == basename aThrows: ] if given the root path "/"3basename (MkPath "/abc/def/dod") :: Maybe (Path Fn) Just "dod"4basename (MkPath "/abc/def/dod/") :: Maybe (Path Fn) Just "dod"3basename (MkPath "/") :: Maybe (Path Fn)Nothing\]^_`abcdefghijklmnopqa`_^]\bcedghfinmkljopq]^ 2016 Julian OspaldBSD3"Julian Ospald <hasufell@posteo.de> experimentalportableNone1VyA type for giving failure hints on recursive failure, which allows to programmatically make choices without examining the weakly typed I/O error attributes (like ioeGetFileName).`The first argument to the data constructor is always the source and the second the destination.~JAdditional generic IO exceptions that the posix functions do not provide.Throws  AlreadyExists  if file exists.Throws  AlreadyExists  if directory exists.Uses  and throws  if it returns True.^Check if the files are the same by examining device and file id. This follows symbolic links.Checks whether the destination directory is contained within the source directory by comparing the device+file ID of the source directory with all device+file IDs of the parent directories of the destination.RChecks if the given file exists and is not a directory. Does not follow symlinks.NChecks if the given file exists and is a directory. Does not follow symlinks.,Checks whether a file or folder is writable.WChecks whether the directory at the given path exists and can be opened. This invokes  openDirStream which follows symlinks.Carries out an action, then checks if there is an IOException and a specific errno. If so, then it carries out another action, otherwise it rethrows the error.Execute the given action and retrow IO exceptions as a new Exception that have the given errno. If errno does not match the exception is rethrown as is.Like , with arguments swapped.Like , but allows to have different clean-up actions depending on whether the in-between computation has raised an exception or not.  source dirfull destination,  dirname dest must existerrno to catch-action to try, which can raise an IOExceptionEaction to carry out in case of an IOException and if errno matcheserrno to catchrethrow as if errno matches action to trycomputation to run first8computation to run last, when no exception was raised8computation to run last, when an exception was raisedcomputation to run in-betweenreaction on IO errorsreaction on HPathIOExceptionyz{|}~~yz{|}yz{|}~ 2016 Julian OspaldBSD3"Julian Ospald <hasufell@posteo.de> experimentalportableNoneU.xApplies realpath on the given absolute path.Throws:- if the file at the given path does not exist if the symlink is brokensThe mode for copy and file moves. Overwrite mode is usually not very well defined, but is a convenience shortcut.fail if any target existsoverwrite targets(The error mode for recursive operations.On  the whole operation fails immediately if any of the recursive sub-operations fail, which is sort of the default for IO operations.On ` skips errors in the recursion and keeps on recursing. However all errors are collected in the N error type, which is raised finally if there was any error. Also note that K does not give any guarantees on the ordering of the collected exceptions.Copies the contents of a directory recursively to the given destination, while preserving permissions. Does not follow symbolic links. This behaves more or less like the following, without descending into the destination if it already exists: ) cp -a /source/dir /destination/somedir DFor directory contents, this will ignore any file type that is not ,  or .For  copy mode this does not prune destination directory contents, so the destination might contain more files than the source after the operation has completed. Permissions of existing directories are fixed.Safety/reliability concerns: not atomicexamines filetypes explicitlyan explicit check  is carried out for the top directory for basic sanity, because otherwise we might end up with an infinite copy loop... however, this operation is not carried out recursively (because it's slow)Throws:# if source directory does not exist$ if source directory can't be opened4 if source and destination are the same file (~). if destination is contained in source (~) Throws in  RecursiveErrorMode only:$ if output directory is not writable, if source directory is wrong type (symlink)1 if source directory is wrong type (regular file) Throws in  RecursiveErrorMode only:e if any of the recursive operations that are not part of the top-directory sanity-checks fail (~) Throws in  CopyMode only: if destination already existsRecreate a symlink.In 8 copy mode only files and empty directories are deleted.Safety/reliability concerns: mode is inherently non-atomicThrows:- if source file is wrong type (not a symlink)) if output directory cannot be written to% if source directory cannot be opened4 if source and destination are the same file (~) Throws in  mode only: if destination already exists Throws in  mode only:+ if destination file is non-empty directory Note: calls symlinkCopies the given regular file to the given destination. Neither follows symbolic links, nor accepts them. For "copying" symbolic links, use  instead.yNote that this is still sort of a low-level function and doesn't examine file types. For a more high-level version, use  instead.In 9 copy mode only overwrites actual files, not directories.Safety/reliability concerns: mode is not atomic when used on ], reads the "contents" and copies them to a regular file, which might take indefinitely when used on , may either read the "contents" and copy them to a regular file (potentially hanging indefinitely) or may create a regular empty destination file when used on , will hang indefinitelyThrows: if source file does not exist if source file is a a $ if output directory is not writable$ if source directory can't be opened4 if source file is wrong type (symlink or directory)4 if source and destination are the same file (~) Throws in  mode only: if destination already exists Note: calls sendfile and possibly /write as fallbackCopies a regular file, directory or symbolic link. In case of a symbolic link it is just recreated, even if it points to a directory. Any other file type is ignored.Safety/reliability concerns:examines filetypes explicitlycalls  for directoriesDeletes the given file. Raises eISDIR8 if run on a directory. Does not follow symbolic links.Throws: for wrong file type (directory) if the file does not exist if the directory cannot be readADeletes the given directory, which must be empty, never symlinks.Throws:+ for wrong file type (symlink to directory)# for wrong file type (regular file) if directory does not exist if directory is not empty. if we can't open or write to parent directory Notes: calls rmdirPDeletes the given directory recursively. Does not follow symbolic links. Tries / first before attemtping a recursive deletion.(On directory contents this behaves like 1 and thus will ignore any file type that is not ,  or .Safety/reliability concerns: not atomicexamines filetypes explicitlyThrows:+ for wrong file type (symlink to directory)# for wrong file type (regular file) if directory does not exist. if we can't open or write to parent directoryDeletes a file, directory or symlink. In case of directory, performs recursive deletion. In case of a symlink, the symlink file is deleted. Any other file type is ignored.Safety/reliability concerns:examines filetypes explicitlycalls  for directorieseOpens a file appropriately by invoking xdg-open. The file type is not checked. This forks a process.BExecutes a program with the given arguments. This forks a process.MCreate an empty regular file at the given directory with the given filename.Throws:) if output directory cannot be written to if destination already exists? if any of the parent components of the path do not existICreate an empty directory at the given directory with the given filename.Throws:) if output directory cannot be written to if destination already exists? if any of the parent components of the path do not existCreate an empty directory at the given directory with the given filename. All parent directories are created with the same filemode. This basically behaves like:  mkdir -p /some/dir Safety/reliability concerns: not atomicThrows:O if any part of the path components do not exist and cannot be written to; if destination already exists and is not a directoryCreate a symlink.Throws:) if output directory cannot be written to# if destination file already exists? if any of the parent components of the path do not exist Note: calls symlinknRename a given file with the provided filename. Destination and source must be on the same device, otherwise  will be raised.CDoes not follow symbolic links, but renames the symbolic link file.Safety/reliability concerns:@has a separate set of exception handling, apart from the syscallThrows: if source file does not exist) if output directory cannot be written to% if source directory cannot be opened: if source and destination are on different devices if destination already exists5 if destination and source are the same file (~) Note: calls 3 (but does not allow to rename over existing files)dMove a file. This also works across devices by copy-delete fallback. And also works on directories.CDoes not follow symbolic links, but renames the symbolic link file.Safety/reliability concerns: mode is not atomic-copy-delete fallback is inherently non-atomicsince this function calls  and  as a fallback to , file types that are not ,  or  may be ignoredfor L mode, the destination will be deleted (not recursively) before movingThrows: if source file does not exist) if output directory cannot be written to% if source directory cannot be opened5 if destination and source are the same file (~) Throws in  mode only: if destination already exists Note: calls 3 (but does not allow to rename over existing files)Read the given file at once into memory as a strict ByteString. Symbolic links are followed, no sanity checks on file size or file type. File must exist.UNote: the size of the file is determined in advance, as to only have one allocation.Safety/reliability concerns:since amount of bytes to read is determined in advance, the file might be read partially only if something else is appending to it while reading#the whole file is read into memory!Throws:+ if file is not a regular file or a symlinkC if we cannot read the file or the directory containting it if the file does not exist&Read the given file in chunks of size `8192` into memory until freadP returns 0. Returns a lazy ByteString, because it uses Builders under the hood.Safety/reliability concerns:#the whole file is read into memory!Throws:+ if file is not a regular file or a symlinkC if we cannot read the file or the directory containting it if the file does not existkWrite a given ByteString to a file, truncating the file beforehand. The file must exist. Follows symlinks.Throws:+ if file is not a regular file or a symlinkC if we cannot read the file or the directory containting it if the file does not existLAppend a given ByteString to a file. The file must exist. Follows symlinks.Throws:+ if file is not a regular file or a symlinkC if we cannot read the file or the directory containting it if the file does not exist#Default permissions for a new file.(Default permissions for a new directory.tGets all filenames of the given directory. This excludes "." and "..". This version does not follow symbolic links.FThe contents are not sorted and there is no guarantee on the ordering.Throws: if directory does not exist if file type is wrong (file)( if file type is wrong (symlink to file)' if file type is wrong (symlink to dir) if directory cannot be openedYGet the file type of the file located at the given path. Does not follow symbolic links.Throws: if the file does not exist* if any part of the path is not accessible source dir:destination (parent dirs are not automatically created)the old symlink filedestination file source filedestination file source filedestination fileprogram argumentsdestination filepath the symlink points to file to move destination dir to read'x'x    !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk lmn opKqrstuvwxyz{|}~"hpath-0.8.1-DEk3fucrhPaEZeN9cHqgXKHPathSystem.Posix.Directory.ForeignSystem.Posix.FDSystem.Posix.FilePath!System.Posix.Directory.TraversalsHPath.IOHPath.IO.ErrorsHPath.Internal toFilePath System.PosixFilesPathFlagsUnsupportedFlagDirTypeunFlags isSupportedoCloexecdtBlkdtChrdtDirdtFifodtLnkdtRegdtSock dtUnknownoAppendoAsyncoCreat oDirectoryoExcloNoctty oNofollow oNonblockoRdonlyoWronlyoRdwroSyncoTruncpathMax unionFlags $fEqDirType $fShowDirType $fEqFlags $fShowFlagsopenFd pathSeparatorisPathSeparatorsearchPathSeparatorisSearchPathSeparator extSeparatorisExtSeparatorsplitSearchPath getSearchPathsplitExtension takeExtensionreplaceExtension dropExtension addExtension hasExtension<.>splitExtensionsdropExtensionstakeExtensionsstripExtension splitFileName takeFileNamereplaceFileName dropFileName takeBaseNamereplaceBaseName takeDirectoryreplaceDirectorycombine splitPathjoinPathsplitDirectorieshasTrailingPathSeparatoraddTrailingPathSeparatordropTrailingPathSeparator normalise makeRelative equalFilePath isRelative isAbsoluteisValid makeValid isFileName hasParentDir hiddenFileallDirectoryContentsallDirectoryContents'traverseDirectoryunpackDirStream packDirStream readDirEntgetDirectoryContents fdOpendirgetDirectoryContents'realpathRelC PathExceptionPathParseExceptionFnRelAbsparseAbsparseRelparseFnfromAbsfromRelstripDir isParentOf getAllParentsdirnamebasename withAbsPath withRelPath withFnPath$fExceptionPathParseException$fExceptionPathException$fRelCFn $fRelCRel$fShowPathParseException$fShowPathExceptioncanonicalizePathRecursiveFailureHintReadContentsFailedCreateDirFailedCopyFileFailedRecreateSymlinkFailedHPathIOExceptionSameFileDestinationInSourceRecursiveFailure isSameFileisDestinationInSourceisRecursiveFailureisReadContentsFailedisCreateDirFailedisCopyFileFailedisRecreateSymlinkFailedthrowFileDoesExistthrowDirDoesExist throwSameFilesameFilethrowDestinationInSource doesFileExistdoesDirectoryExist isWritablecanOpenDirectory catchErrnorethrowErrnoAs handleIOError bracketeer reactOnError$fExceptionHPathIOException$fEqRecursiveFailureHint$fShowRecursiveFailureHint$fEqHPathIOException$fShowHPathIOExceptionCopyModeStrict OverwriteRecursiveErrorMode FailEarlyCollectFailuresFileType Directory RegularFile SymbolicLink BlockDeviceCharacterDevice NamedPipeSocketcopyDirRecursiverecreateSymlinkcopyFileeasyCopy deleteFile deleteDirdeleteDirRecursive easyDeleteopenFile executeFilecreateRegularFile createDircreateDirRecursive createSymlink renameFilemoveFilereadFile readFileEOF writeFile appendFile newFilePerms newDirPerms getDirsFiles getFileType $fEqFileType$fShowFileType $fShowPath $fOrdPath$fEqPathMkPath unix-2.7.2.2 System.Posix.ByteString.FilePath RawFilePathbaseGHC.BaseNothingJustGHC.Real/ combineRawthrowErrnoPathIfMinus1_throwErrnoPathIfMinus1throwErrnoPathIfNullthrowErrnoPathIf_throwErrnoPathIfthrowErrnoPaththrowErrnoPathIfRetrythrowErrnoPathIfNullRetrythrowErrnoPathIfMinus1Retry_throwErrnoPathIfMinus1RetrypeekFilePathLen peekFilePath withFilePath.RootDirHasNoBasename InvalidAbs InvalidRel InvalidFnCouldn'tStripPrefixTPSGHC.IO.ExceptionIOErrorSystem.IO.Error catchIOErrorControl.Exception.Basebracket NoSuchThingPermissionDeniedInvalidArgumentInappropriateType AlreadyExistsUnsatisfiedConstraints Text.ReadreadForeign.C.ErroreXDEVUnsupportedOperationSystem.Posix.Files.ByteStringrename _copyFile