An absolute path.

The main Path type.

The type variable b is either:

• Abs -- absolute path
• Rel -- relative path

Internally is a ByteString. The path is guaranteed to be normalised and contain no trailing Path separators, except for the / root path.

There are no duplicate path separators //, no .., no ./, no ~/, etc.

A relative path; one without a root.

Exception when parsing a location.

Get a location for an absolute path. Produces a normalised path.

Throws: PathParseException

>>> parseAbs "/abc"          :: Maybe (Path Abs)
Just "/abc"
>>> parseAbs "/"             :: Maybe (Path Abs)
Just "/"
>>> parseAbs "/abc/def"      :: Maybe (Path Abs)
Just "/abc/def"
>>> parseAbs "/abc/def/.///" :: Maybe (Path Abs)
Just "/abc/def"
>>> parseAbs "abc"           :: Maybe (Path Abs)
Nothing
>>> parseAbs ""              :: Maybe (Path Abs)
Nothing
>>> parseAbs "/abc/../foo"   :: Maybe (Path Abs)
Nothing

Get a location for a relative path. Produces a normalised path.

Note that filepath may contain any number of ./ but may not consist solely of ./. It also may not contain a single .. anywhere.

Throws: PathParseException

>>> parseRel "abc"        :: Maybe (Path Rel)
Just "abc"
>>> parseRel "def/"       :: Maybe (Path Rel)
Just "def"
>>> parseRel "abc/def"    :: Maybe (Path Rel)
Just "abc/def"
>>> parseRel "abc/def/."  :: Maybe (Path Rel)
Just "abc/def"
>>> parseRel "/abc"       :: Maybe (Path Rel)
Nothing
>>> parseRel ""           :: Maybe (Path Rel)
Nothing
>>> parseRel "abc/../foo" :: Maybe (Path Rel)
Nothing
>>> parseRel "."          :: Maybe (Path Rel)
Nothing
>>> parseRel ".."         :: Maybe (Path Rel)
Nothing

Parses a path, whether it's relative or absolute. Will lose information on whether it's relative or absolute. If you need to know, reparse it.

Filenames must not contain slashes. Excludes . and '..'.

Throws: PathParseException

>>> parseAny "/abc"       :: Maybe (Either (Path Abs) (Path Rel))
Just (Left "/abc")
>>> parseAny "..."        :: Maybe (Either (Path Abs) (Path Rel))
Just (Right "...")
>>> parseAny "abc/def"    :: Maybe (Either (Path Abs) (Path Rel))
Just (Right "abc/def")
>>> parseAny "abc/def/."  :: Maybe (Either (Path Abs) (Path Rel))
Just (Right "abc/def")
>>> parseAny "/abc"       :: Maybe (Either (Path Abs) (Path Rel))
Just (Left "/abc")
>>> parseAny ""           :: Maybe (Either (Path Abs) (Path Rel))
Nothing
>>> parseAny "abc/../foo" :: Maybe (Either (Path Abs) (Path Rel))
Nothing
>>> parseAny "."          :: Maybe (Either (Path Abs) (Path Rel))
Nothing
>>> parseAny ".."         :: Maybe (Either (Path Abs) (Path Rel))
Nothing

Convert an absolute Path to a ByteString type.

Convert a relative Path to a ByteString type.

Convert any Path to a ByteString type.

Append two paths.

The second argument must always be a relative path, which ensures that undefinable things like `"abc" <> "/def"` cannot happen.

Technically, the first argument can be a path that points to a non-directory, because this library is IO-agnostic and makes no assumptions about file types.

>>> (MkPath "/")        </> (MkPath "file"     :: Path Rel)
"/file"
>>> (MkPath "/path/to") </> (MkPath "file"     :: Path Rel)
"/path/to/file"
>>> (MkPath "/")        </> (MkPath "file/lal" :: Path Rel)
"/file/lal"
>>> (MkPath "/")        </> (MkPath "file"    :: Path Rel)
"/file"

Extract the file part of a path.

The following properties hold:

basename (p </> a) == basename a

Throws: PathException if given the root path "/"

>>> basename (MkPath "/abc/def/dod") :: Maybe (Path Rel)
Just "dod"
>>> basename (MkPath "abc/def/dod")  :: Maybe (Path Rel)
Just "dod"
>>> basename (MkPath "dod")          :: Maybe (Path Rel)
Just "dod"
>>> basename (MkPath "/")            :: Maybe (Path Rel)
Nothing

Extract the directory name of a path.

>>> dirname (MkPath "/abc/def/dod")
"/abc/def"
>>> dirname (MkPath "/")
"/"

Get all parents of a path.

>>> getAllParents (MkPath "/abs/def/dod")
["/abs/def","/abs","/"]
>>> getAllParents (MkPath "/foo")
["/"]
>>> getAllParents (MkPath "/")
[]

Gets all path components.

>>> getAllComponents (MkPath "abs/def/dod")
["abs","def","dod"]
>>> getAllComponents (MkPath "abs")
["abs"]

Gets all path components after the "/" root directory.

>>> getAllComponentsAfterRoot (MkPath "/abs/def/dod")
["abs","def","dod"]
>>> getAllComponentsAfterRoot (MkPath "/abs")
["abs"]

Strip directory from path, making it relative to that directory. Throws Couldn'tStripPrefixDir if directory is not a parent of the path.

The bases must match.

>>> (MkPath "/lal/lad")     `stripDir` (MkPath "/lal/lad/fad") :: Maybe (Path Rel)
Just "fad"
>>> (MkPath "lal/lad")      `stripDir` (MkPath "lal/lad/fad")  :: Maybe (Path Rel)
Just "fad"
>>> (MkPath "/")            `stripDir` (MkPath "/")            :: Maybe (Path Rel)
Nothing
>>> (MkPath "/lal/lad/fad") `stripDir` (MkPath "/lal/lad")     :: Maybe (Path Rel)
Nothing
>>> (MkPath "fad")          `stripDir` (MkPath "fad")          :: Maybe (Path Rel)
Nothing

Is p a parent of the given location? Implemented in terms of stripDir. The bases must match.

>>> (MkPath "/lal/lad")     `isParentOf` (MkPath "/lal/lad/fad")
True
>>> (MkPath "lal/lad")      `isParentOf` (MkPath "lal/lad/fad")
True
>>> (MkPath "/")            `isParentOf` (MkPath "/")
False
>>> (MkPath "/lal/lad/fad") `isParentOf` (MkPath "/lal/lad")
False
>>> (MkPath "fad")          `isParentOf` (MkPath "fad")
False

Check whether the given Path is the root "/" path.

>>> isRootPath (MkPath "/lal/lad")
False
>>> isRootPath (MkPath "/")
True

Quasiquote an absolute Path. This accepts Unicode Chars and will encode as UTF-8.

>>> [abs|/etc/profile|] :: Path Abs
"/etc/profile"
>>> [abs|/|] :: Path Abs
"/"
>>> [abs|/|] :: Path Abs
"/\239\131\144"

Quasiquote a relative Path. This accepts Unicode Chars and will encode as UTF-8.

>>> [rel|etc|] :: Path Rel
"etc"
>>> [rel|bar/baz|] :: Path Rel
"bar/baz"
>>> [rel||] :: Path Rel
"\239\131\144"