[fs.op.funcs] - C++20 → C++23

Files changed (1) hide show

tmp/tmp8fq4fmwp/{from.md → to.md} +131 -132

tmp/tmp8fq4fmwp/{from.md → to.md} RENAMED Viewed

@@ -1,21 +1,23 @@
 ### Filesystem operation functions <a id="fs.op.funcs">[[fs.op.funcs]]</a>
 Filesystem operation functions query or modify files, including
 directories, in external storage.
 [*Note 1*: Because hardware failures, network failures, file system
 races [[fs.race.behavior]], and many other kinds of errors occur
-frequently in file system operations, users should be aware that any
-filesystem operation function, no matter how apparently innocuous, may
-encounter an error; see  [[fs.err.report]]. — *end note*]
 #### Absolute <a id="fs.op.absolute">[[fs.op.absolute]]</a>
 ``` cpp
-path absolute(const path& p);
-path absolute(const path& p, error_code& ec);
 ```
 *Effects:* Composes an absolute path referencing the same file system
 location as `p` according to the operating system [[fs.conform.os]].
@@ -25,12 +27,12 @@ location as `p` according to the operating system [[fs.conform.os]].
 [*Note 1*: For the returned path, `rp`, `rp.is_absolute()` is `true`
 unless an error occurs. — *end note*]
 *Throws:* As specified in  [[fs.err.report]].
-[*Note 2*: To resolve symlinks, or perform other sanitization which
-might require queries to secondary storage, such as hard disks, consider
 `canonical` [[fs.op.canonical]]. — *end note*]
 [*Note 3*: Implementations are strongly encouraged to not query
 secondary storage, and not consider `!exists(p)` an
 error. — *end note*]
@@ -41,12 +43,12 @@ simply `current_path()/p`. For Windows-based operating systems,
 `GetFullPathNameW`. — *end example*]
 #### Canonical <a id="fs.op.canonical">[[fs.op.canonical]]</a>
 ``` cpp
-path canonical(const path& p);
-path canonical(const path& p, error_code& ec);
 ```
 *Effects:* Converts `p` to an absolute path that has no symbolic link,
 dot, or dot-dot elements in its pathname in the generic format.
@@ -59,24 +61,24 @@ error occurs.
 *Remarks:* `!exists(p)` is an error.
 #### Copy <a id="fs.op.copy">[[fs.op.copy]]</a>
 ``` cpp
-void copy(const path& from, const path& to);
 ```
 *Effects:* Equivalent to `copy(from, to, copy_options::none)`.
 ``` cpp
-void copy(const path& from, const path& to, error_code& ec);
 ```
 *Effects:* Equivalent to `copy(from, to, copy_options::none, ec)`.
 ``` cpp
-void copy(const path& from, const path& to, copy_options options);
-void copy(const path& from, const path& to, copy_options options,
           error_code& ec);
 ```
 *Preconditions:* At most one element from each option
 group [[fs.enum.copy.opts]] is set in `options`.
@@ -213,22 +215,22 @@ would result in:
 — *end example*]
 #### Copy file <a id="fs.op.copy.file">[[fs.op.copy.file]]</a>
 ``` cpp
-bool copy_file(const path& from, const path& to);
-bool copy_file(const path& from, const path& to, error_code& ec);
 ```
 *Returns:* `copy_file(from, to, copy_options::none)` or
 `copy_file(from, to, copy_options::none, ec)`, respectively.
 *Throws:* As specified in  [[fs.err.report]].
 ``` cpp
-bool copy_file(const path& from, const path& to, copy_options options);
-bool copy_file(const path& from, const path& to, copy_options options,
                error_code& ec);
 ```
 *Preconditions:* At most one element from each option
 group [[fs.enum.copy.opts]] is set in `options`.
@@ -263,12 +265,12 @@ signature with argument `ec` returns `false` if an error occurs.
 *Complexity:* At most one direct or indirect invocation of `status(to)`.
 #### Copy symlink <a id="fs.op.copy.symlink">[[fs.op.copy.symlink]]</a>
 ``` cpp
-void copy_symlink(const path& existing_symlink, const path& new_symlink);
-void copy_symlink(const path& existing_symlink, const path& new_symlink,
                   error_code& ec) noexcept;
 ```
 *Effects:* Equivalent to
 *`function`*`(read_symlink(existing_symlink), new_symlink)` or
@@ -279,12 +281,12 @@ respectively, where in each case *`function`* is `create_symlink` or
 *Throws:* As specified in  [[fs.err.report]].
 #### Create directories <a id="fs.op.create.directories">[[fs.op.create.directories]]</a>
 ``` cpp
-bool create_directories(const path& p);
-bool create_directories(const path& p, error_code& ec);
 ```
 *Effects:* Calls `create_directory()` for each element of `p` that does
 not exist.
@@ -296,12 +298,12 @@ resolves to, otherwise `false`.
 *Complexity:* 𝑂(n) where *n* is the number of elements of `p`.
 #### Create directory <a id="fs.op.create.directory">[[fs.op.create.directory]]</a>
 ``` cpp
-bool create_directory(const path& p);
-bool create_directory(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* Creates the directory `p` resolves to, as if by POSIX `mkdir`
 with a second argument of `static_cast<int>(perms::all)`. If `mkdir`
 fails because `p` resolves to an existing directory, no error is
@@ -310,12 +312,12 @@ reported. Otherwise on failure an error is reported.
 *Returns:* `true` if a new directory was created, otherwise `false`.
 *Throws:* As specified in  [[fs.err.report]].
 ``` cpp
-bool create_directory(const path& p, const path& existing_p);
-bool create_directory(const path& p, const path& existing_p, error_code& ec) noexcept;
 ```
 *Effects:* Creates the directory `p` resolves to, with attributes copied
 from directory `existing_p`. The set of attributes copied is operating
 system dependent. If `mkdir` fails because `p` resolves to an existing
@@ -335,12 +337,12 @@ from directory `existing_p`, otherwise `false`.
 *Throws:* As specified in  [[fs.err.report]].
 #### Create directory symlink <a id="fs.op.create.dir.symlk">[[fs.op.create.dir.symlk]]</a>
 ``` cpp
-void create_directory_symlink(const path& to, const path& new_symlink);
-void create_directory_symlink(const path& to, const path& new_symlink,
                               error_code& ec) noexcept;
 ```
 *Effects:* Establishes the postcondition, as if by POSIX `symlink()`.
@@ -348,24 +350,24 @@ void create_directory_symlink(const path& to, const path& new_symlink,
 an unspecified representation of `to`.
 *Throws:* As specified in  [[fs.err.report]].
 [*Note 1*: Some operating systems require symlink creation to identify
-that the link is to a directory. Portable code should use
-`create_directory_symlink()` to create directory symlinks rather than
-`create_symlink()` — *end note*]
 [*Note 2*: Some operating systems do not support symbolic links at all
 or support them only for regular files. Some file systems (such as the
 FAT file system) do not support symbolic links regardless of the
 operating system. — *end note*]
 #### Create hard link <a id="fs.op.create.hard.lk">[[fs.op.create.hard.lk]]</a>
 ``` cpp
-void create_hard_link(const path& to, const path& new_hard_link);
-void create_hard_link(const path& to, const path& new_hard_link,
                                       error_code& ec) noexcept;
 ```
 *Effects:* Establishes the postcondition, as if by POSIX `link()`.
@@ -383,12 +385,12 @@ system. Some file systems limit the number of links per
 file. — *end note*]
 #### Create symlink <a id="fs.op.create.symlink">[[fs.op.create.symlink]]</a>
 ``` cpp
-void create_symlink(const path& to, const path& new_symlink);
-void create_symlink(const path& to, const path& new_symlink,
                     error_code& ec) noexcept;
 ```
 *Effects:* Establishes the postcondition, as if by POSIX `symlink()`.
@@ -403,12 +405,12 @@ FAT file system) do not support symbolic links regardless of the
 operating system. — *end note*]
 #### Current path <a id="fs.op.current.path">[[fs.op.current.path]]</a>
 ``` cpp
-path current_path();
-path current_path(error_code& ec);
 ```
 *Returns:* The absolute path of the current working directory, whose
 pathname in the native format is obtained as if by POSIX `getcwd()`. The
 signature with argument `ec` returns `path()` if an error occurs.
@@ -422,61 +424,61 @@ resolution for relative paths.
 [*Note 1*: The `current_path()` name was chosen to emphasize that the
 returned value is a path, not just a single directory
 name. — *end note*]
 [*Note 2*: The current path as returned by many operating systems is a
-dangerous global variable. It may be changed unexpectedly by third-party
 or system library functions, or by another thread. — *end note*]
 ``` cpp
-void current_path(const path& p);
-void current_path(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* Establishes the postcondition, as if by POSIX `chdir()`.
 *Ensures:* `equivalent(p, current_path())`.
 *Throws:* As specified in  [[fs.err.report]].
 [*Note 3*: The current path for many operating systems is a dangerous
-global state. It may be changed unexpectedly by a third-party or system
 library functions, or by another thread. — *end note*]
 #### Equivalent <a id="fs.op.equivalent">[[fs.op.equivalent]]</a>
 ``` cpp
-bool equivalent(const path& p1, const path& p2);
-bool equivalent(const path& p1, const path& p2, error_code& ec) noexcept;
 ```
-*Returns:* `true`, if `p1` and `p2` resolve to the same file system
-entity, otherwise `false`. The signature with argument `ec` returns
-`false` if an error occurs.
 Two paths are considered to resolve to the same file system entity if
 two candidate entities reside on the same device at the same location.
 [*Note 1*: On POSIX platforms, this is determined as if by the values
 of the POSIX `stat` class, obtained as if by `stat()` for the two paths,
 having equal `st_dev` values and equal `st_ino` values. — *end note*]
 *Remarks:* `!exists(p1) || !exists(p2)` is an error.
-*Throws:* As specified in  [[fs.err.report]].
 #### Exists <a id="fs.op.exists">[[fs.op.exists]]</a>
 ``` cpp
-bool exists(file_status s) noexcept;
 ```
 *Returns:* `status_known(s) && s.type() != file_type::not_found`.
 ``` cpp
-bool exists(const path& p);
-bool exists(const path& p, error_code& ec) noexcept;
 ```
 Let `s` be a `file_status`, determined as if by `status(p)` or
 `status(p, ec)`, respectively.
@@ -488,12 +490,12 @@ Let `s` be a `file_status`, determined as if by `status(p)` or
 *Throws:* As specified in  [[fs.err.report]].
 #### File size <a id="fs.op.file.size">[[fs.op.file.size]]</a>
 ``` cpp
-uintmax_t file_size(const path& p);
-uintmax_t file_size(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* If `exists(p)` is `false`, an error is
 reported [[fs.err.report]].
@@ -510,30 +512,30 @@ an error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Hard link count <a id="fs.op.hard.lk.ct">[[fs.op.hard.lk.ct]]</a>
 ``` cpp
-uintmax_t hard_link_count(const path& p);
-uintmax_t hard_link_count(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* The number of hard links for `p`. The signature with argument
 `ec` returns `static_cast<uintmax_t>(-1)` if an error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is block file <a id="fs.op.is.block.file">[[fs.op.is.block.file]]</a>
 ``` cpp
-bool is_block_file(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::block`.
 ``` cpp
-bool is_block_file(const path& p);
-bool is_block_file(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_block_file(status(p))` or `is_block_file(status(p, ec))`,
 respectively. The signature with argument `ec` returns `false` if an
 error occurs.
@@ -541,18 +543,18 @@ error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is character file <a id="fs.op.is.char.file">[[fs.op.is.char.file]]</a>
 ``` cpp
-bool is_character_file(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::character`.
 ``` cpp
-bool is_character_file(const path& p);
-bool is_character_file(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_character_file(status(p))` or
 `is_character_file(status(p, ec))`, respectively.
 The signature with argument `ec` returns `false` if an error occurs.
@@ -560,18 +562,18 @@ The signature with argument `ec` returns `false` if an error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is directory <a id="fs.op.is.directory">[[fs.op.is.directory]]</a>
 ``` cpp
-bool is_directory(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::directory`.
 ``` cpp
-bool is_directory(const path& p);
-bool is_directory(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_directory(status(p))` or `is_directory(status(p, ec))`,
 respectively. The signature with argument `ec` returns `false` if an
 error occurs.
@@ -579,12 +581,12 @@ error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is empty <a id="fs.op.is.empty">[[fs.op.is.empty]]</a>
 ``` cpp
-bool is_empty(const path& p);
-bool is_empty(const path& p, error_code& ec);
 ```
 *Effects:*
 - Determine `file_status s`, as if by `status(p)` or `status(p, ec)`,
@@ -607,18 +609,18 @@ bool is_empty(const path& p, error_code& ec);
 *Throws:* As specified in  [[fs.err.report]].
 #### Is fifo <a id="fs.op.is.fifo">[[fs.op.is.fifo]]</a>
 ``` cpp
-bool is_fifo(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::fifo`.
 ``` cpp
-bool is_fifo(const path& p);
-bool is_fifo(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_fifo(status(p))` or `is_fifo(status(p, ec))`,
 respectively. The signature with argument `ec` returns `false` if an
 error occurs.
@@ -626,19 +628,19 @@ error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is other <a id="fs.op.is.other">[[fs.op.is.other]]</a>
 ``` cpp
-bool is_other(file_status s) noexcept;
 ```
 *Returns:*
 `exists(s) && !is_regular_file(s) && !is_directory(s) && !is_symlink(s)`.
 ``` cpp
-bool is_other(const path& p);
-bool is_other(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_other(status(p))` or `is_other(status(p, ec))`,
 respectively. The signature with argument `ec` returns `false` if an
 error occurs.
@@ -646,26 +648,26 @@ error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is regular file <a id="fs.op.is.regular.file">[[fs.op.is.regular.file]]</a>
 ``` cpp
-bool is_regular_file(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::regular`.
 ``` cpp
-bool is_regular_file(const path& p);
 ```
 *Returns:* `is_regular_file(status(p))`.
 *Throws:* `filesystem_error` if `status(p)` would throw
 `filesystem_error`.
 ``` cpp
-bool is_regular_file(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* Sets `ec` as if by `status(p, ec)`.
 [*Note 1*: `file_type::none`, `file_type::not_found` and
@@ -676,18 +678,18 @@ between cases, call the `status` function directly. — *end note*]
 occurs.
 #### Is socket <a id="fs.op.is.socket">[[fs.op.is.socket]]</a>
 ``` cpp
-bool is_socket(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::socket`.
 ``` cpp
-bool is_socket(const path& p);
-bool is_socket(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_socket(status(p))` or `is_socket(status(p, ec))`,
 respectively. The signature with argument `ec` returns `false` if an
 error occurs.
@@ -695,18 +697,18 @@ error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is symlink <a id="fs.op.is.symlink">[[fs.op.is.symlink]]</a>
 ``` cpp
-bool is_symlink(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::symlink`.
 ``` cpp
-bool is_symlink(const path& p);
-bool is_symlink(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_symlink(symlink_status(p))` or
 `is_symlink(symlink_status(p, ec))`, respectively. The signature with
 argument `ec` returns `false` if an error occurs.
@@ -714,74 +716,74 @@ argument `ec` returns `false` if an error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Last write time <a id="fs.op.last.write.time">[[fs.op.last.write.time]]</a>
 ``` cpp
-file_time_type last_write_time(const path& p);
-file_time_type last_write_time(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* The time of last data modification of `p`, determined as if
 by the value of the POSIX `stat` class member `st_mtime` obtained as if
 by POSIX `stat()`. The signature with argument `ec` returns
 `file_time_type::min()` if an error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 ``` cpp
-void last_write_time(const path& p, file_time_type new_time);
-void last_write_time(const path& p, file_time_type new_time,
                      error_code& ec) noexcept;
 ```
 *Effects:* Sets the time of last data modification of the file resolved
 to by `p` to `new_time`, as if by POSIX `futimens()`.
 *Throws:* As specified in  [[fs.err.report]].
 [*Note 1*: A postcondition of `last_write_time(p) == new_time` is not
-specified since it might not hold for file systems with coarse time
-granularity. — *end note*]
 #### Permissions <a id="fs.op.permissions">[[fs.op.permissions]]</a>
 ``` cpp
-void permissions(const path& p, perms prms, perm_options opts=perm_options::replace);
-void permissions(const path& p, perms prms, error_code& ec) noexcept;
-void permissions(const path& p, perms prms, perm_options opts, error_code& ec);
 ```
 *Preconditions:* Exactly one of the `perm_options` constants `replace`,
 `add`, or `remove` is present in `opts`.
-*Remarks:* The second signature behaves as if it had an additional
-parameter `perm_options` `opts` with an argument of
-`perm_options::replace`.
 *Effects:* Applies the action specified by `opts` to the file `p`
 resolves to, or to file `p` itself if `p` is a symbolic link and
 `perm_options::nofollow` is set in `opts`. The action is applied as if
 by POSIX `fchmodat()`.
 [*Note 1*: Conceptually permissions are viewed as bits, but the actual
-implementation may use some other mechanism. — *end note*]
 *Throws:* As specified in  [[fs.err.report]].
 #### Proximate <a id="fs.op.proximate">[[fs.op.proximate]]</a>
 ``` cpp
-path proximate(const path& p, error_code& ec);
 ```
 *Returns:* `proximate(p, current_path(), ec)`.
 *Throws:* As specified in  [[fs.err.report]].
 ``` cpp
-path proximate(const path& p, const path& base = current_path());
-path proximate(const path& p, const path& base, error_code& ec);
 ```
 *Returns:* For the first form:
 ``` cpp
@@ -799,12 +801,12 @@ or `path()` at the first error occurrence, if any.
 *Throws:* As specified in  [[fs.err.report]].
 #### Read symlink <a id="fs.op.read.symlink">[[fs.op.read.symlink]]</a>
 ``` cpp
-path read_symlink(const path& p);
-path read_symlink(const path& p, error_code& ec);
 ```
 *Returns:* If `p` resolves to a symbolic link, a `path` object
 containing the contents of that symbolic link. The signature with
 argument `ec` returns `path()` if an error occurs.
@@ -815,20 +817,20 @@ argument `ec` returns `path()` if an error occurs.
 link. — *end note*]
 #### Relative <a id="fs.op.relative">[[fs.op.relative]]</a>
 ``` cpp
-path relative(const path& p, error_code& ec);
 ```
 *Returns:* `relative(p, current_path(), ec)`.
 *Throws:* As specified in  [[fs.err.report]].
 ``` cpp
-path relative(const path& p, const path& base = current_path());
-path relative(const path& p, const path& base, error_code& ec);
 ```
 *Returns:* For the first form:
 ``` cpp
@@ -846,12 +848,12 @@ or `path()` at the first error occurrence, if any.
 *Throws:* As specified in  [[fs.err.report]].
 #### Remove <a id="fs.op.remove">[[fs.op.remove]]</a>
 ``` cpp
-bool remove(const path& p);
-bool remove(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* If `exists(symlink_status(p, ec))`, the file `p` is removed
 as if by POSIX `remove()`.
@@ -866,12 +868,12 @@ with argument `ec` returns `false` if an error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Remove all <a id="fs.op.remove.all">[[fs.op.remove.all]]</a>
 ``` cpp
-uintmax_t remove_all(const path& p);
-uintmax_t remove_all(const path& p, error_code& ec);
 ```
 *Effects:* Recursively deletes the contents of `p` if it exists, then
 deletes file `p` itself, as if by POSIX `remove()`.
@@ -886,25 +888,25 @@ returns `static_cast< uintmax_t>(-1)` if an error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Rename <a id="fs.op.rename">[[fs.op.rename]]</a>
 ``` cpp
-void rename(const path& old_p, const path& new_p);
-void rename(const path& old_p, const path& new_p, error_code& ec) noexcept;
 ```
 *Effects:* Renames `old_p` to `new_p`, as if by POSIX `rename()`.
 [*Note 1*:
 - If `old_p` and `new_p` resolve to the same existing file, no action is
   taken.
-- Otherwise, the rename may include the following effects:
   - if `new_p` resolves to an existing non-directory file, `new_p` is
     removed; otherwise,
   - if `new_p` resolves to an existing directory, `new_p` is removed if
-    empty on POSIX compliant operating systems but may be an error on
     other operating systems.
 A symbolic link is itself renamed, rather than the file it resolves to.
 — *end note*]
@@ -912,24 +914,24 @@ A symbolic link is itself renamed, rather than the file it resolves to.
 *Throws:* As specified in  [[fs.err.report]].
 #### Resize file <a id="fs.op.resize.file">[[fs.op.resize.file]]</a>
 ``` cpp
-void resize_file(const path& p, uintmax_t new_size);
-void resize_file(const path& p, uintmax_t new_size, error_code& ec) noexcept;
 ```
 *Effects:* Causes the size that would be returned by `file_size(p)` to
 be equal to `new_size`, as if by POSIX `truncate()`.
 *Throws:* As specified in  [[fs.err.report]].
 #### Space <a id="fs.op.space">[[fs.op.space]]</a>
 ``` cpp
-space_info space(const path& p);
-space_info space(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* An object of type `space_info`. The value of the `space_info`
 object is determined as if by using POSIX `statvfs` to obtain a POSIX
 `struct statvfs`, and then multiplying its `f_blocks`, `f_bfree`, and
@@ -942,16 +944,16 @@ members are set to `static_cast<uintmax_t>(-1)` if an error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 *Remarks:* The value of member `space_info::available` is operating
 system dependent.
-[*Note 1*: `available` may be less than `free`. — *end note*]
 #### Status <a id="fs.op.status">[[fs.op.status]]</a>
 ``` cpp
-file_status status(const path& p);
 ```
 *Effects:* As if:
 ``` cpp
@@ -969,11 +971,11 @@ return result;
 [*Note 1*: `result` values of `file_status(file_type::not_found)` and
 `file_status(file_type::unknown)` are not considered failures and do not
 cause an exception to be thrown. — *end note*]
 ``` cpp
-file_status status(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* If possible, determines the attributes of the file `p`
 resolves to, as if by using POSIX `stat()` to obtain a POSIX
 `struct stat`. If, during attribute determination, the underlying file
@@ -1034,20 +1036,20 @@ determined as if by converting the `st_mode` member of the obtained
 pathname resolution continues using the contents of the symbolic link.
 #### Status known <a id="fs.op.status.known">[[fs.op.status.known]]</a>
 ``` cpp
-bool status_known(file_status s) noexcept;
 ```
 *Returns:* `s.type() != file_type::none`.
 #### Symlink status <a id="fs.op.symlink.status">[[fs.op.symlink.status]]</a>
 ``` cpp
-file_status symlink_status(const path& p);
-file_status symlink_status(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* Same as `status()`, above, except that the attributes of `p`
 are determined as if by using POSIX `lstat()` to obtain a POSIX
 `struct stat`.
@@ -1059,19 +1061,19 @@ determined as if by converting the `st_mode` member of the obtained
 *Returns:* Same as `status()`, above, except that if the attributes
 indicate a symbolic link, as if by POSIX `S_ISLNK`, returns
 `file_status(file_type::symlink, prms)`. The signature with argument
 `ec` returns `file_status(file_type::none)` if an error occurs.
 *Remarks:* Pathname resolution terminates if `p` names a symbolic link.
-*Throws:* As specified in  [[fs.err.report]].
 #### Temporary directory path <a id="fs.op.temp.dir.path">[[fs.op.temp.dir.path]]</a>
 ``` cpp
-path temp_directory_path();
-path temp_directory_path(error_code& ec);
 ```
 Let `p` be an unspecified directory path suitable for temporary files.
 *Effects:* If `exists(p)` is `false` or `is_directory(p)` is `false`, an
@@ -1090,17 +1092,14 @@ return the path reported by the Windows `GetTempPath` API
 function. — *end example*]
 #### Weakly canonical <a id="fs.op.weakly.canonical">[[fs.op.weakly.canonical]]</a>
 ``` cpp
-path weakly_canonical(const path& p);
-path weakly_canonical(const path& p, error_code& ec);
 ```
-*Returns:* `p` with symlinks resolved and the result
-normalized [[fs.path.generic]].
 *Effects:* Using `status(p)` or `status(p, ec)`, respectively, to
 determine existence, return a path composed by `operator/=` from the
 result of calling `canonical()` with a path argument composed of the
 leading elements of `p` that exist, if any, followed by the elements of
 `p` that do not exist, if any. For the first form, `canonical()` is
@@ -1108,10 +1107,10 @@ called without an `error_code` argument. For the second form,
 `canonical()` is called with `ec` as an `error_code` argument, and
 `path()` is returned at the first error occurrence, if any.
 *Ensures:* The returned path is in normal form [[fs.path.generic]].
-*Remarks:* Implementations should avoid unnecessary normalization such
-as when `canonical` has already been called on the entirety of `p`.
 *Throws:* As specified in  [[fs.err.report]].

 ### Filesystem operation functions <a id="fs.op.funcs">[[fs.op.funcs]]</a>
+#### General <a id="fs.op.funcs.general">[[fs.op.funcs.general]]</a>
 Filesystem operation functions query or modify files, including
 directories, in external storage.
 [*Note 1*: Because hardware failures, network failures, file system
 races [[fs.race.behavior]], and many other kinds of errors occur
+frequently in file system operations, any filesystem operation function,
+no matter how apparently innocuous, can encounter an error; see
+[[fs.err.report]]. — *end note*]
 #### Absolute <a id="fs.op.absolute">[[fs.op.absolute]]</a>
 ``` cpp
+path filesystem::absolute(const path& p);
+path filesystem::absolute(const path& p, error_code& ec);
 ```
 *Effects:* Composes an absolute path referencing the same file system
 location as `p` according to the operating system [[fs.conform.os]].
 [*Note 1*: For the returned path, `rp`, `rp.is_absolute()` is `true`
 unless an error occurs. — *end note*]
 *Throws:* As specified in  [[fs.err.report]].
+[*Note 2*: To resolve symlinks or perform other sanitization that can
+involve queries to secondary storage, such as hard disks, consider
 `canonical` [[fs.op.canonical]]. — *end note*]
 [*Note 3*: Implementations are strongly encouraged to not query
 secondary storage, and not consider `!exists(p)` an
 error. — *end note*]
 `GetFullPathNameW`. — *end example*]
 #### Canonical <a id="fs.op.canonical">[[fs.op.canonical]]</a>
 ``` cpp
+path filesystem::canonical(const path& p);
+path filesystem::canonical(const path& p, error_code& ec);
 ```
 *Effects:* Converts `p` to an absolute path that has no symbolic link,
 dot, or dot-dot elements in its pathname in the generic format.
 *Remarks:* `!exists(p)` is an error.
 #### Copy <a id="fs.op.copy">[[fs.op.copy]]</a>
 ``` cpp
+void filesystem::copy(const path& from, const path& to);
 ```
 *Effects:* Equivalent to `copy(from, to, copy_options::none)`.
 ``` cpp
+void filesystem::copy(const path& from, const path& to, error_code& ec);
 ```
 *Effects:* Equivalent to `copy(from, to, copy_options::none, ec)`.
 ``` cpp
+void filesystem::copy(const path& from, const path& to, copy_options options);
+void filesystem::copy(const path& from, const path& to, copy_options options,
           error_code& ec);
 ```
 *Preconditions:* At most one element from each option
 group [[fs.enum.copy.opts]] is set in `options`.
 — *end example*]
 #### Copy file <a id="fs.op.copy.file">[[fs.op.copy.file]]</a>
 ``` cpp
+bool filesystem::copy_file(const path& from, const path& to);
+bool filesystem::copy_file(const path& from, const path& to, error_code& ec);
 ```
 *Returns:* `copy_file(from, to, copy_options::none)` or
 `copy_file(from, to, copy_options::none, ec)`, respectively.
 *Throws:* As specified in  [[fs.err.report]].
 ``` cpp
+bool filesystem::copy_file(const path& from, const path& to, copy_options options);
+bool filesystem::copy_file(const path& from, const path& to, copy_options options,
                error_code& ec);
 ```
 *Preconditions:* At most one element from each option
 group [[fs.enum.copy.opts]] is set in `options`.
 *Complexity:* At most one direct or indirect invocation of `status(to)`.
 #### Copy symlink <a id="fs.op.copy.symlink">[[fs.op.copy.symlink]]</a>
 ``` cpp
+void filesystem::copy_symlink(const path& existing_symlink, const path& new_symlink);
+void filesystem::copy_symlink(const path& existing_symlink, const path& new_symlink,
                   error_code& ec) noexcept;
 ```
 *Effects:* Equivalent to
 *`function`*`(read_symlink(existing_symlink), new_symlink)` or
 *Throws:* As specified in  [[fs.err.report]].
 #### Create directories <a id="fs.op.create.directories">[[fs.op.create.directories]]</a>
 ``` cpp
+bool filesystem::create_directories(const path& p);
+bool filesystem::create_directories(const path& p, error_code& ec);
 ```
 *Effects:* Calls `create_directory()` for each element of `p` that does
 not exist.
 *Complexity:* 𝑂(n) where *n* is the number of elements of `p`.
 #### Create directory <a id="fs.op.create.directory">[[fs.op.create.directory]]</a>
 ``` cpp
+bool filesystem::create_directory(const path& p);
+bool filesystem::create_directory(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* Creates the directory `p` resolves to, as if by POSIX `mkdir`
 with a second argument of `static_cast<int>(perms::all)`. If `mkdir`
 fails because `p` resolves to an existing directory, no error is
 *Returns:* `true` if a new directory was created, otherwise `false`.
 *Throws:* As specified in  [[fs.err.report]].
 ``` cpp
+bool filesystem::create_directory(const path& p, const path& existing_p);
+bool filesystem::create_directory(const path& p, const path& existing_p, error_code& ec) noexcept;
 ```
 *Effects:* Creates the directory `p` resolves to, with attributes copied
 from directory `existing_p`. The set of attributes copied is operating
 system dependent. If `mkdir` fails because `p` resolves to an existing
 *Throws:* As specified in  [[fs.err.report]].
 #### Create directory symlink <a id="fs.op.create.dir.symlk">[[fs.op.create.dir.symlk]]</a>
 ``` cpp
+void filesystem::create_directory_symlink(const path& to, const path& new_symlink);
+void filesystem::create_directory_symlink(const path& to, const path& new_symlink,
                               error_code& ec) noexcept;
 ```
 *Effects:* Establishes the postcondition, as if by POSIX `symlink()`.
 an unspecified representation of `to`.
 *Throws:* As specified in  [[fs.err.report]].
 [*Note 1*: Some operating systems require symlink creation to identify
+that the link is to a directory. Thus, `create_symlink()` (instead of
+`create_directory_symlink()`) cannot be used reliably to create
+directory symlinks. — *end note*]
 [*Note 2*: Some operating systems do not support symbolic links at all
 or support them only for regular files. Some file systems (such as the
 FAT file system) do not support symbolic links regardless of the
 operating system. — *end note*]
 #### Create hard link <a id="fs.op.create.hard.lk">[[fs.op.create.hard.lk]]</a>
 ``` cpp
+void filesystem::create_hard_link(const path& to, const path& new_hard_link);
+void filesystem::create_hard_link(const path& to, const path& new_hard_link,
                                       error_code& ec) noexcept;
 ```
 *Effects:* Establishes the postcondition, as if by POSIX `link()`.
 file. — *end note*]
 #### Create symlink <a id="fs.op.create.symlink">[[fs.op.create.symlink]]</a>
 ``` cpp
+void filesystem::create_symlink(const path& to, const path& new_symlink);
+void filesystem::create_symlink(const path& to, const path& new_symlink,
                     error_code& ec) noexcept;
 ```
 *Effects:* Establishes the postcondition, as if by POSIX `symlink()`.
 operating system. — *end note*]
 #### Current path <a id="fs.op.current.path">[[fs.op.current.path]]</a>
 ``` cpp
+path filesystem::current_path();
+path filesystem::current_path(error_code& ec);
 ```
 *Returns:* The absolute path of the current working directory, whose
 pathname in the native format is obtained as if by POSIX `getcwd()`. The
 signature with argument `ec` returns `path()` if an error occurs.
 [*Note 1*: The `current_path()` name was chosen to emphasize that the
 returned value is a path, not just a single directory
 name. — *end note*]
 [*Note 2*: The current path as returned by many operating systems is a
+dangerous global variable and can be changed unexpectedly by third-party
 or system library functions, or by another thread. — *end note*]
 ``` cpp
+void filesystem::current_path(const path& p);
+void filesystem::current_path(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* Establishes the postcondition, as if by POSIX `chdir()`.
 *Ensures:* `equivalent(p, current_path())`.
 *Throws:* As specified in  [[fs.err.report]].
 [*Note 3*: The current path for many operating systems is a dangerous
+global state and can be changed unexpectedly by third-party or system
 library functions, or by another thread. — *end note*]
 #### Equivalent <a id="fs.op.equivalent">[[fs.op.equivalent]]</a>
 ``` cpp
+bool filesystem::equivalent(const path& p1, const path& p2);
+bool filesystem::equivalent(const path& p1, const path& p2, error_code& ec) noexcept;
 ```
 Two paths are considered to resolve to the same file system entity if
 two candidate entities reside on the same device at the same location.
 [*Note 1*: On POSIX platforms, this is determined as if by the values
 of the POSIX `stat` class, obtained as if by `stat()` for the two paths,
 having equal `st_dev` values and equal `st_ino` values. — *end note*]
+*Returns:* `true`, if `p1` and `p2` resolve to the same file system
+entity, otherwise `false`. The signature with argument `ec` returns
+`false` if an error occurs.
+*Throws:* As specified in  [[fs.err.report]].
 *Remarks:* `!exists(p1) || !exists(p2)` is an error.
 #### Exists <a id="fs.op.exists">[[fs.op.exists]]</a>
 ``` cpp
+bool filesystem::exists(file_status s) noexcept;
 ```
 *Returns:* `status_known(s) && s.type() != file_type::not_found`.
 ``` cpp
+bool filesystem::exists(const path& p);
+bool filesystem::exists(const path& p, error_code& ec) noexcept;
 ```
 Let `s` be a `file_status`, determined as if by `status(p)` or
 `status(p, ec)`, respectively.
 *Throws:* As specified in  [[fs.err.report]].
 #### File size <a id="fs.op.file.size">[[fs.op.file.size]]</a>
 ``` cpp
+uintmax_t filesystem::file_size(const path& p);
+uintmax_t filesystem::file_size(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* If `exists(p)` is `false`, an error is
 reported [[fs.err.report]].
 *Throws:* As specified in  [[fs.err.report]].
 #### Hard link count <a id="fs.op.hard.lk.ct">[[fs.op.hard.lk.ct]]</a>
 ``` cpp
+uintmax_t filesystem::hard_link_count(const path& p);
+uintmax_t filesystem::hard_link_count(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* The number of hard links for `p`. The signature with argument
 `ec` returns `static_cast<uintmax_t>(-1)` if an error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is block file <a id="fs.op.is.block.file">[[fs.op.is.block.file]]</a>
 ``` cpp
+bool filesystem::is_block_file(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::block`.
 ``` cpp
+bool filesystem::is_block_file(const path& p);
+bool filesystem::is_block_file(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_block_file(status(p))` or `is_block_file(status(p, ec))`,
 respectively. The signature with argument `ec` returns `false` if an
 error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is character file <a id="fs.op.is.char.file">[[fs.op.is.char.file]]</a>
 ``` cpp
+bool filesystem::is_character_file(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::character`.
 ``` cpp
+bool filesystem::is_character_file(const path& p);
+bool filesystem::is_character_file(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_character_file(status(p))` or
 `is_character_file(status(p, ec))`, respectively.
 The signature with argument `ec` returns `false` if an error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is directory <a id="fs.op.is.directory">[[fs.op.is.directory]]</a>
 ``` cpp
+bool filesystem::is_directory(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::directory`.
 ``` cpp
+bool filesystem::is_directory(const path& p);
+bool filesystem::is_directory(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_directory(status(p))` or `is_directory(status(p, ec))`,
 respectively. The signature with argument `ec` returns `false` if an
 error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is empty <a id="fs.op.is.empty">[[fs.op.is.empty]]</a>
 ``` cpp
+bool filesystem::is_empty(const path& p);
+bool filesystem::is_empty(const path& p, error_code& ec);
 ```
 *Effects:*
 - Determine `file_status s`, as if by `status(p)` or `status(p, ec)`,
 *Throws:* As specified in  [[fs.err.report]].
 #### Is fifo <a id="fs.op.is.fifo">[[fs.op.is.fifo]]</a>
 ``` cpp
+bool filesystem::is_fifo(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::fifo`.
 ``` cpp
+bool filesystem::is_fifo(const path& p);
+bool filesystem::is_fifo(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_fifo(status(p))` or `is_fifo(status(p, ec))`,
 respectively. The signature with argument `ec` returns `false` if an
 error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is other <a id="fs.op.is.other">[[fs.op.is.other]]</a>
 ``` cpp
+bool filesystem::is_other(file_status s) noexcept;
 ```
 *Returns:*
 `exists(s) && !is_regular_file(s) && !is_directory(s) && !is_symlink(s)`.
 ``` cpp
+bool filesystem::is_other(const path& p);
+bool filesystem::is_other(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_other(status(p))` or `is_other(status(p, ec))`,
 respectively. The signature with argument `ec` returns `false` if an
 error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is regular file <a id="fs.op.is.regular.file">[[fs.op.is.regular.file]]</a>
 ``` cpp
+bool filesystem::is_regular_file(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::regular`.
 ``` cpp
+bool filesystem::is_regular_file(const path& p);
 ```
 *Returns:* `is_regular_file(status(p))`.
 *Throws:* `filesystem_error` if `status(p)` would throw
 `filesystem_error`.
 ``` cpp
+bool filesystem::is_regular_file(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* Sets `ec` as if by `status(p, ec)`.
 [*Note 1*: `file_type::none`, `file_type::not_found` and
 occurs.
 #### Is socket <a id="fs.op.is.socket">[[fs.op.is.socket]]</a>
 ``` cpp
+bool filesystem::is_socket(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::socket`.
 ``` cpp
+bool filesystem::is_socket(const path& p);
+bool filesystem::is_socket(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_socket(status(p))` or `is_socket(status(p, ec))`,
 respectively. The signature with argument `ec` returns `false` if an
 error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is symlink <a id="fs.op.is.symlink">[[fs.op.is.symlink]]</a>
 ``` cpp
+bool filesystem::is_symlink(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::symlink`.
 ``` cpp
+bool filesystem::is_symlink(const path& p);
+bool filesystem::is_symlink(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_symlink(symlink_status(p))` or
 `is_symlink(symlink_status(p, ec))`, respectively. The signature with
 argument `ec` returns `false` if an error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Last write time <a id="fs.op.last.write.time">[[fs.op.last.write.time]]</a>
 ``` cpp
+file_time_type filesystem::last_write_time(const path& p);
+file_time_type filesystem::last_write_time(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* The time of last data modification of `p`, determined as if
 by the value of the POSIX `stat` class member `st_mtime` obtained as if
 by POSIX `stat()`. The signature with argument `ec` returns
 `file_time_type::min()` if an error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 ``` cpp
+void filesystem::last_write_time(const path& p, file_time_type new_time);
+void filesystem::last_write_time(const path& p, file_time_type new_time,
                      error_code& ec) noexcept;
 ```
 *Effects:* Sets the time of last data modification of the file resolved
 to by `p` to `new_time`, as if by POSIX `futimens()`.
 *Throws:* As specified in  [[fs.err.report]].
 [*Note 1*: A postcondition of `last_write_time(p) == new_time` is not
+specified because it does not necessarily hold for file systems with
+coarse time granularity. — *end note*]
 #### Permissions <a id="fs.op.permissions">[[fs.op.permissions]]</a>
 ``` cpp
+void filesystem::permissions(const path& p, perms prms, perm_options opts=perm_options::replace);
+void filesystem::permissions(const path& p, perms prms, error_code& ec) noexcept;
+void filesystem::permissions(const path& p, perms prms, perm_options opts, error_code& ec);
 ```
 *Preconditions:* Exactly one of the `perm_options` constants `replace`,
 `add`, or `remove` is present in `opts`.
 *Effects:* Applies the action specified by `opts` to the file `p`
 resolves to, or to file `p` itself if `p` is a symbolic link and
 `perm_options::nofollow` is set in `opts`. The action is applied as if
 by POSIX `fchmodat()`.
 [*Note 1*: Conceptually permissions are viewed as bits, but the actual
+implementation can use some other mechanism. — *end note*]
 *Throws:* As specified in  [[fs.err.report]].
+*Remarks:* The second signature behaves as if it had an additional
+parameter `perm_options` `opts` with an argument of
+`perm_options::replace`.
 #### Proximate <a id="fs.op.proximate">[[fs.op.proximate]]</a>
 ``` cpp
+path filesystem::proximate(const path& p, error_code& ec);
 ```
 *Returns:* `proximate(p, current_path(), ec)`.
 *Throws:* As specified in  [[fs.err.report]].
 ``` cpp
+path filesystem::proximate(const path& p, const path& base = current_path());
+path filesystem::proximate(const path& p, const path& base, error_code& ec);
 ```
 *Returns:* For the first form:
 ``` cpp
 *Throws:* As specified in  [[fs.err.report]].
 #### Read symlink <a id="fs.op.read.symlink">[[fs.op.read.symlink]]</a>
 ``` cpp
+path filesystem::read_symlink(const path& p);
+path filesystem::read_symlink(const path& p, error_code& ec);
 ```
 *Returns:* If `p` resolves to a symbolic link, a `path` object
 containing the contents of that symbolic link. The signature with
 argument `ec` returns `path()` if an error occurs.
 link. — *end note*]
 #### Relative <a id="fs.op.relative">[[fs.op.relative]]</a>
 ``` cpp
+path filesystem::relative(const path& p, error_code& ec);
 ```
 *Returns:* `relative(p, current_path(), ec)`.
 *Throws:* As specified in  [[fs.err.report]].
 ``` cpp
+path filesystem::relative(const path& p, const path& base = current_path());
+path filesystem::relative(const path& p, const path& base, error_code& ec);
 ```
 *Returns:* For the first form:
 ``` cpp
 *Throws:* As specified in  [[fs.err.report]].
 #### Remove <a id="fs.op.remove">[[fs.op.remove]]</a>
 ``` cpp
+bool filesystem::remove(const path& p);
+bool filesystem::remove(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* If `exists(symlink_status(p, ec))`, the file `p` is removed
 as if by POSIX `remove()`.
 *Throws:* As specified in  [[fs.err.report]].
 #### Remove all <a id="fs.op.remove.all">[[fs.op.remove.all]]</a>
 ``` cpp
+uintmax_t filesystem::remove_all(const path& p);
+uintmax_t filesystem::remove_all(const path& p, error_code& ec);
 ```
 *Effects:* Recursively deletes the contents of `p` if it exists, then
 deletes file `p` itself, as if by POSIX `remove()`.
 *Throws:* As specified in  [[fs.err.report]].
 #### Rename <a id="fs.op.rename">[[fs.op.rename]]</a>
 ``` cpp
+void filesystem::rename(const path& old_p, const path& new_p);
+void filesystem::rename(const path& old_p, const path& new_p, error_code& ec) noexcept;
 ```
 *Effects:* Renames `old_p` to `new_p`, as if by POSIX `rename()`.
 [*Note 1*:
 - If `old_p` and `new_p` resolve to the same existing file, no action is
   taken.
+- Otherwise, the rename can include the following effects:
   - if `new_p` resolves to an existing non-directory file, `new_p` is
     removed; otherwise,
   - if `new_p` resolves to an existing directory, `new_p` is removed if
+    empty on POSIX compliant operating systems but might be an error on
     other operating systems.
 A symbolic link is itself renamed, rather than the file it resolves to.
 — *end note*]
 *Throws:* As specified in  [[fs.err.report]].
 #### Resize file <a id="fs.op.resize.file">[[fs.op.resize.file]]</a>
 ``` cpp
+void filesystem::resize_file(const path& p, uintmax_t new_size);
+void filesystem::resize_file(const path& p, uintmax_t new_size, error_code& ec) noexcept;
 ```
 *Effects:* Causes the size that would be returned by `file_size(p)` to
 be equal to `new_size`, as if by POSIX `truncate()`.
 *Throws:* As specified in  [[fs.err.report]].
 #### Space <a id="fs.op.space">[[fs.op.space]]</a>
 ``` cpp
+space_info filesystem::space(const path& p);
+space_info filesystem::space(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* An object of type `space_info`. The value of the `space_info`
 object is determined as if by using POSIX `statvfs` to obtain a POSIX
 `struct statvfs`, and then multiplying its `f_blocks`, `f_bfree`, and
 *Throws:* As specified in  [[fs.err.report]].
 *Remarks:* The value of member `space_info::available` is operating
 system dependent.
+[*Note 1*: `available` might be less than `free`. — *end note*]
 #### Status <a id="fs.op.status">[[fs.op.status]]</a>
 ``` cpp
+file_status filesystem::status(const path& p);
 ```
 *Effects:* As if:
 ``` cpp
 [*Note 1*: `result` values of `file_status(file_type::not_found)` and
 `file_status(file_type::unknown)` are not considered failures and do not
 cause an exception to be thrown. — *end note*]
 ``` cpp
+file_status filesystem::status(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* If possible, determines the attributes of the file `p`
 resolves to, as if by using POSIX `stat()` to obtain a POSIX
 `struct stat`. If, during attribute determination, the underlying file
 pathname resolution continues using the contents of the symbolic link.
 #### Status known <a id="fs.op.status.known">[[fs.op.status.known]]</a>
 ``` cpp
+bool filesystem::status_known(file_status s) noexcept;
 ```
 *Returns:* `s.type() != file_type::none`.
 #### Symlink status <a id="fs.op.symlink.status">[[fs.op.symlink.status]]</a>
 ``` cpp
+file_status filesystem::symlink_status(const path& p);
+file_status filesystem::symlink_status(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* Same as `status()`, above, except that the attributes of `p`
 are determined as if by using POSIX `lstat()` to obtain a POSIX
 `struct stat`.
 *Returns:* Same as `status()`, above, except that if the attributes
 indicate a symbolic link, as if by POSIX `S_ISLNK`, returns
 `file_status(file_type::symlink, prms)`. The signature with argument
 `ec` returns `file_status(file_type::none)` if an error occurs.
+*Throws:* As specified in  [[fs.err.report]].
 *Remarks:* Pathname resolution terminates if `p` names a symbolic link.
 #### Temporary directory path <a id="fs.op.temp.dir.path">[[fs.op.temp.dir.path]]</a>
 ``` cpp
+path filesystem::temp_directory_path();
+path filesystem::temp_directory_path(error_code& ec);
 ```
 Let `p` be an unspecified directory path suitable for temporary files.
 *Effects:* If `exists(p)` is `false` or `is_directory(p)` is `false`, an
 function. — *end example*]
 #### Weakly canonical <a id="fs.op.weakly.canonical">[[fs.op.weakly.canonical]]</a>
 ``` cpp
+path filesystem::weakly_canonical(const path& p);
+path filesystem::weakly_canonical(const path& p, error_code& ec);
 ```
 *Effects:* Using `status(p)` or `status(p, ec)`, respectively, to
 determine existence, return a path composed by `operator/=` from the
 result of calling `canonical()` with a path argument composed of the
 leading elements of `p` that exist, if any, followed by the elements of
 `p` that do not exist, if any. For the first form, `canonical()` is
 `canonical()` is called with `ec` as an `error_code` argument, and
 `path()` is returned at the first error occurrence, if any.
 *Ensures:* The returned path is in normal form [[fs.path.generic]].
+*Returns:* `p` with symlinks resolved and the result
+normalized [[fs.path.generic]].
 *Throws:* As specified in  [[fs.err.report]].

Diff to HTML by rtfpessoa