Convenience function that adds a string path.

Convenience function that adds two strings into a path.

Convert a path to the absolute path on the file system.
The overload on a plain string is necessary as it allows for unnormalized paths with ".." parts. For example "/foo/symlink/../test.txt" may resolve to "/bar/test.txt" if symlink is a symbolic link to a sub directory of "/bar".

Add two paths together using left-associative operator (/).
Keeps the root of p1 and discards the root name of p2.
"/a/" / "b/foo.txt" (===)std/core/sslice/(===): (slice1 : sslice, slice2 : sslice) -> bool "/a/b/foo.txt"
"/a/foo.txt" / "/b/bar.txt" (===)std/core/sslice/(===): (slice1 : sslice, slice2 : sslice) -> bool "/a/foo.txt/b/bar.txt"
"c:/foo" / "d:/bar" (===)std/core/sslice/(===): (slice1 : sslice, slice2 : sslice) -> bool "c:/foo/bar".

Return the first path if it is not empty, otherwise return the second one.

Return the path to the currently executing application.

Return the base directory that contains the currently running application. First tries app-pathstd/os/path/app-path: () -> io path().nobasestd/os/path/nobase: (p : path) -> path; if that ends in the bin or exe directory it returns the parent of that directory.

Return the base name of a path (stem name + extension)
"/foo/bar.txt".pathstd/os/path/path: (s : string) -> path.basenamestd/os/path/basename: (p : path) -> string (===)std/core/sslice/(===): (slice1 : sslice, slice2 : sslice) -> bool "bar.txt"
"/foo".pathstd/os/path/path: (s : string) -> path.basenamestd/os/path/basename: (p : path) -> string (===)std/core/sslice/(===): (slice1 : sslice, slice2 : sslice) -> bool "foo".

Change the base name of a path.

Change the extension of a path. Only adds a dot if the extname does not already start with a dot.

Change the stem name of a path.

Combine multiple paths using (/).

Returns the current working directory.
Equal to ".".realpath.

If a path has no extension, set it to the provided one.

Return the directory part of a path (including the rootname) "/foo/bar.txt".pathstd/os/path/path: (s : string) -> path.dirnamestd/os/path/dirname: (p : path) -> string (===)std/core/sslice/(===): (slice1 : sslice, slice2 : sslice) -> bool "/foo"
"/foo".pathstd/os/path/path: (s : string) -> path.dirnamestd/os/path/dirname: (p : path) -> string (===)std/core/sslice/(===): (slice1 : sslice, slice2 : sslice) -> bool "/".

Return a list of all directory components (excluding the root but including the basename).
"/foo/bar/test.txt".pathstd/os/path/path: (s : string) -> path.dirpartsstd/os/path/dirparts: (p : path) -> list<string> (===)std/core/sslice/(===): (slice1 : sslice, slice2 : sslice) -> bool ["foo","bar","test.txt"].

Return the extension of path (without the preceding dot ('.'))
"/foo/bar.svg.txt".pathstd/os/path/path: (s : string) -> path.extnamestd/os/path/extname: (p : path) -> string (===)std/core/sslice/(===): (slice1 : sslice, slice2 : sslice) -> bool "txt".

Return the home directory of the current user.

Is a path absolute?

Is a path empty?

Is a path relative?

Remove the basename and only keep the root and directory name portion of the path.
nobasestd/os/path/nobase: (p : path) -> path("foo/bar.ext".pathstd/os/path/path: (s : string) -> path) == "foo").

Remove the directory and root and only keep the base name (file name) portion of the path.
nodirstd/os/path/nodir: (p : path) -> path("foo/bar.ext".pathstd/os/path/path: (s : string) -> path) (===)std/core/sslice/(===): (slice1 : sslice, slice2 : sslice) -> bool "bar.ext".

Remove the extension from a path.

Return the last directory component name (or the empty string).
"c:/foo/bar/tst.txt".pathstd/os/path/path: (s : string) -> path.parentnamestd/os/path/parentname: (p : path) -> string (===)std/core/sslice/(===): (slice1 : sslice, slice2 : sslice) -> bool "bar".

Create a normalized pathstd/os/path/path: V from a path string.

Convert a path to the absolute path on the file system. The path is not required to exist on disk. However, if it exists any permissions and symbolic links are resolved fully.
".".realpath (to get the current working directory)
"/foo".realpath (to resolve the full root, like "c:/foo" on windows).

Return the root name of path. "c:\foo".pathstd/os/path/path: (s : string) -> path.rootnamestd/os/path/rootname: (p : path) -> string (===)std/core/sslice/(===): (slice1 : sslice, slice2 : sslice) -> bool "c:/"
"/foo".pathstd/os/path/path: (s : string) -> path.rootnamestd/os/path/rootname: (p : path) -> string (===)std/core/sslice/(===): (slice1 : sslice, slice2 : sslice) -> bool "/".

Show a path as a string.

Return the stem name of path.
"/foo/bar.svg.txt".pathstd/os/path/path: (s : string) -> path.extnamestd/os/path/extname: (p : path) -> string (===)std/core/sslice/(===): (slice1 : sslice, slice2 : sslice) -> bool "foo.svg".

Convert a pathstd/os/path/path: V to a normalized stringstd/core/types/string: V path.
If this results in an empty string, the current directory path "." is returned. "c:/foo/test.txt".pathstd/os/path/path: (s : string) -> path.string -> "c:/foo/test.txt"
"c:\foo\test.txt".pathstd/os/path/path: (s : string) -> path.string -> "c:/foo/test.txt"
"/foo//./bar/../test.txt".pathstd/os/path/path: (s : string) -> path.string -> "/foo/test.txt".

Return the temporary directory for the current user.