Module

pooka/path

src/pooka/path.pooka

A path is a set of directions, not proof that the house exists.

Transform paths with the host runtime conventions. Normalization is lexical and does not resolve symbolic links. absolute and relative may fail while consulting the working directory; extensions include their leading dot.

import pooka/path

assert path.extension("notes.txt") == Some(".txt")

class

PathError

src/pooka/path.pooka:19

class PathError(message: String)

A path failure carrying the details needed by its caller. Keep this value in Result until a boundary can explain it.

field

message

src/pooka/path.pooka:19

message: String

INFERREDString

constructor

new

src/pooka/path.pooka:19

INFERREDfn(String) -> pooka/path.PathError

function

join

src/pooka/path.pooka:49

join(parts: List(String)) -> String

INFERREDfn(List(String)) -> String

Join path components using the host filename conventions. An empty list yields a dot.

import pooka/path

assert path.join([]) == "."

function

basename

src/pooka/path.pooka:60

basename(path: String) -> String

INFERREDfn(String) -> String

Return the final component of a path.

import pooka/path

assert path.basename("notes/oak.txt") == "oak.txt"

function

dirname

src/pooka/path.pooka:71

dirname(path: String) -> String

INFERREDfn(String) -> String

Return the path's parent component.

import pooka/path

assert path.dirname("notes/oak.txt") == "notes"

function

extension

src/pooka/path.pooka:82

extension(path: String) -> Option(String)

INFERREDfn(String) -> Option(String)

Return a leading-dot extension, or None when there is no suffix.

import pooka/path

assert path.extension("notes.txt") == Some(".txt")

function

stem

src/pooka/path.pooka:93

stem(path: String) -> String

INFERREDfn(String) -> String

Return the basename without its final extension.

import pooka/path

assert path.stem("notes.txt") == "notes"

function

is_absolute

src/pooka/path.pooka:104

is_absolute(path: String) -> Bool

INFERREDfn(String) -> Bool

Check the host runtime's absolute-path convention.

import pooka/path

let absolute = path.is_absolute("notes.txt")

function

is_relative

src/pooka/path.pooka:115

is_relative(path: String) -> Bool

INFERREDfn(String) -> Bool

Ask whether the host runtime considers the path relative.

import pooka/path

let relative = path.is_relative("notes.txt")

function

normalize

src/pooka/path.pooka:126

normalize(path: String) -> String

INFERREDfn(String) -> String

Normalize lexical components without resolving symbolic links.

import pooka/path

let normalized = path.normalize("notes/./oak.txt")

function

absolute

src/pooka/path.pooka:147

absolute(path: String) -> Result(String, PathError)

INFERREDfn(String) -> Result(String, pooka/path.PathError)

Resolve a relative path against the working directory without a filesystem existence check.

import pooka/path

let assert Ok(resolved) = path.absolute("notes.txt")

function

relative

src/pooka/path.pooka:158

relative(path: String, base: String) -> Result(String, PathError)

INFERREDfn(String, String) -> Result(String, pooka/path.PathError)

Find a lexical path from base to path after resolving their absolute forms.

import pooka/path

let assert Ok(relative) = path.relative("notes/oak.txt", "notes")