    bf(Operators:)
    itemization(
    itt(path &operator/=(Type const &arg)):nl()
       the arguments that can be passed to constructors can also be passed
        to this member. The tt(arg) argument is separated from the path's
        current content by a directory separator (unless the path is initially
        empty as in tt(cout << path{}.append("entry"))). See also the members
        tt(append) and tt(concat), below. The free operator tt(/) accepts two
        tt(path) (promotable) arguments, returning a tt(path) containing both
        paths separated by a directory separator (e.g., tt(lhs / rhs) returns
        the tt(path) object tt(lhs/rhs));

    itt(path &operator+=(Type const &arg)):nl()
       similar to tt(/=), but em(no) directory separator is used when
        adding tt(arg) to the current tt(path);

    it() comparison operators: tt(path) objects can be compared using the
        (operators implied by the) tt(==) and tt(<=>) operators. Path objects
        are compared by lexicographical comparing their ascii-character
        content;

    itt(ostream &operator<<(ostream &out, path const &path)) (stream
        insertion) inserts tt(path's) content, surrounded by double quotes,
        into tt(out);

    itt(istream &operator>>(istream &in, path &path)) extracts
        tt(path's) content from tt(in). The extracted path name may optionally
        be surrounded by double quotes. When inserting a previously extracted
        tt(path) object only one set of surrounding quotes are shown.
    )

    bf(Accessors:) 

    Accessors return specific tt(path) components. If a path doesn't contain
    the requested component then an empty tt(path) is returned.
    itemization(
    itt(char const *c_str()): the path's content is returned as an NTBS; 

    itt(path extension()) returns the dot-extension of the path's last
        component (including the dot);

    itt(path filename()) returns the last path-content of the current tt(path)
        object. See also the tt(stem()) accessor, below;

    itt(bool is_absolute()): returns tt(true) if the tt(path) object contains
        an absolute path specification;

    itt(bool is_relative()): returns tt(true) if the tt(path) object contains
        a relative path specification;

    itt(path parent_path()) returns the current path-content from which the
        last element has been removed. Note that if the tt(path) object
        contains a filename's path (like tt("/usr/bin/zip")) then
        tt(parent_path) removes tt(/zip) and returns tt(/usr/bin), so not
        tt(zip's) parent directory, but its actual directory;

    itt(path relative_path()): returns the path's content beyond
        the path's root-directory component of the tt(path) object. E.g., if
        the tt(path ulb{ "/usr/local/bin" }) is defined then
        tt(ulb.relative_path()) returns a path containing tt("usr/local/bin");

    itt(path root_directory()): returns the root-directory component of the
        tt(path) object;

    itt(path root_name()): returns the root-name's component of the tt(path)
        object;

    itt(path root_path()): returns the root-path component of the tt(path)
        object;

    itt(path stem()) returns the last path-content of the current tt(path)
        object from which the dot-extension hash been removed;

    itt(string()): returns the path's content as a tt(std::string).nl()
       Similar accessors are available for the following string-types:
        tt(wstring, u8string, u16string, , u32string, generic_string,
        generic_wstring, generic_u8string, generic_u16string,) and
        tt(generic_u32string);
    )

    Except for the family of tt(string()) and the tt(is_...) accessors, there
    are also tt(bool has_...) members returning tt(true) if the tt(path)
    contains the specified component (e.g., tt(has_extension) returns tt(true)
    if the tt(path) contains an extension).

    bf(Member functions:)
    itemization(
    itt(path &append(Type const &arg)) acts like the tt(/=) operator;
        
    itt(path::iterator begin()) returns an iterator containing the first path
        component; Dereferencing a tt(path::iterator) returns a tt(path)
        object.nl()
       When available root names and root directories are returned as initial
        components. When incrementing tt(path::iterators) the individual
        directories and finally filename components are returned. The
        directory separators themselves are not returned when dereferencing
        subsequent tt(path::iterators);

    itt(path::const_iterator begin() const) returns a iterator to the
        immutable first path component; Dereferencing a
        tt(path::const_iterator) returns a tt(path const) object;

    itt(void clear()): the tt(path's) content is erased;

    itt(int compare(Type const &other)):nl()
       returns the result of lexicographically comparing the current path's
        content with tt(other). tt(Other) can be a tt(path), a string-type or
        an NTBS;

    itt(path &concat(Type const &arg)) acts like the tt(+=) operator;

    itt(path::iterator end()) returns an iterator beyond the last path
        component;

    itt(path::const_iterator end() const) returns an iterator beyond the
        immutable last path component 

    itt(path &remove_filename()):nl()
       removes the last component of the stored path not ending in tt(/). If
        the tt(path) doesn't contain a slash then the tt(path) object's
        cleared;

    itt(path &replace_extension(path const &replacement = path{} )):nl()
       replaces the extension of the last component of the stored path
        (including the extension's dot) with tt(replacement). The extension is
        removed if tt(replacement) is empty. If the tt(path) calling
        tt(replace_extension) has no extension then tt(replacement) is added.
        The replacement may optionally start with a dot. The path object's
        extension receives only one dot;

    itt(path &replace_filename(path const &replacement)):nl()
       replaces the last component of the stored path with tt(replacement),
        which itself may contain multiple path elements.  If only a
        root-directory is stored, then it is replaced by tt(replacement). The
        member's behavior is undefined if the current path object is empty;
    )
