System.Path.Windows

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.

Documentation

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

asPath :: (AbsOrRel ar, FileOrDir fd) => String -> Path ar fd

Deprecated: Use maybePath, parsePath or path instead.

asRelFile :: String -> RelFile

Deprecated: Use relFile instead.

asRelDir :: String -> RelDir

Deprecated: Use relDir instead.

asAbsFile :: String -> AbsFile

Deprecated: Use absFile instead.

asAbsDir :: String -> AbsDir

Deprecated: Use absDir instead.

asRelPath :: FileOrDir fd => String -> RelPath fd

Deprecated: Use relPath instead.

asAbsPath :: FileOrDir fd => String -> AbsPath fd

Deprecated: Use absPath instead.

asFilePath :: AbsOrRel ar => String -> FilePath ar

Deprecated: Use filePath instead.

asDirPath :: AbsOrRel ar => String -> DirPath ar

Deprecated: Use dirPath instead.

path :: (AbsRel ar, FileDir fd) => String -> Path ar fd

maybe :: (AbsRel ar, FileDir fd) => String -> Maybe (Path ar fd)

maybePath :: (AbsRel ar, FileDir fd) => String -> Maybe (Path ar fd)

Deprecated: Use Path.maybe instead.

parse :: (AbsRel ar, FileDir fd) => String -> Either String (Path ar fd)

parsePath :: (AbsRel ar, FileDir fd) => String -> Either String (Path ar fd)

Deprecated: Use Path.parse instead.

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

isAbsoluteString :: String -> Bool

Deprecated: Use System.FilePath.isAbsolute instead.

isRelativeString :: String -> Bool

Deprecated: Use System.FilePath.isRelative instead.

equalFilePath :: String -> String -> Bool

Deprecated: Use System.FilePath.equalFilePath instead.

pathSeparator :: Char

pathSeparators :: [Char]

isPathSeparator :: Char -> Bool

extSeparator :: Char

Part.File extension character

> Posix.extSeparator == '.'

isExtSeparator :: Char -> Bool

Is the character an extension character?

> Posix.isExtSeparator a == (a == Posix.extSeparator)

searchPathSeparator :: Char

The character that is used to separate the entries in the $PATH environment variable.

isSearchPathSeparator :: Char -> Bool

Is the character a file separator?

> Posix.isSearchPathSeparator a == (a == Posix.searchPathSeparator)

addTrailingPathSeparator :: String -> String

Deprecated: Use System.FilePath.addTrailingPathSeparator instead.

This is largely for FilePath compatibility

dropTrailingPathSeparator :: String -> String

Deprecated: Use System.FilePath.dropTrailingPathSeparator instead.

This is largely for FilePath compatibility

hasTrailingPathSeparator :: String -> Bool

Deprecated: Use System.FilePath.hasTrailingPathSeparator instead.

This is largely for FilePath compatibility

testAll :: [(String, IO ())]