!q      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~SafeDdThe character that separates directories. In the case where more than one character is possible, D is the 'ideal' one. +> Posix.isPathSeparator Posix.pathSeparatorE$The list of all possible separators. 1> Posix.pathSeparator `elem` Posix.pathSeparatorsFRather than using (== D)5, use this. Test if something is a path separator. <> Posix.isPathSeparator a == (a `elem` Posix.pathSeparators)}We cannot have a PathComponent without phantom types plus a Tagged wrapper, because we need specialised Eq and Ord instances.*CDEFGHIJKLMNOP"CDEFIHGJKLMNOPCDEFGHIJKLMNOPSafeKLMNOPPONMLK Safe5 Safe SafeSeThis class allows selective behaviour for file and directory paths and is mostly for internal use.WhThis class allows selective behaviour for absolute and relative paths and is mostly for internal use.XSee  /https://wiki.haskell.org/Closed_world_instances for the used technique.JThis class provides a way to prevent other modules from making further U or Q instances;QRSTUVWX#QRSTUVWX-QRSTUVWXSafeQRSTUVWXWXUVSTQR SafeOn+This is the main filepath abstract datatypeo$Map over the components of the path. m> Path.pathMap (map toLower) (absDir "/tmp/Reports/SpreadSheets") == Posix.absDir "/tmp/reports/spreadsheets"Currently not exportedCurrently not exportedr Convert the n into a plain  as required for OS calls.s Synonym of r intended for unqualified use.vThis is a file with path ""O. You will not be able to create a file with this name. We also forbid parsing "" by |e. You might only need this file path as intermediate step when manipulating extensions of files like  ".bashrc".wSThis function is intended for checking and parsing paths provided as user input. > fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.AbsDir) == Just "/" > fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.AbsFile) == Nothing > fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.RelDir) == Nothing > fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.RelFile) == Nothing > fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.AbsDir) == Just "/tmp" > fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.AbsFile) == Just "/tmp" > fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.RelDir) == Nothing > fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.RelFile) == Nothing > fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.AbsDir) == Just "/tmp" > fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.AbsFile) == Nothing > fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.RelDir) == Nothing > fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.RelFile) == Nothing > fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.AbsRelFileDir) == Just "/tmp" > fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.AbsRelFileDir) == Just "/tmp" > fmap Posix.toString (Posix.maybePath "file.txt" :: Maybe Posix.RelFile) == Just "file.txt" > fmap Posix.toString (Posix.maybePath "file.txt" :: Maybe Posix.AbsFile) == Nothing > fmap Windows.toString (Windows.maybePath "\\tmp" :: Maybe Windows.AbsDir) == Just "\\tmp" > fmap Windows.toString (Windows.maybePath "a:\\tmp" :: Maybe Windows.AbsDir) == Just "a:\\tmp" > fmap Windows.toString (Windows.maybePath "a:tmp" :: Maybe Windows.AbsDir) == Just "a:tmp" > fmap Windows.toString (Windows.maybePath "a:\\" :: Maybe Windows.AbsDir) == Just "a:\\" > fmap Windows.toString (Windows.maybePath "a:" :: Maybe Windows.AbsDir) == Just "a:" > fmap Windows.toString (Windows.maybePath "tmp" :: Maybe Windows.RelDir) == Just "tmp" > fmap Windows.toString (Windows.maybePath "\\tmp" :: Maybe Windows.RelDir) == Nothing > fmap Windows.toString (Windows.maybePath "a:\\tmp" :: Maybe Windows.RelDir) == Nothing > fmap Windows.toString (Windows.maybePath "a:tmp" :: Maybe Windows.RelDir) == Nothing > fmap Windows.toString (Windows.maybePath "tmp" :: Maybe Windows.AbsDir) == NothingxSThis function is intended for checking and parsing paths provided as user input. > fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.AbsDir) == Just "/" > fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.AbsFile) == Nothing > fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.RelDir) == Nothing > fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.RelFile) == Nothing > fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.AbsDir) == Just "/tmp" > fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.AbsFile) == Just "/tmp" > fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.RelDir) == Nothing > fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.RelFile) == Nothing > fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.AbsDir) == Just "/tmp" > fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.AbsFile) == Nothing > fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.RelDir) == Nothing > fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.RelFile) == Nothing > fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.AbsRelFileDir) == Just "/tmp" > fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.AbsRelFileDir) == Just "/tmp" > fmap Posix.toString (Posix.maybePath "file.txt" :: Maybe Posix.RelFile) == Just "file.txt" > fmap Posix.toString (Posix.maybePath "file.txt" :: Maybe Posix.AbsFile) == Nothing > fmap Windows.toString (Windows.maybePath "\\tmp" :: Maybe Windows.AbsDir) == Just "\\tmp" > fmap Windows.toString (Windows.maybePath "a:\\tmp" :: Maybe Windows.AbsDir) == Just "a:\\tmp" > fmap Windows.toString (Windows.maybePath "a:tmp" :: Maybe Windows.AbsDir) == Just "a:tmp" > fmap Windows.toString (Windows.maybePath "a:\\" :: Maybe Windows.AbsDir) == Just "a:\\" > fmap Windows.toString (Windows.maybePath "a:" :: Maybe Windows.AbsDir) == Just "a:" > fmap Windows.toString (Windows.maybePath "tmp" :: Maybe Windows.RelDir) == Just "tmp" > fmap Windows.toString (Windows.maybePath "\\tmp" :: Maybe Windows.RelDir) == Nothing > fmap Windows.toString (Windows.maybePath "a:\\tmp" :: Maybe Windows.RelDir) == Nothing > fmap Windows.toString (Windows.maybePath "a:tmp" :: Maybe Windows.RelDir) == Nothing > fmap Windows.toString (Windows.maybePath "tmp" :: Maybe Windows.AbsDir) == Nothing{jThis function is intended for converting path strings with known content, e.g. string literals, to the n type.| Construct a l from a . i> Posix.toString (Posix.relFile "file.txt") == "file.txt" > Posix.toString (Posix.relFile "tmp") == "tmp"} Construct a j from a . > Posix.toString (Posix.relDir ".") == "." > Posix.toString (Posix.relDir "file.txt") == "file.txt" > Posix.toString (Posix.relDir "tmp") == "tmp"~ Construct an m from a . m> Posix.toString (Posix.absFile "/file.txt") == "/file.txt" > Posix.toString (Posix.absFile "/tmp") == "/tmp" Construct an k from a . k> Posix.toString (Posix.absDir "/file.txt") == "/file.txt" > Posix.toString (Posix.absDir "/tmp") == "/tmp"Construct a 'Rel fd' from a .Construct an 'Abs fd' from a . Construct an 'AbsRel fd' from a .Construct a 'File ar' from a .Construct a 'Dir ar' from a . Construct a 'FileDir ar' from a . Construct a 'RelPath fd' from a .!Construct an 'AbsPath fd' from a .!Construct a 'FilePath ar' from a . Construct a 'DirPath ar' from a .Use a  as a nO whose type is determined by its context. You should not use this and other as* functions, since they may silently turn a relative path to an absolute one, or vice versa, or they may accept a path as file path although it ends on a slash. If you are certain about the string content then you should use {2. If you got the string as user input then use x or z. [> Posix.asPath "/tmp" == Posix.absDir "/tmp" > Posix.asPath "file.txt" == Posix.relFile "file.txt" > Path.isAbsolute (Posix.asAbsDir "/tmp") > Path.isRelative (Posix.asRelDir "/tmp") > Posix.toString (Posix.asPath "/tmp" :: Posix.AbsDir) == "/tmp" > Posix.toString (Posix.asPath "/tmp" :: Posix.RelDir) == "tmp" > Windows.toString (Windows.asPath "\\tmp" :: Windows.AbsDir) == "\\tmp" > Windows.toString (Windows.asPath "a:\\tmp" :: Windows.AbsDir) == "a:\\tmp" > Windows.toString (Windows.asPath "a:tmp" :: Windows.AbsDir) == "a:tmp" > Windows.toString (Windows.asPath "tmp" :: Windows.RelDir) == "tmp"Use a  as a l. No checking is done. > Posix.toString (Posix.asRelFile "file.txt") == "file.txt" > Posix.toString (Posix.asRelFile "/file.txt") == "file.txt" > Posix.toString (Posix.asRelFile "tmp") == "tmp" > Posix.toString (Posix.asRelFile "/tmp") == "tmp"Use a  as a j. No checking is done. > Posix.toString (Posix.asRelDir ".") == "." > Posix.toString (Posix.asRelDir "file.txt") == "file.txt" > Posix.toString (Posix.asRelDir "/file.txt") == "file.txt" > Posix.toString (Posix.asRelDir "tmp") == "tmp" > Posix.toString (Posix.asRelDir "/tmp") == "tmp"Use a  as an m. No checking is done. q> Posix.toString (Posix.asAbsFile "/file.txt") == "/file.txt" > Posix.toString (Posix.asAbsFile "/tmp") == "/tmp"Use a  as an k. No checking is done. o> Posix.toString (Posix.asAbsDir "/file.txt") == "/file.txt" > Posix.toString (Posix.asAbsDir "/tmp") == "/tmp"Use a ( as a 'RelPath fd'. No checking is done.Use a ) as an 'AbsPath fd'. No checking is done.Use a ) as a 'FilePath ar'. No checking is done.Use a ( as a 'DirPath ar'. No checking is done.YExamines the supplied string and constructs an absolute or relative path as appropriate. r> Path.mkPathAbsOrRel "/tmp" == Left (Posix.absDir "/tmp") > Path.mkPathAbsOrRel "tmp" == Right (Posix.relDir "tmp") > Path.mkPathAbsOrRel "\\tmp" == Left (Windows.absDir "\\tmp") > Path.mkPathAbsOrRel "d:\\tmp" == Left (Windows.absDir "d:\\tmp") > Path.mkPathAbsOrRel "d:tmp" == Left (Windows.absDir "d:tmp") > Path.mkPathAbsOrRel "tmp" == Right (Windows.relDir "tmp")YExamines the supplied string and constructs an absolute or relative path as appropriate. r> Path.mkPathAbsOrRel "/tmp" == Left (Posix.absDir "/tmp") > Path.mkPathAbsOrRel "tmp" == Right (Posix.relDir "tmp") > Path.mkPathAbsOrRel "\\tmp" == Left (Windows.absDir "\\tmp") > Path.mkPathAbsOrRel "d:\\tmp" == Left (Windows.absDir "d:\\tmp") > Path.mkPathAbsOrRel "d:tmp" == Left (Windows.absDir "d:tmp") > Path.mkPathAbsOrRel "tmp" == Right (Windows.relDir "tmp")PSearches for a file or directory with the supplied path string and returns a M or LA path as appropriate. If neither exists at the supplied path,  is returned. Convert a  into an ^J by interpreting it as relative to the supplied directory if necessary. > Path.mkAbsPath (absDir "/tmp") "foo.txt" == Posix.absFile "/tmp/foo.txt" > Path.mkAbsPath (absDir "/tmp") "/etc/foo.txt" == Posix.absFile "/etc/foo.txt" Convert a  into an ^; by interpreting it as relative to the cwd if necessary.QParse path string independent from expectations expressed by the type parameters.Infix variant of . > Posix.toString (Posix.absDir "/tmp" </> Posix.relFile "file.txt") == "/tmp/file.txt" > Posix.toString (Posix.absDir "/tmp" </> Posix.relDir "dir" </> Posix.relFile "file.txt") == "/tmp/dir/file.txt" > Posix.toString (Posix.relDir "dir" </> Posix.relFile "file.txt") == "dir/file.txt" > Windows.toString (Windows.absDir "\\tmp" </> Windows.relFile "file.txt") == "\\tmp\\file.txt" > Windows.toString (Windows.absDir "c:\\tmp" </> Windows.relFile "file.txt") == "c:\\tmp\\file.txt" > Windows.toString (Windows.absDir "c:tmp" </> Windows.relFile "file.txt") == "c:tmp\\file.txt" > Windows.toString (Windows.absDir "c:\\" </> Windows.relDir "tmp" </> Windows.relFile "file.txt") == "c:\\tmp\\file.txt" > Windows.toString (Windows.absDir "c:" </> Windows.relDir "tmp" </> Windows.relFile "file.txt") == "c:tmp\\file.txt" > Windows.toString (Windows.relDir "dir" </> Windows.relFile "file.txt") == "dir\\file.txt"Infix variant of s. We only allow files (and not directories) to have extensions added by this function. This is because it's the vastly common case and an attempt to add one to a directory will - more often than not - represent an error. We don't however want to prevent the corresponding operation on directories, and so we provide a function that is more flexible: .>Add an extension, even if there is already one there. E.g. -addExtension "foo.txt" "bat" -> "foo.txt.bat". > Path.addExtension (relFile "file.txt") "bib" == Posix.relFile "file.txt.bib" > Path.addExtension (relFile "file.") ".bib" == Posix.relFile "file..bib" > Path.addExtension (relFile "file") ".bib" == Posix.relFile "file.bib" > Path.addExtension Path.emptyFile "bib" == Posix.relFile ".bib" > Path.addExtension Path.emptyFile ".bib" == Posix.relFile ".bib" > Path.takeFileName (Path.addExtension Path.emptyFile "ext") == Posix.relFile ".ext"mJoin an (absolute or relative) directory path with a relative (file or directory) path to form a new path.0Remove last extension, and the "." preceding it. 5> Path.dropExtension x == fst (Path.splitExtension x)Drop all extensions 3> not $ Path.hasAnExtension (Path.dropExtensions x) Synonym for @Set the extension of a file, overwriting one if already present. > Path.replaceExtension (relFile "file.txt") ".bob" == Posix.relFile "file.bob" > Path.replaceExtension (relFile "file.txt") "bob" == Posix.relFile "file.bob" > Path.replaceExtension (relFile "file") ".bob" == Posix.relFile "file.bob" > Path.replaceExtension (relFile "file.txt") "" == Posix.relFile "file" > Path.replaceExtension (relFile "file.fred.bob") "txt" == Posix.relFile "file.fred.txt"Split on the extension.  is the inverse. > uncurry (<.>) (Path.splitExtension x) == x > uncurry Path.addExtension (Path.splitExtension x) == x > Path.splitExtension (relFile "file.txt") == (Posix.relFile "file",".txt") > Path.splitExtension (relFile ".bashrc") == (Posix.emptyFile, ".bashrc") > Path.splitExtension (relFile "file") == (Posix.relFile "file","") > Path.splitExtension (relFile "file/file.txt") == (Posix.relFile "file/file",".txt") > Path.splitExtension (relFile "file.txt/boris") == (Posix.relFile "file.txt/boris","") > Path.splitExtension (relFile "file.txt/boris.ext") == (Posix.relFile "file.txt/boris",".ext") > Path.splitExtension (relFile "file/path.txt.bob.fred") == (Posix.relFile "file/path.txt.bob",".fred")Split on all extensions R> Path.splitExtensions (relFile "file.tar.gz") == (Posix.relFile "file",".tar.gz")Get the basename of a file > Path.takeBaseName (absFile "/tmp/somedir/myfile.txt") == Posix.relFile "myfile" > Path.takeBaseName (relFile "./myfile.txt") == Posix.relFile "myfile" > Path.takeBaseName (relFile "myfile.txt") == Posix.relFile "myfile"%Get the extension of a file, returns "" for no extension, .ext otherwise. > Path.takeExtension x == snd (Path.splitExtension x) > Path.takeExtension (Path.addExtension x "ext") == ".ext" > Path.takeExtension (Path.replaceExtension x "ext") == ".ext"Get all extensions @> Path.takeExtensions (Posix.relFile "file.tar.gz") == ".tar.gz"HGet the filename component of a file path (ie stripping all parent dirs) > Path.takeFileName (absFile "/tmp/somedir/myfile.txt") == Posix.relFile "myfile.txt" > Path.takeFileName (relFile "./myfile.txt") == Posix.relFile "myfile.txt" > Path.takeFileName (relFile "myfile.txt") == Posix.relFile "myfile.txt"2Check whether two strings are equal as file paths. > Posix.equalFilePath "abc/def" "abc/def" > Posix.equalFilePath "abc/def" "abc//def" > Posix.equalFilePath "/tmp/" "/tmp" > Posix.equalFilePath "/tmp" "//tmp" > Posix.equalFilePath "/tmp" "///tmp" > not $ Posix.equalFilePath "abc" "def" > not $ Posix.equalFilePath "/tmp" "tmp" > Windows.equalFilePath "abc\\def" "abc\\def" > Windows.equalFilePath "abc\\def" "abc\\\\def" > Windows.equalFilePath "file" "File" > Windows.equalFilePath "\\file" "\\\\file" > Windows.equalFilePath "\\file" "\\\\\\file" > not $ Windows.equalFilePath "abc" "def" > not $ Windows.equalFilePath "file" "dir" Constructs a ] from a list of components. It is an unchecked error if the path components contain path separators. It is an unchecked error if a l path is empty. > Path.joinPath ["tmp","someDir","dir"] == Posix.relDir "tmp/someDir/dir" > Path.joinPath ["tmp","someDir","file.txt"] == Posix.relFile "tmp/someDir/file.txt"Currently just transforms: Y> Path.normalise (absFile "/tmp/fred/./jim/./file") == Posix.absFile "/tmp/fred/jim/file"(Deconstructs a path into its components. > Path.splitPath (Posix.absDir "/tmp/someDir/mydir.dir") == (True, map relDir ["tmp","someDir","mydir.dir"], Nothing) > Path.splitPath (Posix.absFile "/tmp/someDir/myfile.txt") == (True, map relDir ["tmp","someDir"], Just $ relFile "myfile.txt")SThis function can be used to construct a relative path by removing the supplied k! from the front. It is a runtime  if the supplied ^ doesn't start with the k. ~> Path.makeRelative (absDir "/tmp/somedir") (absFile "/tmp/somedir/anotherdir/file.txt") == Posix.relFile "anotherdir/file.txt" > Path.makeRelative (absDir "/tmp/somedir") (absDir "/tmp/somedir/anotherdir/dir") == Posix.relDir "anotherdir/dir" > Path.makeRelative (absDir "c:\\tmp\\somedir") (absFile "C:\\Tmp\\SomeDir\\AnotherDir\\File.txt") == Windows.relFile "AnotherDir\\File.txt" > Path.makeRelative (absDir "c:\\tmp\\somedir") (absDir "c:\\tmp\\somedir\\anotherdir\\dir") == Windows.relDir "anotherdir\\dir" > Path.makeRelative (absDir "c:tmp\\somedir") (absDir "c:tmp\\somedir\\anotherdir\\dir") == Windows.relDir "anotherdir\\dir"UJoins an absolute directory with a relative path to construct a new absolute path.  > Path.makeAbsolute (absDir "/tmp") (relFile "file.txt") == Posix.absFile "/tmp/file.txt" > Path.makeAbsolute (absDir "/tmp") (relFile "adir/file.txt") == Posix.absFile "/tmp/adir/file.txt" > Path.makeAbsolute (absDir "/tmp") (relDir "adir/dir") == Posix.absDir "/tmp/adir/dir"]Converts a relative path into an absolute one by prepending the current working directory.As for |, but for use when the path may already be absolute (in which case it is left unchanged). You should avoid the use of ]-type functions, because then you avoid to absolutize a path that was already absolutized. :> Path.genericMakeAbsolute (absDir "/tmp") (relFile "file.txt") == Posix.absFile "/tmp/file.txt" > Path.genericMakeAbsolute (absDir "/tmp") (relFile "adir/file.txt") == Posix.absFile "/tmp/adir/file.txt" > Path.genericMakeAbsolute (absDir "/tmp") (absFile "/adir/file.txt") == Posix.absFile "/adir/file.txt"As for \, but for use when the path may already be absolute (in which case it is left unchanged).Convert a file to a directory path. Obviously, the corresponding disk object won't change accordingly. The purpose of this function is to be an intermediate step when deriving a directory name from a file name.<Convert a directory to a file path. The function returns  if the directory path is empty. The purpose of this function is to be an intermediate step when deriving a file name from a directory name.Test whether a n ar fd is absolute. > Path.isAbsolute (Posix.absFile "/fred") > Path.isAbsolute (Windows.absFile "\\fred") > Path.isAbsolute (Windows.absFile "c:\\fred") > Path.isAbsolute (Windows.absFile "c:fred")7Invariant - this should return True iff arg is of type n Part.Rel _ r isRelative = not . isAbsolute > Path.isRelative (Posix.relFile "fred") > Path.isRelative (Windows.relFile "fred")Test whether the : would correspond to an absolute path if interpreted as a n.Test whether the 9 would correspond to a relative path if interpreted as a n. )isRelativeString = not . isAbsoluteString*Does the given filename have an extension? <> null (Path.takeExtension x) == not (Path.hasAnExtension x)1Does the given filename have the given extension? > Path.hasExtension ".hs" (Posix.relFile "MyCode.hs") > Path.hasExtension ".hs" (Posix.relFile "MyCode.bak.hs") > not $ Path.hasExtension ".hs" (Posix.relFile "MyCode.hs.bak")Part.File extension character > Posix.extSeparator == '.'UThe character that is used to separate the entries in the $PATH environment variable.(Is the character an extension character? 5> Posix.isExtSeparator a == (a == Posix.extSeparator)"Is the character a file separator? C> Posix.isSearchPathSeparator a == (a == Posix.searchPathSeparator)#This is a more flexible variant of  / , which can work with files or directories  > Path.genericAddExtension (absDir "/") "x" == Posix.absDir "/.x" > Path.genericAddExtension (absDir "/a") "x" == Posix.absDir "/a.x" > Path.genericAddExtension Path.emptyFile "x" == Posix.relFile ".x" > Path.genericAddExtension Path.emptyFile "" == Posix.emptyFile4Check internal integrity of the path data structure.CForbid use of OverloadedStrings and prevent custom orphan instances}Currently it also parses Part.AbsRel and Part.FileDir paths, although these cannot be composed with the accepted combinators.@We show and parse file path components using the rather generic  smart constructor instead of |, } and relPath str :: FileDirPath ar%. Otherwise handling of all cases of M, L and K" types becomes pretty complicated.YZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;CDEFIHGJYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~YZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;577SafeThis is largely for   compatibilityThis is largely for   compatibilityThis is largely for   compatibilityF<=>?     @D     D     E<=>?     @SafeXThis is largely for   compatibilityYThis is largely for   compatibilityZThis is largely for   compatibilityG !"#$%&'()*+,-./01ABCD23456789:;<=>?@ABCDEFGHIJKLMNOPQEFRSTUVWXYZ[\D !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[D10/.-'&%$,+*)#"(! 23456789:?;<=>@ABCEDFGHIJKLMNOPQSTRUVWXYZ[F !"#$%&'()*+,-./01ABCD23456789:;<=>?@ABCDEFGHIJKLMNOPQEFRSTUVWXYZ[\Safe~CYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ًnmlkjihgfe^d]c\b[aZ`Y_pqrstuvxwzy{|}~oCDEFGHIJCSafeD     Safeopqs     SafebURetrieve the contents of a directory without any directory prefixes. In contrast to ,, exclude special directories "." and "..".cSRetrieve the contents of a directory path (which may be relative) as absolute pathsdReturns paths relative toX the supplied (abs or relative) directory path. eg (for current working directory of /somewhere/cwd/): show (relDirectoryContents "d/e/f/") == (["subDir1A","subDir1B"], ["file1A","file1B"])eA convenient alternative to d if you only want files.fA convenient alternative to d if you only want directories.]^_`abcdGefghijklmnopqrstuvwB]^_`abcdefghijklmnopqrstuvw]^_`abcdefghijklmnopqrstBuvw]^_`abcdGefghijklmnopqrstuvwSafe xyz{|}~K  !"#$%&'()*+,-./012348765<;:9A@?>=xyz{|}~Kxyz{|}~3A@?>=&%$#8765!4 '<;:9210"/.-, +)*( xyz{|}~H !"#$%&'(')'*+,+-+.+/+0+1+2+3+4+5+6+7+8+9+:+;+<+=+>+?+@+ABCBDBEBFBGBHBIBJBKBLBM'N+OPQRSTUTVTWTXYZY[Y\Y]Y^_` abcdefghijklm n o h p q r k s t u v  w x h k i j l m y z { | } ~     tuvwxhkijlmyz{|}~abctuvwxhkijlmyz{|}~abc     hijlm !"#$%&'()*+ , , - . / 0 1 2 3 3 4 5 5 6 7 7 8 i 9 j : l ; m < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \]^ _]` abc d e f g g h i j k l  m n o p q r p o s t u v w x y z { | } ~                                                                 #pathtype-0.8-AxzGlf4JUPwB9OMZXyiXrpSystem.Path.IOSystem.Path.DirectorySystem.Path.GenericSystem.Path.PartSystem.Path.PartClassSystem.Path.PosixSystem.Path.WindowsSystem.Path.Internal.PartSystem.Path.RegularExpressionSystem.Path.ModificationTimeSystem.Path.Internal.PartClassSystem.Path.InternalSystemFilePathSystem.Path.Host System.PathSystem.DirectorygetDirectoryContentsbase System.IOprintghc-prim GHC.TypesIOGHC.IO.Handle.TypesHandlefixIOhPrinthReadyreadIOreadLninteract getContentsgetLinegetCharputStrLnputStrputCharGHC.IO.Handle.FDisEOFstderrstdin GHC.IO.HandlehShowhSetBinaryModehIsTerminalDevicehGetEchohSetEcho hIsSeekable hGetBuffering hIsWritable hIsReadable hIsClosedhIsOpenhTellhSeekhSetPosnhGetPosn hSetBuffering hLookAheadhIsEOF hSetFileSize hFileSizehClose HandlePosnGHC.IO.Handle.TexthGetBufNonBlockinghGetBufhPutBufNonBlockinghPutBuf hPutStrLnhPutStrhPutChar hGetContentshGetLinehGetChar hWaitForInputstdouthFlushBlockBuffering LineBuffering NoBuffering BufferMode GHC.IO.Device SeekFromEnd RelativeSeek AbsoluteSeekSeekMode GHC.IO.IOMode ReadWriteMode AppendMode WriteModeReadModeIOModedirectory-1.2.6.2 Permissions pathSeparatorpathSeparatorsisPathSeparator splitAbsolute canonicalize splitDrivegenDriveFileDirDirFileAbsRelRelAbs FileOrDirswitchFileOrDir switchFileDirAbsOrRelswitchAbsOrRel switchAbsRel FileDirPath AbsRelPathDirPathRelPathAbsPath AbsRelFileDir RelFileDir AbsFileDir AbsRelDir AbsRelFileRelDirAbsDirRelFileAbsFilePathpathMap withAbsRel withFileDirtoString getPathStringrootDir currentDir emptyFilemaybe maybePathparse parsePathpathrelFilerelDirabsFileabsDirrelabsabsRelfiledirfileDirrelPathabsPathfilePathdirPathidAbsRelidAbsidRel idFileDiridFileidDirasPath asRelFileasRelDir asAbsFileasAbsDir asRelPath asAbsPath asFilePath asDirPathmkPathAbsOrRelmkPathFileOrDir mkAbsPathmkAbsPathFromCwd<.><++> addExtensioncombine dropExtensiondropExtensions dropFileNamereplaceExtensionreplaceBaseNamereplaceDirectoryreplaceFileNamesplitExtensionsplitExtensions splitFileName splitDirName takeBaseName takeDirectorytakeSuperDirectory takeExtensiontakeExtensions takeFileName takeDirName mapFileName mapFileNameF equalFilePathjoinPath normalise splitPath makeRelativemakeRelativeMaybe makeAbsolutemakeAbsoluteFromCwddynamicMakeAbsolutedynamicMakeAbsoluteFromCwdgenericMakeAbsolutegenericMakeAbsoluteFromCwd dirFromFile fileFromDir toFileDir fromFileDirfileFromFileDirdirFromFileDir isAbsolute isRelativeisAbsoluteStringisRelativeStringhasAnExtension hasExtension extSeparatorsearchPathSeparatorisExtSeparatorisSearchPathSeparatorgenericAddExtensiongenericDropExtensiongenericDropExtensionsgenericSplitExtensiongenericSplitExtensionsgenericTakeExtensiongenericTakeExtensionsisValidtestAlladdTrailingPathSeparatordropTrailingPathSeparatorhasTrailingPathSeparator $fSystemPosix$fSystemWindowscreateDirectorycreateDirectoryIfMissingremoveDirectoryremoveDirectoryRecursiverenameDirectoryabsDirectoryContentsrelDirectoryContents filesInDir dirsInDirgetCurrentDirectorysetCurrentDirectorygetHomeDirectorygetAppUserDataDirectorygetUserDocumentsDirectorygetTemporaryDirectory removeFile renameFilecopyFilecanonicalizePathmakeRelativeToCurrentDirectoryfindExecutable doesFileExistdoesDirectoryExistgetPermissionssetPermissionsgetModificationTimewithFileopenFilereadFile writeFile appendFilewithBinaryFileopenBinaryFile openTempFileopenBinaryTempFile GenComponent PathComponentGenericAbsORelOabsPCemptyPC applyCompretagPCuntagPCfileMappcMappcMapF$fOrdPathComponent$fEqPathComponent$fNFDataPathComponent$fNFDataFileDir $fNFDataDir $fNFDataFile $fNFDataRel $fNFDataAbsParser-|-singlerun$fMonoidParser convertTimePrivate WrapFileDir unwrapFileDir WrapAbsRel unwrapAbsRelFuncArg runFuncArg switchDir switchFile switchRel switchAbsrelVardirVar withFileOrDirfdMap inspectAbsRelinspectFileDir$fOrdWrapFileDir$fEqWrapFileDir$fOrdWrapAbsRel$fEqWrapAbsRel$fDirDir $fFileFile$fFileOrDirDir$fFileOrDirFile$fFileDirFileDir $fFileDirDir $fFileDirFile$fRelRel$fAbsAbs $fAbsOrRelRel $fAbsOrRelAbs$fAbsRelAbsRel $fAbsRelRel $fAbsRelAbs$fPrivateFileDir $fPrivateDir $fPrivateFile$fPrivateAbsRel $fPrivateRel $fPrivateAbseitherFromAbsRel_eitherFromFileDirGHC.BaseStringmkPathAbsOrRelPrivNothingmakePathComponentsGHC.Errerror$fIsStringPath $fReadPath $fShowPathSplitExtensionrunSplitExtensionForbiddenFileDirForbiddenAbsRelForbiddenSystemforbiddenFromString inspectPathselTag mapFilePart mapFilePartF splitFilePart mapPathDirsshowsPrecTagged showsConsreadsPrecTagged skipSpaces readsConshandleMismatch matchStringreadsSplitDrivereadsSplitDriveAbsreadsSplitDriveRel toStringSprop_asPath_toString rootDirTaggedrootStringTagged atomicFilerootName currentNamecurrentDirComponent absDirName relPathName pathWithNamesarNamefdNamemkPathFromComponentsmaybePathFromComponentsarrangeComponentsmkPathComponentsnonEmptyComponents splitDriveOS splitDriveAbssplitAbsoluteOpathComponents(prop_mkPathFromComponents_pathComponentscombineOperatorprop_combine_currentDirprop_split_combineExtprop_split_combineprop_splitDir_combineprop_takeFileName_endprop_takeDirName_endmkPathAbsOrRelTagged maybeFileDir prop_makeAbsoluteFromDir_endSame"prop_makeAbsoluteFromDir_startSame fileFromAnyisDrivecomponentsAddExtensioncomponentsSplitExtensioncomponentsSplitExtensionsmapLast mapLastPairmapLastPairFoldrmapLastPairRecmapLastPairRev_prop_mapLastPairaddExtensionPCsplitExtensionPC_splitExtensionPCsplitExtensionsPC isValidTaggedisValidComponentisValidPathComponent quickCheckqcFileComponentqcDirComponentqcAbsRel qcGenPath qcFilePath qcDirPathqcPath$fArbitraryPath $fMonoidPath $fNFDataPath $fOrdPath$fEqPathPosix_osDummywithOSWindows driveRegExplainDirectoryContents