-- Hoogle documentation, generated by Haddock -- See Hoogle, http://www.haskell.org/hoogle/ -- | Type-safe replacement for System.FilePath etc -- -- This package provides type-safe access to filepath manipulations. -- -- System.Path is designed to be used instead of -- System.FilePath. (It is intended to provide versions of -- functions from that module which have equivalent functionality but are -- more typesafe). System.Path.Directory is a companion module -- providing a type-safe alternative to System.Directory. -- -- The heart of this package is the Path ar fd abstract -- type which represents file and directory paths. The idea is that there -- are two type parameters - the first should be Abs or -- Rel, and the second File or Dir. A number of type -- synonyms are provided for common types: -- -- 
--   type Path.AbsFile = Path Abs File
--   type Path.RelFile = Path Rel File
--   type Path.AbsDir  = Path Abs Dir
--   type Path.RelDir  = Path Rel Dir
--   
--   type Path.Abs  fd = Path Abs fd
--   type Path.Rel  fd = Path Rel fd
--   type Path.File ar = Path ar File
--   type Path.Dir  ar = Path ar Dir
--
-- -- The type of the combine (aka </>) function gives -- the idea: -- -- 
--   (</>) :: Path.Dir ar -> Path.Rel fd -> Path ar fd
--
-- -- Together this enables us to give more meaningful types to a lot of the -- functions, and (hopefully) catch a bunch more errors at compile time. -- -- For more details see the README.md file. -- -- Related packages: -- -- @package pathtype @version 0.8.1 -- | This module provides type-safe access to filepath manipulations -- independent from the operating system. -- -- Normally you would import Path since this contains types fixed -- to your host system and otherwise generic functions. However, -- importing this explicitly allows for manipulation of non-native paths. module System.Path.Generic -- | This is the main filepath abstract datatype data Path os ar fd type AbsFile os = Path os Abs File type RelFile os = Path os Rel File type AbsDir os = Path os Abs Dir type RelDir os = Path os Rel Dir type AbsRelFile os = Path os AbsRel File type AbsRelDir os = Path os AbsRel Dir type AbsFileDir os = Path os Abs FileDir type RelFileDir os = Path os Rel FileDir type AbsRelFileDir os = Path os AbsRel FileDir -- | Deprecated: Use Path.Abs instead. type AbsPath os fd = Path os Abs fd type Abs os fd = Path os Abs fd -- | Deprecated: Use Path.Rel instead. type RelPath os fd = Path os Rel fd type Rel os fd = Path os Rel fd -- | Deprecated: Use Path.File instead. type FilePath os ar = Path os ar File type File os ar = Path os ar File -- | Deprecated: Use Path.Dir instead. type DirPath os ar = Path os ar Dir type Dir os ar = Path os ar Dir -- | Deprecated: Use Path.AbsRel instead. type AbsRelPath os fd = Path os AbsRel fd type AbsRel os fd = Path os AbsRel fd -- | Deprecated: Use Path.FileDir instead. type FileDirPath os ar = Path os ar FileDir type FileDir os ar = Path os ar FileDir withAbsRel :: (AbsRel ar) => (AbsPath os fd -> a) -> (RelPath os fd -> a) -> Path os ar fd -> a withFileDir :: (FileOrDir fd) => (FilePath os ar -> a) -> (DirPath os ar -> a) -> Path os ar fd -> a -- | Convert the Path into a plain String as required for OS -- calls. toString :: (System os, AbsRel ar, FileDir fd) => Path os ar fd -> String -- | Synonym of toString intended for unqualified use. -- | Deprecated: Use Path.toString instead. getPathString :: (System os, AbsRel ar, FileDir fd) => Path os ar fd -> String rootDir :: (System os) => AbsDir os currentDir :: (System os) => RelDir os -- | This is a file with path "". You will not be able to create a -- file with this name. We also forbid parsing "" by -- relFile. You might only need this file path as intermediate -- step when manipulating extensions of files like ".bashrc". emptyFile :: (System os) => RelFile os -- | This 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
--
-- | Deprecated: Use Path.maybe instead. maybePath :: (System os, AbsRel ar, FileDir fd) => String -> Maybe (Path os ar fd) -- | This 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
--
maybe :: (System os, AbsRel ar, FileDir fd) => String -> Maybe (Path os ar fd) -- | Deprecated: Use Path.parse instead. parsePath :: (System os, AbsRel ar, FileDir fd) => String -> Either String (Path os ar fd) parse :: (System os, AbsRel ar, FileDir fd) => String -> Either String (Path os ar fd) -- | This function is intended for converting path strings with known -- content, e.g. string literals, to the Path type. path :: (System os, AbsRel ar, FileDir fd) => String -> Path os ar fd -- | Construct a RelFile from a String. -- -- 
--   > Posix.toString (Posix.relFile "file.txt") == "file.txt"
--   > Posix.toString (Posix.relFile "tmp") == "tmp"
--
relFile :: (System os) => String -> RelFile os -- | Construct a RelDir from a String. -- -- 
--   > Posix.toString (Posix.relDir ".") == "."
--   > Posix.toString (Posix.relDir "file.txt") == "file.txt"
--   > Posix.toString (Posix.relDir "tmp") == "tmp"
--
relDir :: (System os) => String -> RelDir os -- | Construct an AbsFile from a String. -- -- 
--   > Posix.toString (Posix.absFile "/file.txt") == "/file.txt"
--   > Posix.toString (Posix.absFile "/tmp") == "/tmp"
--
absFile :: (System os) => String -> AbsFile os -- | Construct an AbsDir from a String. -- -- 
--   > Posix.toString (Posix.absDir "/file.txt") == "/file.txt"
--   > Posix.toString (Posix.absDir "/tmp") == "/tmp"
--
absDir :: (System os) => String -> AbsDir os -- | Construct a 'RelPath fd' from a String. -- | Deprecated: Use Path.rel instead. relPath :: (System os, FileDir fd) => String -> RelPath os fd -- | Construct a 'Rel fd' from a String. rel :: (System os, FileDir fd) => String -> Rel os fd -- | Construct an 'AbsPath fd' from a String. -- | Deprecated: Use Path.abs instead. absPath :: (System os, FileDir fd) => String -> AbsPath os fd -- | Construct an 'Abs fd' from a String. abs :: (System os, FileDir fd) => String -> Abs os fd -- | Construct a 'FilePath ar' from a String. -- | Deprecated: Use Path.file instead. filePath :: (System os, AbsRel ar) => String -> FilePath os ar -- | Construct a 'File ar' from a String. file :: (System os, AbsRel ar) => String -> File os ar -- | Construct a 'DirPath ar' from a String. -- | Deprecated: Use Path.dir instead. dirPath :: (System os, AbsRel ar) => String -> DirPath os ar -- | Construct a 'Dir ar' from a String. dir :: (System os, AbsRel ar) => String -> Dir os ar -- | Construct an 'AbsRel fd' from a String. absRel :: (System os, FileDir fd) => String -> AbsRel os fd -- | Construct a 'FileDir ar' from a String. fileDir :: (System os, AbsRel ar) => String -> FileDir os ar idAbsRel :: AbsRelPath os fd -> AbsRelPath os fd idAbs :: AbsPath os fd -> AbsPath os fd idRel :: RelPath os fd -> RelPath os fd idFileDir :: FileDirPath os fd -> FileDirPath os fd idFile :: FilePath os fd -> FilePath os fd idDir :: DirPath os fd -> DirPath os fd -- | Use a String as a Path 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 path. If you got the string as user input then use -- maybePath or parsePath. -- -- 
--   > 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"
--
-- | Deprecated: Use maybePath, parsePath or path -- instead. asPath :: (System os, AbsRel ar, FileDir fd) => String -> Path os ar fd -- | Use a String as a RelFile. 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"
--
-- | Deprecated: Use relFile instead. asRelFile :: (System os) => String -> RelFile os -- | Use a String as a RelDir. 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"
--
-- | Deprecated: Use relDir instead. asRelDir :: (System os) => String -> RelDir os -- | Use a String as an AbsFile. No checking is done. -- -- 
--   > Posix.toString (Posix.asAbsFile "/file.txt") == "/file.txt"
--   > Posix.toString (Posix.asAbsFile "/tmp") == "/tmp"
--
-- | Deprecated: Use absFile instead. asAbsFile :: (System os) => String -> AbsFile os -- | Use a String as an AbsDir. No checking is done. -- -- 
--   > Posix.toString (Posix.asAbsDir "/file.txt") == "/file.txt"
--   > Posix.toString (Posix.asAbsDir "/tmp") == "/tmp"
--
-- | Deprecated: Use absDir instead. asAbsDir :: (System os) => String -> AbsDir os -- | Use a String as a 'RelPath fd'. No checking is done. -- | Deprecated: Use relPath instead. asRelPath :: (System os, FileDir fd) => String -> RelPath os fd -- | Use a String as an 'AbsPath fd'. No checking is done. -- | Deprecated: Use absPath instead. asAbsPath :: (System os, FileDir fd) => String -> AbsPath os fd -- | Use a String as a 'FilePath ar'. No checking is done. -- | Deprecated: Use filePath instead. asFilePath :: (System os, AbsRel ar) => String -> FilePath os ar -- | Use a String as a 'DirPath ar'. No checking is done. -- | Deprecated: Use dirPath instead. asDirPath :: (System os, AbsRel ar) => String -> DirPath os ar -- | Examines the supplied string and constructs an absolute or relative -- path as appropriate. -- -- 
--   > 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")
--
-- | Deprecated: Use Path.absRel instead. mkPathAbsOrRel :: (System os, FileDir fd) => String -> Either (AbsPath os fd) (RelPath os fd) -- | Searches for a file or directory with the supplied path string and -- returns a File or Dir path as appropriate. If neither -- exists at the supplied path, Nothing is returned. -- | Deprecated: Don't let the path type depend on current file system -- content. Instead choose the path type according to the needed disk -- object type. mkPathFileOrDir :: (System os, AbsRel ar) => String -> IO (Maybe (Either (FilePath os ar) (DirPath os ar))) -- | Convert a String into an AbsPath 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"
--
-- | Deprecated: Use Path.dynamicMakeAbsolute instead. mkAbsPath :: (System os, FileDir fd) => AbsDir os -> String -> AbsPath os fd -- | Convert a String into an AbsPath by interpreting it as -- relative to the cwd if necessary. -- | Deprecated: Use Path.dynamicMakeAbsoluteFromCwd instead. mkAbsPathFromCwd :: (System os, FileDir fd) => String -> IO (AbsPath os fd) -- | Infix variant of combine. -- -- 
--   > 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"
--
() :: DirPath os ar -> RelPath os fd -> Path os ar fd infixr 5 -- | Infix variant of addExtension. 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: -- genericAddExtension. (<.>) :: FilePath os ar -> String -> FilePath os ar infixl 7 <.> (<++>) :: FilePath os ar -> String -> FilePath os ar infixl 7 <++> -- | 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"
--
addExtension :: FilePath os ar -> String -> FilePath os ar -- | Join an (absolute or relative) directory path with a relative (file or -- directory) path to form a new path. combine :: DirPath os ar -> RelPath os fd -> Path os ar fd -- | Remove last extension, and the "." preceding it. -- -- 
--   > Path.dropExtension x == fst (Path.splitExtension x)
--
dropExtension :: FilePath os ar -> FilePath os ar -- | Drop all extensions -- -- 
--   > not $ Path.hasAnExtension (Path.dropExtensions x)
--
dropExtensions :: FilePath os ar -> FilePath os ar -- | Synonym for takeDirectory dropFileName :: FilePath os ar -> DirPath os ar -- | 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"
--
replaceExtension :: FilePath os ar -> String -> FilePath os ar replaceBaseName :: FilePath os ar -> String -> FilePath os ar replaceDirectory :: FilePath os ar1 -> DirPath os ar2 -> FilePath os ar2 replaceFileName :: FilePath os ar -> String -> FilePath os ar -- | Split on the extension. addExtension 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")
--
splitExtension :: FilePath os ar -> (FilePath os ar, String) -- | Split on all extensions -- -- 
--   > Path.splitExtensions (relFile "file.tar.gz") == (Posix.relFile "file",".tar.gz")
--
splitExtensions :: FilePath os ar -> (FilePath os ar, String) splitFileName :: FilePath os ar -> (DirPath os ar, RelFile os) splitDirName :: DirPath os ar -> Maybe (DirPath os ar, RelDir os) -- | 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"
--
takeBaseName :: FilePath os ar -> RelFile os takeDirectory :: FilePath os ar -> DirPath os ar takeSuperDirectory :: DirPath os ar -> Maybe (DirPath os ar) -- | 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"
--
takeExtension :: FilePath os ar -> String -- | Get all extensions -- -- 
--   > Path.takeExtensions (Posix.relFile "file.tar.gz") == ".tar.gz"
--
takeExtensions :: FilePath os ar -> String -- | Get 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"
--
takeFileName :: FilePath os ar -> RelFile os takeDirName :: DirPath os ar -> Maybe (RelDir os) mapFileName :: (String -> String) -> FilePath os ar -> FilePath os ar mapFileNameF :: (Functor f) => (String -> f String) -> FilePath os ar -> f (FilePath os ar) -- | Check 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"
--
equalFilePath :: (System os) => Tagged os (String -> String -> Bool) -- | Constructs a RelPath from a list of components. It is an -- unchecked error if the path components contain path separators. It is -- an unchecked error if a RelFile 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"
--
joinPath :: (FileDir fd) => [String] -> RelPath os fd -- | Currently just transforms: -- -- 
--   > Path.normalise (absFile "/tmp/fred/./jim/./file") == Posix.absFile "/tmp/fred/jim/file"
--
normalise :: (System os) => Path os ar fd -> Path os ar fd -- | 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")
--
splitPath :: (AbsRel ar, FileOrDir fd) => Path os ar fd -> (Bool, [RelDir os], Maybe (RelFile os)) -- | This function can be used to construct a relative path by removing the -- supplied AbsDir from the front. It is a runtime error if -- the supplied AbsPath doesn't start with the AbsDir. -- -- 
--   > 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"
--
makeRelative :: (System os, FileDir fd) => AbsDir os -> AbsPath os fd -> RelPath os fd makeRelativeMaybe :: (System os, FileDir fd) => AbsDir os -> AbsPath os fd -> Maybe (RelPath os fd) -- | Joins 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"
--
makeAbsolute :: (System os) => AbsDir os -> RelPath os fd -> AbsPath os fd -- | Converts a relative path into an absolute one by prepending the -- current working directory. makeAbsoluteFromCwd :: (System os) => RelPath os fd -> IO (AbsPath os fd) dynamicMakeAbsolute :: (System os) => AbsDir os -> AbsRelPath os fd -> AbsPath os fd dynamicMakeAbsoluteFromCwd :: (System os) => AbsRelPath os fd -> IO (AbsPath os fd) -- | As for makeAbsolute, but for use when the path may already be -- absolute (in which case it is left unchanged). You should avoid the -- use of genericMakeAbsolute-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"
--
genericMakeAbsolute :: (System os, AbsRel ar) => AbsDir os -> Path os ar fd -> AbsPath os fd -- | As for makeAbsoluteFromCwd, but for use when the path may -- already be absolute (in which case it is left unchanged). genericMakeAbsoluteFromCwd :: (System os, AbsRel ar) => Path os ar fd -> IO (AbsPath os fd) -- | Map over the components of the path. -- -- 
--   > Path.pathMap (map toLower) (absDir "/tmp/Reports/SpreadSheets") == Posix.absDir "/tmp/reports/spreadsheets"
--
pathMap :: (FileDir fd) => (String -> String) -> Path os ar fd -> Path os ar fd -- | 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. dirFromFile :: FilePath os ar -> DirPath os ar -- | Convert a directory to a file path. The function returns -- Nothing 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. fileFromDir :: DirPath os ar -> Maybe (FilePath os ar) toFileDir :: (FileDir fd) => Path os ar fd -> FileDirPath os ar fromFileDir :: (FileDir fd) => FileDirPath os ar -> Maybe (Path os ar fd) fileFromFileDir :: FileDirPath os ar -> Maybe (FilePath os ar) dirFromFileDir :: FileDirPath os ar -> DirPath os ar toAbsRel :: (AbsRel ar) => Path os ar fd -> AbsRelPath os fd fromAbsRel :: (AbsRel ar) => AbsRelPath os fd -> Maybe (Path os ar fd) -- | Test whether a Path 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")
--
isAbsolute :: AbsRel ar => Path os ar fd -> Bool -- | Invariant - this should return True iff arg is of type Path -- Part.Rel _ -- -- 
--    isRelative = not . isAbsolute
--   > Path.isRelative (Posix.relFile "fred")
--   > Path.isRelative (Windows.relFile "fred")
--
isRelative :: AbsRel ar => Path os ar fd -> Bool -- | Test whether the String would correspond to an absolute path if -- interpreted as a Path. isAbsoluteString :: (System os) => Tagged os (String -> Bool) -- | Test whether the String would correspond to a relative path if -- interpreted as a Path. -- -- 
--   isRelativeString = not . isAbsoluteString
--
isRelativeString :: (System os) => Tagged os (String -> Bool) -- | Does the given filename have an extension? -- -- 
--   > null (Path.takeExtension x) == not (Path.hasAnExtension x)
--
hasAnExtension :: FilePath os ar -> Bool -- | Does 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")
--
hasExtension :: String -> FilePath os ar -> Bool class System os -- | The character that separates directories. In the case where more than -- one character is possible, pathSeparator is the 'ideal' one. -- -- 
--   > Posix.isPathSeparator Posix.pathSeparator
--
pathSeparator :: System os => Tagged os Char -- | The list of all possible separators. -- -- 
--   > Posix.pathSeparator `elem` Posix.pathSeparators
--
pathSeparators :: System os => Tagged os [Char] -- | Rather than using (== pathSeparator), use this. Test -- if something is a path separator. -- -- 
--   > Posix.isPathSeparator a == (a `elem` Posix.pathSeparators)
--
isPathSeparator :: System os => Tagged os (Char -> Bool) splitAbsolute :: System os => Tagged os (State String String) canonicalize :: System os => Tagged os (String -> String) splitDrive :: System os => Tagged os (State String String) genDrive :: System os => Tagged os (Gen String) -- | Part.File extension character -- -- 
--   > Posix.extSeparator == '.'
--
extSeparator :: Char -- | The character that is used to separate the entries in the $PATH -- environment variable. searchPathSeparator :: Char -- | Is the character an extension character? -- -- 
--   > Posix.isExtSeparator a == (a == Posix.extSeparator)
--
isExtSeparator :: Char -> Bool -- | Is the character a file separator? -- -- 
--   > Posix.isSearchPathSeparator a == (a == Posix.searchPathSeparator)
--
isSearchPathSeparator :: Char -> Bool -- | This is a more flexible variant of addExtension / -- <.> 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.emptyFile
--
genericAddExtension :: (FileDir fd) => Path os ar fd -> String -> Path os ar fd genericDropExtension :: (FileDir fd) => Path os ar fd -> Path os ar fd genericDropExtensions :: (FileDir fd) => Path os ar fd -> Path os ar fd genericSplitExtension :: (FileDir fd) => Path os ar fd -> (Path os ar fd, String) genericSplitExtensions :: (FileDir fd) => Path os ar fd -> (Path os ar fd, String) genericTakeExtension :: (FileDir fd) => Path os ar fd -> String genericTakeExtensions :: (FileDir fd) => Path os ar fd -> String testAll :: (System os) => os -> [(String, IO ())] -- | Check internal integrity of the path data structure. isValid :: (System os, AbsRel ar, FileDir fd) => Path os ar fd -> Bool class System os module System.Path.Part data Abs data Rel data AbsRel data File data Dir data FileDir module System.Path.PartClass -- | This class allows selective behaviour for absolute and relative paths -- and is mostly for internal use. class Private ar => AbsRel ar -- | See https://wiki.haskell.org/Closed_world_instances for the -- used technique. switchAbsRel :: AbsRel ar => f Abs -> f Rel -> f AbsRel -> f ar class AbsRel ar => AbsOrRel ar switchAbsOrRel :: AbsOrRel ar => f Abs -> f Rel -> f ar -- | This class allows selective behaviour for file and directory paths and -- is mostly for internal use. class Private fd => FileDir fd switchFileDir :: FileDir fd => f File -> f Dir -> f FileDir -> f fd class FileDir fd => FileOrDir fd switchFileOrDir :: FileOrDir fd => f File -> f Dir -> f fd -- | This module provides type-safe access to filepath manipulations. -- -- Normally you would import Path (which will use the default -- implementation for the host platform) instead of this. However, -- importing this explicitly allows for manipulation of non-native paths. module System.Path.Posix type Path = Path System type AbsFile = AbsFile System type RelFile = RelFile System type AbsDir = AbsDir System type RelDir = RelDir System type Abs fd = Abs System fd type Rel fd = Rel System fd type File ar = File System ar type Dir ar = Dir System ar type AbsRelFile = AbsRelFile System type AbsRelDir = AbsRelDir System type AbsFileDir = AbsFileDir System type RelFileDir = RelFileDir System type AbsRel fd = AbsRel System fd type FileDir ar = FileDir System ar type AbsRelFileDir = AbsRelFileDir System type AbsPath fd = AbsPath System fd type RelPath fd = RelPath System fd type FilePath ar = FilePath System ar type DirPath ar = DirPath System ar type AbsRelPath fd = AbsRelPath System fd type FileDirPath ar = FileDirPath System ar -- | Deprecated: Use maybePath, parsePath or path -- instead. asPath :: (AbsOrRel ar, FileOrDir fd) => String -> Path ar fd -- | Deprecated: Use relFile instead. asRelFile :: String -> RelFile -- | Deprecated: Use relDir instead. asRelDir :: String -> RelDir -- | Deprecated: Use absFile instead. asAbsFile :: String -> AbsFile -- | Deprecated: Use absDir instead. asAbsDir :: String -> AbsDir -- | Deprecated: Use relPath instead. asRelPath :: (FileOrDir fd) => String -> RelPath fd -- | Deprecated: Use absPath instead. asAbsPath :: (FileOrDir fd) => String -> AbsPath fd -- | Deprecated: Use filePath instead. asFilePath :: (AbsOrRel ar) => String -> FilePath ar -- | Deprecated: Use dirPath instead. asDirPath :: (AbsOrRel ar) => String -> DirPath ar path :: (AbsRel ar, FileDir fd) => String -> Path ar fd maybe :: (AbsRel ar, FileDir fd) => String -> Maybe (Path ar fd) -- | Deprecated: Use Path.maybe instead. maybePath :: (AbsRel ar, FileDir fd) => String -> Maybe (Path ar fd) parse :: (AbsRel ar, FileDir fd) => String -> Either String (Path ar fd) -- | Deprecated: Use Path.parse instead. parsePath :: (AbsRel ar, FileDir fd) => String -> Either String (Path ar fd) relFile :: String -> RelFile relDir :: String -> RelDir absFile :: String -> AbsFile absDir :: String -> AbsDir abs :: (FileDir fd) => String -> Abs fd rel :: (FileDir fd) => String -> Rel fd absRel :: (FileDir fd) => String -> AbsRel fd file :: (AbsRel ar) => String -> File ar dir :: (AbsRel ar) => String -> Dir ar fileDir :: (AbsRel ar) => String -> FileDir ar relPath :: (FileDir fd) => String -> RelPath fd absPath :: (FileDir fd) => String -> AbsPath fd filePath :: (AbsRel ar) => String -> FilePath ar dirPath :: (AbsRel ar) => String -> DirPath ar rootDir :: AbsDir currentDir :: RelDir emptyFile :: RelFile toString :: (AbsRel ar, FileDir fd) => Path ar fd -> String -- | Deprecated: Use System.FilePath.isAbsolute instead. isAbsoluteString :: String -> Bool -- | Deprecated: Use System.FilePath.isRelative instead. isRelativeString :: String -> Bool -- | Deprecated: Use System.FilePath.equalFilePath instead. equalFilePath :: String -> String -> Bool pathSeparator :: Char pathSeparators :: [Char] isPathSeparator :: Char -> Bool -- | Part.File extension character -- -- 
--   > Posix.extSeparator == '.'
--
extSeparator :: Char -- | Is the character an extension character? -- -- 
--   > Posix.isExtSeparator a == (a == Posix.extSeparator)
--
isExtSeparator :: Char -> Bool -- | The character that is used to separate the entries in the $PATH -- environment variable. searchPathSeparator :: Char -- | Is the character a file separator? -- -- 
--   > Posix.isSearchPathSeparator a == (a == Posix.searchPathSeparator)
--
isSearchPathSeparator :: Char -> Bool -- | This is largely for FilePath compatibility -- | Deprecated: Use System.FilePath.addTrailingPathSeparator -- instead. addTrailingPathSeparator :: String -> String -- | This is largely for FilePath compatibility -- | Deprecated: Use System.FilePath.dropTrailingPathSeparator -- instead. dropTrailingPathSeparator :: String -> String -- | This is largely for FilePath compatibility -- | Deprecated: Use System.FilePath.hasTrailingPathSeparator -- instead. hasTrailingPathSeparator :: String -> Bool testAll :: [(String, IO ())] instance System.Path.Internal.Part.System System.Path.Posix.Posix module System.Path -- | This module provides type-safe access to IO operations. -- -- It is designed to be imported instead of System.IO. (It is -- intended to provide versions of functions from that module which have -- equivalent functionality but are more typesafe). System.Path is -- a companion module providing a type-safe alternative to -- System.FilePath. -- -- You will typically want to import as follows: -- -- 
--   import Prelude hiding (FilePath)
--   import System.Path
--   import System.Path.Directory
--   import System.Path.IO
--
-- -- Ben Moseley - (c) 2009 module System.Path.IO withFile :: AbsRel ar => FilePath ar -> IOMode -> (Handle -> IO r) -> IO r openFile :: AbsRel ar => FilePath ar -> IOMode -> IO Handle readFile :: AbsRel ar => FilePath ar -> IO String writeFile :: AbsRel ar => FilePath ar -> String -> IO () appendFile :: AbsRel ar => FilePath ar -> String -> IO () withBinaryFile :: AbsRel ar => FilePath ar -> IOMode -> (Handle -> IO r) -> IO r openBinaryFile :: AbsRel ar => FilePath ar -> IOMode -> IO Handle openTempFile :: AbsRel ar => DirPath ar -> RelFile -> IO (AbsFile, Handle) openBinaryTempFile :: AbsRel ar => DirPath ar -> RelFile -> IO (AbsFile, Handle) -- | A value of type IO a is a computation which, when -- performed, does some I/O before returning a value of type a. -- -- There is really only one way to "perform" an I/O action: bind it to -- Main.main in your program. When your program is run, the I/O -- will be performed. It isn't possible to perform I/O from an arbitrary -- function, unless that function is itself in the IO monad and -- called at some point, directly or indirectly, from Main.main. -- -- IO is a monad, so IO actions can be combined using -- either the do-notation or the >> and >>= -- operations from the Monad class. data IO a :: * -> * fixIO :: () => (a -> IO a) -> IO a -- | Haskell defines operations to read and write characters from and to -- files, represented by values of type Handle. Each value of -- this type is a handle: a record used by the Haskell run-time -- system to manage I/O with file system objects. A handle has at -- least the following properties: -- -- -- -- Most handles will also have a current I/O position indicating where -- the next input or output operation will occur. A handle is -- readable if it manages only input or both input and output; -- likewise, it is writable if it manages only output or both -- input and output. A handle is open when first allocated. Once -- it is closed it can no longer be used for either input or output, -- though an implementation cannot re-use its storage while references -- remain to it. Handles are in the Show and Eq classes. -- The string produced by showing a handle is system dependent; it should -- include enough information to identify the handle for debugging. A -- handle is equal according to == only to itself; no attempt is -- made to compare the internal state of different handles for equality. data Handle :: * -- | A handle managing input from the Haskell program's standard input -- channel. stdin :: Handle -- | A handle managing output to the Haskell program's standard output -- channel. stdout :: Handle -- | A handle managing output to the Haskell program's standard error -- channel. stderr :: Handle -- | See openFile data IOMode :: * ReadMode :: IOMode WriteMode :: IOMode AppendMode :: IOMode ReadWriteMode :: IOMode -- | Computation hClose hdl makes handle hdl -- closed. Before the computation finishes, if hdl is writable -- its buffer is flushed as for hFlush. Performing hClose -- on a handle that has already been closed has no effect; doing so is -- not an error. All other operations on a closed handle will fail. If -- hClose fails for any reason, any further operations (apart from -- hClose) on the handle will still fail as if hdl had -- been successfully closed. hClose :: Handle -> IO () -- | For a handle hdl which attached to a physical file, -- hFileSize hdl returns the size of that file in 8-bit -- bytes. hFileSize :: Handle -> IO Integer -- | hSetFileSize hdl size truncates the physical -- file with handle hdl to size bytes. hSetFileSize :: Handle -> Integer -> IO () -- | For a readable handle hdl, hIsEOF hdl returns -- True if no further input can be taken from hdl or for -- a physical file, if the current I/O position is equal to the length of -- the file. Otherwise, it returns False. -- -- NOTE: hIsEOF may block, because it has to attempt to read from -- the stream to determine whether there is any more data to be read. hIsEOF :: Handle -> IO Bool -- | The computation isEOF is identical to hIsEOF, except -- that it works only on stdin. isEOF :: IO Bool -- | Three kinds of buffering are supported: line-buffering, -- block-buffering or no-buffering. These modes have the following -- effects. For output, items are written out, or flushed, from -- the internal buffer according to the buffer mode: -- -- -- -- An implementation is free to flush the buffer more frequently, but not -- less frequently, than specified above. The output buffer is emptied as -- soon as it has been written out. -- -- Similarly, input occurs according to the buffer mode for the handle: -- -- -- -- The default buffering mode when a handle is opened is -- implementation-dependent and may depend on the file system object -- which is attached to that handle. For most implementations, physical -- files will normally be block-buffered and terminals will normally be -- line-buffered. data BufferMode :: * -- | buffering is disabled if possible. NoBuffering :: BufferMode -- | line-buffering should be enabled if possible. LineBuffering :: BufferMode -- | block-buffering should be enabled if possible. The size of the buffer -- is n items if the argument is Just n and is -- otherwise implementation-dependent. BlockBuffering :: Maybe Int -> BufferMode -- | Computation hSetBuffering hdl mode sets the mode of -- buffering for handle hdl on subsequent reads and writes. -- -- If the buffer mode is changed from BlockBuffering or -- LineBuffering to NoBuffering, then -- -- -- -- This operation may fail with: -- -- hSetBuffering :: Handle -> BufferMode -> IO () -- | Computation hGetBuffering hdl returns the current -- buffering mode for hdl. hGetBuffering :: Handle -> IO BufferMode -- | The action hFlush hdl causes any items buffered for -- output in handle hdl to be sent immediately to the operating -- system. -- -- This operation may fail with: -- -- hFlush :: Handle -> IO () -- | Computation hGetPosn hdl returns the current I/O -- position of hdl as a value of the abstract type -- HandlePosn. hGetPosn :: Handle -> IO HandlePosn -- | If a call to hGetPosn hdl returns a position -- p, then computation hSetPosn p sets the -- position of hdl to the position it held at the time of the -- call to hGetPosn. -- -- This operation may fail with: -- -- hSetPosn :: HandlePosn -> IO () data HandlePosn :: * -- | Computation hSeek hdl mode i sets the position of -- handle hdl depending on mode. The offset i -- is given in terms of 8-bit bytes. -- -- If hdl is block- or line-buffered, then seeking to a position -- which is not in the current buffer will first cause any items in the -- output buffer to be written to the device, and then cause the input -- buffer to be discarded. Some handles may not be seekable (see -- hIsSeekable), or only support a subset of the possible -- positioning operations (for instance, it may only be possible to seek -- to the end of a tape, or to a positive offset from the beginning or -- current position). It is not possible to set a negative I/O position, -- or for a physical file, an I/O position beyond the current -- end-of-file. -- -- This operation may fail with: -- -- hSeek :: Handle -> SeekMode -> Integer -> IO () -- | A mode that determines the effect of hSeek hdl mode -- i. data SeekMode :: * -- | the position of hdl is set to i. AbsoluteSeek :: SeekMode -- | the position of hdl is set to offset i from the -- current position. RelativeSeek :: SeekMode -- | the position of hdl is set to offset i from the end -- of the file. SeekFromEnd :: SeekMode -- | Computation hTell hdl returns the current position of -- the handle hdl, as the number of bytes from the beginning of -- the file. The value returned may be subsequently passed to -- hSeek to reposition the handle to the current position. -- -- This operation may fail with: -- -- hTell :: Handle -> IO Integer hIsOpen :: Handle -> IO Bool hIsClosed :: Handle -> IO Bool hIsReadable :: Handle -> IO Bool hIsWritable :: Handle -> IO Bool hIsSeekable :: Handle -> IO Bool -- | Is the handle connected to a terminal? hIsTerminalDevice :: Handle -> IO Bool -- | Set the echoing status of a handle connected to a terminal. hSetEcho :: Handle -> Bool -> IO () -- | Get the echoing status of a handle connected to a terminal. hGetEcho :: Handle -> IO Bool -- | hShow is in the IO monad, and gives more comprehensive -- output than the (pure) instance of Show for Handle. hShow :: Handle -> IO String -- | Computation hWaitForInput hdl t waits until input is -- available on handle hdl. It returns True as soon as -- input is available on hdl, or False if no input is -- available within t milliseconds. Note that -- hWaitForInput waits until one or more full characters -- are available, which means that it needs to do decoding, and hence may -- fail with a decoding error. -- -- If t is less than zero, then hWaitForInput waits -- indefinitely. -- -- This operation may fail with: -- -- -- -- NOTE for GHC users: unless you use the -threaded flag, -- hWaitForInput hdl t where t >= 0 will block all -- other Haskell threads for the duration of the call. It behaves like a -- safe foreign call in this respect. hWaitForInput :: Handle -> Int -> IO Bool -- | Computation hReady hdl indicates whether at least one -- item is available for input from handle hdl. -- -- This operation may fail with: -- -- hReady :: Handle -> IO Bool -- | Computation hGetChar hdl reads a character from the -- file or channel managed by hdl, blocking until a character is -- available. -- -- This operation may fail with: -- -- hGetChar :: Handle -> IO Char -- | Computation hGetLine hdl reads a line from the file or -- channel managed by hdl. -- -- This operation may fail with: -- -- -- -- If hGetLine encounters end-of-file at any other point while -- reading in a line, it is treated as a line terminator and the -- (partial) line is returned. hGetLine :: Handle -> IO String -- | Computation hLookAhead returns the next character from the -- handle without removing it from the input buffer, blocking until a -- character is available. -- -- This operation may fail with: -- -- hLookAhead :: Handle -> IO Char -- | Computation hGetContents hdl returns the list of -- characters corresponding to the unread portion of the channel or file -- managed by hdl, which is put into an intermediate state, -- semi-closed. In this state, hdl is effectively closed, -- but items are read from hdl on demand and accumulated in a -- special list returned by hGetContents hdl. -- -- Any operation that fails because a handle is closed, also fails if a -- handle is semi-closed. The only exception is hClose. A -- semi-closed handle becomes closed: -- -- -- -- Once a semi-closed handle becomes closed, the contents of the -- associated list becomes fixed. The contents of this final list is only -- partially specified: it will contain at least all the items of the -- stream that were evaluated prior to the handle becoming closed. -- -- Any I/O errors encountered while a handle is semi-closed are simply -- discarded. -- -- This operation may fail with: -- -- hGetContents :: Handle -> IO String -- | Computation hPutChar hdl ch writes the character -- ch to the file or channel managed by hdl. Characters -- may be buffered if buffering is enabled for hdl. -- -- This operation may fail with: -- -- hPutChar :: Handle -> Char -> IO () -- | Computation hPutStr hdl s writes the string s -- to the file or channel managed by hdl. -- -- This operation may fail with: -- -- hPutStr :: Handle -> String -> IO () -- | The same as hPutStr, but adds a newline character. hPutStrLn :: Handle -> String -> IO () -- | Computation hPrint hdl t writes the string -- representation of t given by the shows function to the -- file or channel managed by hdl and appends a newline. -- -- This operation may fail with: -- -- hPrint :: Show a => Handle -> a -> IO () -- | The interact function takes a function of type -- String->String as its argument. The entire input from the -- standard input device is passed to this function as its argument, and -- the resulting string is output on the standard output device. interact :: (String -> String) -> IO () -- | Write a character to the standard output device (same as -- hPutChar stdout). putChar :: Char -> IO () -- | Write a string to the standard output device (same as hPutStr -- stdout). putStr :: String -> IO () -- | The same as putStr, but adds a newline character. putStrLn :: String -> IO () -- | The print function outputs a value of any printable type to the -- standard output device. Printable types are those that are instances -- of class Show; print converts values to strings for -- output using the show operation and adds a newline. -- -- For example, a program to print the first 20 integers and their powers -- of 2 could be written as: -- -- 
--   main = print ([(n, 2^n) | n <- [0..19]])
--
print :: Show a => a -> IO () -- | Read a character from the standard input device (same as -- hGetChar stdin). getChar :: IO Char -- | Read a line from the standard input device (same as hGetLine -- stdin). getLine :: IO String -- | The getContents operation returns all user input as a single -- string, which is read lazily as it is needed (same as -- hGetContents stdin). getContents :: IO String -- | The readIO function is similar to read except that it -- signals parse failure to the IO monad instead of terminating -- the program. readIO :: Read a => String -> IO a -- | The readLn function combines getLine and readIO. readLn :: Read a => IO a -- | Select binary mode (True) or text mode (False) on a open -- handle. (See also openBinaryFile.) -- -- This has the same effect as calling hSetEncoding with -- char8, together with hSetNewlineMode with -- noNewlineTranslation. hSetBinaryMode :: Handle -> Bool -> IO () -- | hPutBuf hdl buf count writes count 8-bit -- bytes from the buffer buf to the handle hdl. It -- returns (). -- -- hPutBuf ignores any text encoding that applies to the -- Handle, writing the bytes directly to the underlying file or -- device. -- -- hPutBuf ignores the prevailing TextEncoding and -- NewlineMode on the Handle, and writes bytes directly. -- -- This operation may fail with: -- -- hPutBuf :: () => Handle -> Ptr a -> Int -> IO () -- | hGetBuf hdl buf count reads data from the handle -- hdl into the buffer buf until either EOF is reached -- or count 8-bit bytes have been read. It returns the number of -- bytes actually read. This may be zero if EOF was reached before any -- data was read (or if count is zero). -- -- hGetBuf never raises an EOF exception, instead it returns a -- value smaller than count. -- -- If the handle is a pipe or socket, and the writing end is closed, -- hGetBuf will behave as if EOF was reached. -- -- hGetBuf ignores the prevailing TextEncoding and -- NewlineMode on the Handle, and reads bytes directly. hGetBuf :: () => Handle -> Ptr a -> Int -> IO Int hPutBufNonBlocking :: () => Handle -> Ptr a -> Int -> IO Int -- | hGetBufNonBlocking hdl buf count reads data from the -- handle hdl into the buffer buf until either EOF is -- reached, or count 8-bit bytes have been read, or there is no -- more data available to read immediately. -- -- hGetBufNonBlocking is identical to hGetBuf, except that -- it will never block waiting for data to become available, instead it -- returns only whatever data is available. To wait for data to arrive -- before calling hGetBufNonBlocking, use hWaitForInput. -- -- If the handle is a pipe or socket, and the writing end is closed, -- hGetBufNonBlocking will behave as if EOF was reached. -- -- hGetBufNonBlocking ignores the prevailing TextEncoding -- and NewlineMode on the Handle, and reads bytes directly. -- -- NOTE: on Windows, this function does not work correctly; it behaves -- identically to hGetBuf. hGetBufNonBlocking :: () => Handle -> Ptr a -> Int -> IO Int -- | This module provides type-safe access to directory manipulations. -- -- It is designed to be imported instead of System.Directory. (It -- is intended to provide versions of functions from that module which -- have equivalent functionality but are more typesafe). -- System.Path is a companion module providing a type-safe -- alternative to System.FilePath. -- -- You will typically want to import as follows: -- -- 
--   import Prelude hiding (FilePath)
--   import System.Path
--   import System.Path.Directory
--   import System.Path.IO
--
-- -- Ben Moseley - (c) 2009 module System.Path.Directory createDirectory :: AbsRel ar => DirPath ar -> IO () createDirectoryIfMissing :: AbsRel ar => Bool -> DirPath ar -> IO () removeDirectory :: AbsRel ar => DirPath ar -> IO () removeDirectoryRecursive :: AbsRel ar => DirPath ar -> IO () renameDirectory :: (AbsRel ar1, AbsRel ar2) => DirPath ar1 -> DirPath ar2 -> IO () -- | Retrieve the contents of a directory without any directory prefixes. -- In contrast to getDirectoryContents, exclude special -- directories "." and "..". getDirectoryContents :: AbsRel ar => DirPath ar -> IO [RelFileDir] -- | Retrieve the contents of a directory path (which may be relative) as -- absolute paths absDirectoryContents :: AbsRel ar => DirPath ar -> IO ([AbsDir], [AbsFile]) -- | Returns paths relative to the supplied (abs or relative) -- directory path. eg (for current working directory of -- /somewhere/cwd/): -- -- 
--   show (relDirectoryContents "d/e/f/") == (["subDir1A","subDir1B"],
--                                                        ["file1A","file1B"])
--
relDirectoryContents :: AbsRel ar => DirPath ar -> IO ([RelDir], [RelFile]) -- | A convenient alternative to relDirectoryContents if you only -- want files. filesInDir :: AbsRel ar => DirPath ar -> IO [RelFile] -- | A convenient alternative to relDirectoryContents if you only -- want directories. dirsInDir :: AbsRel ar => DirPath ar -> IO [RelDir] getCurrentDirectory :: IO AbsDir setCurrentDirectory :: AbsRel ar => DirPath ar -> IO () getHomeDirectory :: IO AbsDir getAppUserDataDirectory :: String -> IO AbsDir getUserDocumentsDirectory :: IO AbsDir getTemporaryDirectory :: IO AbsDir removeFile :: AbsRel ar => FilePath ar -> IO () renameFile :: (AbsRel ar1, AbsRel ar2) => FilePath ar1 -> FilePath ar2 -> IO () copyFile :: (AbsRel ar1, AbsRel ar2) => FilePath ar1 -> FilePath ar2 -> IO () canonicalizePath :: (AbsRel ar, FileDir fd) => Path ar fd -> IO (AbsPath fd) makeRelativeToCurrentDirectory :: (AbsRel ar, FileDir fd) => Path ar fd -> IO (RelPath fd) findExecutable :: String -> IO (Maybe AbsFile) doesFileExist :: AbsRel ar => FilePath ar -> IO Bool doesDirectoryExist :: AbsRel ar => DirPath ar -> IO Bool data Permissions :: * getPermissions :: (AbsRel ar, FileDir fd) => Path ar fd -> IO Permissions setPermissions :: (AbsRel ar, FileDir fd) => Path ar fd -> Permissions -> IO () getModificationTime :: (AbsRel ar, FileDir fd) => Path ar fd -> IO UTCTime -- | This module provides type-safe access to filepath manipulations. -- -- Normally you would import Path (which will use the default -- implementation for the host platform) instead of this. However, -- importing this explicitly allows for manipulation of non-native paths. module System.Path.Windows type Path = Path System type AbsFile = AbsFile System type RelFile = RelFile System type AbsDir = AbsDir System type RelDir = RelDir System type Abs fd = Abs System fd type Rel fd = Rel System fd type File ar = File System ar type Dir ar = Dir System ar type AbsRelFile = AbsRelFile System type AbsRelDir = AbsRelDir System type AbsFileDir = AbsFileDir System type RelFileDir = RelFileDir System type AbsRel fd = AbsRel System fd type FileDir ar = FileDir System ar type AbsRelFileDir = AbsRelFileDir System type AbsPath fd = AbsPath System fd type RelPath fd = RelPath System fd type FilePath ar = FilePath System ar type DirPath ar = DirPath System ar type AbsRelPath fd = AbsRelPath System fd type FileDirPath ar = FileDirPath System ar -- | Deprecated: Use maybePath, parsePath or path -- instead. asPath :: (AbsOrRel ar, FileOrDir fd) => String -> Path ar fd -- | Deprecated: Use relFile instead. asRelFile :: String -> RelFile -- | Deprecated: Use relDir instead. asRelDir :: String -> RelDir -- | Deprecated: Use absFile instead. asAbsFile :: String -> AbsFile -- | Deprecated: Use absDir instead. asAbsDir :: String -> AbsDir -- | Deprecated: Use relPath instead. asRelPath :: (FileOrDir fd) => String -> RelPath fd -- | Deprecated: Use absPath instead. asAbsPath :: (FileOrDir fd) => String -> AbsPath fd -- | Deprecated: Use filePath instead. asFilePath :: (AbsOrRel ar) => String -> FilePath ar -- | Deprecated: Use dirPath instead. asDirPath :: (AbsOrRel ar) => String -> DirPath ar path :: (AbsRel ar, FileDir fd) => String -> Path ar fd maybe :: (AbsRel ar, FileDir fd) => String -> Maybe (Path ar fd) -- | Deprecated: Use Path.maybe instead. maybePath :: (AbsRel ar, FileDir fd) => String -> Maybe (Path ar fd) parse :: (AbsRel ar, FileDir fd) => String -> Either String (Path ar fd) -- | Deprecated: Use Path.parse instead. parsePath :: (AbsRel ar, FileDir fd) => String -> Either String (Path ar fd) relFile :: String -> RelFile relDir :: String -> RelDir absFile :: String -> AbsFile absDir :: String -> AbsDir abs :: (FileDir fd) => String -> Abs fd rel :: (FileDir fd) => String -> Rel fd absRel :: (FileDir fd) => String -> AbsRel fd file :: (AbsRel ar) => String -> File ar dir :: (AbsRel ar) => String -> Dir ar fileDir :: (AbsRel ar) => String -> FileDir ar relPath :: (FileDir fd) => String -> RelPath fd absPath :: (FileDir fd) => String -> AbsPath fd filePath :: (AbsRel ar) => String -> FilePath ar dirPath :: (AbsRel ar) => String -> DirPath ar rootDir :: AbsDir currentDir :: RelDir emptyFile :: RelFile toString :: (AbsRel ar, FileDir fd) => Path ar fd -> String -- | Deprecated: Use System.FilePath.isAbsolute instead. isAbsoluteString :: String -> Bool -- | Deprecated: Use System.FilePath.isRelative instead. isRelativeString :: String -> Bool -- | Deprecated: Use System.FilePath.equalFilePath instead. equalFilePath :: String -> String -> Bool pathSeparator :: Char pathSeparators :: [Char] isPathSeparator :: Char -> Bool -- | Part.File extension character -- -- 
--   > Posix.extSeparator == '.'
--
extSeparator :: Char -- | Is the character an extension character? -- -- 
--   > Posix.isExtSeparator a == (a == Posix.extSeparator)
--
isExtSeparator :: Char -> Bool -- | The character that is used to separate the entries in the $PATH -- environment variable. searchPathSeparator :: Char -- | Is the character a file separator? -- -- 
--   > Posix.isSearchPathSeparator a == (a == Posix.searchPathSeparator)
--
isSearchPathSeparator :: Char -> Bool -- | This is largely for FilePath compatibility -- | Deprecated: Use System.FilePath.addTrailingPathSeparator -- instead. addTrailingPathSeparator :: String -> String -- | This is largely for FilePath compatibility -- | Deprecated: Use System.FilePath.dropTrailingPathSeparator -- instead. dropTrailingPathSeparator :: String -> String -- | This is largely for FilePath compatibility -- | Deprecated: Use System.FilePath.hasTrailingPathSeparator -- instead. hasTrailingPathSeparator :: String -> Bool testAll :: [(String, IO ())] instance System.Path.Internal.Part.System System.Path.Windows.Windows