[filesystems] - C++20 → C++23

Files changed (1) hide show

tmp/tmp5as575t4/{from.md → to.md} +279 -216

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

@@ -40,18 +40,20 @@ can be thought of as a raw pointer to a file. If the file pointed to
 does not exist, the symbolic link is said to be a “dangling” symbolic
 link. — *end note*]
 ### Conformance <a id="fs.conformance">[[fs.conformance]]</a>
 Conformance is specified in terms of behavior. Ideal behavior is not
 always implementable, so the conformance subclauses take that into
 account.
 #### POSIX conformance <a id="fs.conform.9945">[[fs.conform.9945]]</a>
-Some behavior is specified by reference to POSIX [[fs.norm.ref]]. How
-such behavior is actually implemented is unspecified.
 [*Note 1*: This constitutes an “as if” rule allowing implementations to
 call native operating system or other APIs. — *end note*]
 Implementations should provide such behavior as it is defined by POSIX.
@@ -90,26 +92,20 @@ system.
 #### File system race behavior <a id="fs.race.behavior">[[fs.race.behavior]]</a>
 A *file system race* is the condition that occurs when multiple threads,
 processes, or computers interleave access and modification of the same
 object within a file system. Behavior is undefined if calls to functions
-provided by subclause  [[fs.race.behavior]] introduce a file system
-race.
 If the possibility of a file system race would make it unreliable for a
 program to test for a precondition before calling a function described
 herein, *Preconditions:* is not specified for the function.
 [*Note 1*: As a design practice, preconditions are not specified when
 it is unreasonable for a program to detect them prior to calling the
 function. — *end note*]
-### Normative references <a id="fs.norm.ref">[[fs.norm.ref]]</a>
-Subclause  [[filesystems]] mentions commercially available operating
-systems for purposes of exposition.[^41]
 ### Requirements <a id="fs.req">[[fs.req]]</a>
 Throughout subclause  [[filesystems]], `char`, `wchar_t`, `char8_t`,
 `char16_t`, and `char32_t` are collectively called *encoded character
 types*.
@@ -126,17 +122,11 @@ value type that is one of the encoded character types.
 character set and encoding. Since `signed char` and `unsigned char` have
 no implied character set and encoding, they are not included as
 permitted types. — *end note*]
 Template parameters named `Allocator` shall meet the *Cpp17Allocator*
-requirements ([[cpp17.allocator]]).
-#### Namespaces and headers <a id="fs.req.namespace">[[fs.req.namespace]]</a>
-Unless otherwise specified, references to entities described in
-subclause  [[filesystems]] are assumed to be qualified with
-`::std::filesystem::`.
 ### Header `<filesystem>` synopsis <a id="fs.filesystem.syn">[[fs.filesystem.syn]]</a>
 ``` cpp
 #include <compare>              // see [compare.syn]
@@ -158,18 +148,18 @@ namespace std::filesystem {
   // [fs.class.directory.iterator], directory iterators
   class directory_iterator;
   // [fs.dir.itr.nonmembers], range access for directory iterators
   directory_iterator begin(directory_iterator iter) noexcept;
-  directory_iterator end(const directory_iterator&) noexcept;
   // [fs.class.rec.dir.itr], recursive directory iterators
   class recursive_directory_iterator;
   // [fs.rec.dir.itr.nonmembers], range access for recursive directory iterators
   recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
-  recursive_directory_iterator end(const recursive_directory_iterator&) noexcept;
   // [fs.class.file.status], file status
   class file_status;
   struct space_info {
@@ -335,10 +325,28 @@ namespace std::filesystem {
   path temp_directory_path(error_code& ec);
   path weakly_canonical(const path& p);
   path weakly_canonical(const path& p, error_code& ec);
 }
 ```
 Implementations should ensure that the resolution and range of
 `file_time_type` reflect the operating system dependent resolution and
 range of file time values.
@@ -389,10 +397,12 @@ follows, unless otherwise specified:
   appropriate for the specific operating system dependent error.
   Otherwise, `clear()` is called on the `error_code&` argument.
 ### Class `path` <a id="fs.class.path">[[fs.class.path]]</a>
 An object of class `path` represents a path and contains a pathname.
 Such an object is concerned only with the lexical and syntactic aspects
 of a path. The path does not necessarily exist in external storage, and
 the pathname is not necessarily valid for the current operating system
 or for a particular file system.
@@ -414,22 +424,22 @@ elements of a path that determine if it is absolute are operating system
 dependent. A *relative path* is a path that is not absolute, and as
 such, only unambiguously identifies the location of a file when resolved
 relative to an implied starting location. The elements of a path that
 determine if it is relative are operating system dependent.
-[*Note 2*: Pathnames “.” and “..” are relative paths. — *end note*]
 A *pathname* is a character string that represents the name of a path.
 Pathnames are formatted according to the generic pathname format grammar
 [[fs.path.generic]] or according to an operating system dependent
 *native pathname format* accepted by the host operating system.
 *Pathname resolution* is the operating system dependent mechanism for
 resolving a pathname to a particular file in a file hierarchy. There may
 be multiple pathnames that resolve to the same file.
-[*Example 1*: POSIX specifies the mechanism in section 4.11, Pathname
 resolution. — *end example*]
 ``` cpp
 namespace std::filesystem {
   class path {
@@ -647,13 +657,13 @@ consisting solely of one and two period characters respectively, have
 special meaning. The following characteristics of filenames are
 operating system dependent:
 - The permitted characters. \[*Example 1*: Some operating systems
   prohibit the ASCII control characters (0x00 – 0x1F) in
-  filenames. — *end example*] \[*Note 1*: For wide portability, users
- may wish to limit *filename* characters to the POSIX Portable Filename
-  Character Set:
   `A B C D E F G H I J K L M N O P Q R S T U V W X Y Z`
   `a b c d e f g h i j k l m n o p q r s t u v w x y z`
   `0 1 2 3 4 5 6 7 8 9 . _ -` — *end note*]
 - The maximum permitted length.
 - Filenames that are not permitted.
@@ -678,11 +688,11 @@ A *root-name* identifies the starting location for pathname resolution
 required.
 [*Note 2*: Many operating systems define a name beginning with two
 *directory-separator* characters as a *root-name* that identifies
 network or other resource locations. Some operating systems define a
-single letter followed by a colon as a drive specifier – a *root-name*
 identifying a specific device such as a disk drive. — *end note*]
 If a *root-name* is otherwise ambiguous, the possibility with the
 longest sequence of characters is chosen.
@@ -694,11 +704,11 @@ longest sequence of characters is chosen.
 1.  If the path is empty, stop.
 2.  Replace each slash character in the *root-name* with a
     *preferred-separator*.
 3.  Replace each *directory-separator* with a *preferred-separator*.
-    \[*Note 4*: The generic pathname grammar [[fs.path.generic]] defines
     *directory-separator* as one or more slashes and
     *preferred-separator*s. — *end note*]
 4.  Remove each dot filename and any immediately following
     *directory-separator*.
 5.  As long as any appear, remove a non-dot-dot filename immediately
@@ -738,11 +748,11 @@ path using either a pathname in the generic format [[fs.path.generic]]
 or a pathname in the native format [[fs.class.path]]. Such an argument
 is taken to be in the generic format if and only if it matches the
 generic format and is not acceptable to the operating system as a native
 path.
-[*Note 2*: Some operating systems may have no unambiguous way to
 distinguish between native format and generic format arguments. This is
 by design as it simplifies use for operating systems that do not require
 disambiguation. An implementation for an operating system where
 disambiguation is required is permitted to distinguish between the
 formats. — *end note*]
@@ -761,11 +771,11 @@ differently from paths for directories, the path shall be treated as a
 directory path if its last element is a *directory-separator*, otherwise
 it shall be treated as a path to a regular file.
 [*Note 4*: A path stores a native format pathname
 [[fs.path.native.obs]] and acts as if it also stores a generic format
-pathname, related as given below. The implementation may generate the
 generic format pathname based on the native format pathname (and
 possibly other information) when requested. — *end note*]
 When a path is constructed from or is assigned a single representation
 separate from any path, the other representation is selected by the
@@ -783,11 +793,11 @@ the result of converting *p*. — *end note*]
 The *native encoding* of an ordinary character string is the operating
 system dependent current encoding for pathnames [[fs.class.path]]. The
 *native encoding* for wide character strings is the
 implementation-defined execution wide-character set encoding
-[[lex.charset]].
 For member function arguments that take character sequences representing
 paths and for member functions returning strings, value type and
 encoding conversion is performed if the value type of the argument or
 return value differs from `path::value_type`. For the argument or return
@@ -801,12 +811,12 @@ determined by its value type:
   return values is performed. For Windows-based operating systems, the
   native ordinary encoding is determined by calling a Windows API
   function. — *end note*] \[*Note 7*: This results in behavior
   identical to other C and C++ standard library functions that perform
   file operations using ordinary character strings to identify paths.
-  Changing this behavior would be surprising and error
-  prone. — *end note*]
 - `wchar_t`: The encoding is the native wide encoding. The method of
   conversion is unspecified. \[*Note 8*: For Windows-based operating
   systems `path::value_type` is `wchar_t` so no conversion from
   `wchar_t` value type arguments or to `wchar_t` value type return
   values is performed. — *end note*]
@@ -850,11 +860,11 @@ participate in overload resolution unless `Source` denotes a type other
 than `path`, and either
 - `Source` is a specialization of `basic_string` or `basic_string_view`,
   or
 - the *qualified-id* `iterator_traits<decay_t<Source>>::value_type` is
-  valid and denotes a possibly `const` encoded character type
   [[temp.deduct]].
 [*Note 1*: See path conversions [[fs.path.cvt]] for how the value types
 above and their encodings convert to `path::value_type` and its
 encoding. — *end note*]
@@ -1089,12 +1099,12 @@ template<class Source>
 ```
 *Effects:* Appends `path(x).native()` to the pathname in the native
 format.
-[*Note 2*: This directly manipulates the value of `native()` and may
-not be portable between operating systems. — *end note*]
 *Returns:* `*this`.
 ``` cpp
 path& operator+=(value_type x);
@@ -1243,14 +1253,10 @@ const value_type* c_str() const noexcept;
 operator string_type() const;
 ```
 *Returns:* `native()`.
-[*Note 3*: Conversion to `string_type` is provided so that an object of
-class `path` can be given as an argument to existing standard library
-file stream constructors and open functions. — *end note*]
 ``` cpp
 template<class EcharT, class traits = char_traits<EcharT>,
          class Allocator = allocator<EcharT>>
   basic_string<EcharT, traits, Allocator>
     string(const Allocator& a = Allocator()) const;
@@ -1450,17 +1456,17 @@ path(".bar").extension();               // yields "" and stem() is ".bar"
 path("..bar").extension();              // yields ".bar" and stem() is "."
 ```
 — *end example*]
-[*Note 4*: The period is included in the return value so that it is
 possible to distinguish between no extension and an empty
 extension. — *end note*]
-[*Note 5*: On non-POSIX operating systems, for a path `p`, it may not
-be the case that `p.stem() + p.extension() == p.filename()`, even though
-the generic format pathnames are the same. — *end note*]
 ##### Query <a id="fs.path.query">[[fs.path.query]]</a>
 ``` cpp
 [[nodiscard]] bool empty() const noexcept;
@@ -1559,25 +1565,21 @@ slashes, but that does not affect `path` equality.
 ``` cpp
 path lexically_relative(const path& base) const;
 ```
-*Returns:* `*this` made relative to `base`. Does not
-resolve [[fs.class.path]] symlinks. Does not first
-normalize [[fs.path.generic]] `*this` or `base`.
 *Effects:* If:
 - `root_name() != base.root_name()` is `true`, or
 - `is_absolute() != base.is_absolute()` is `true`, or
 - `!has_root_directory() && base.has_root_directory()` is `true`, or
 - any *filename* in `relative_path()` or `base.relative_path()` can be
   interpreted as a *root-name*,
 returns `path()`.
-[*Note 6*: On a POSIX implementation, no *filename* in a
 *relative-path* is acceptable as a *root-name*. — *end note*]
 Determines the first mismatched element of `*this` and `base` as if by:
 ``` cpp
@@ -1595,10 +1597,14 @@ Then,
 - returns an object of class `path` that is default-constructed,
   followed by
   - application of `operator/=(path(".."))` `n` times, and then
   - application of `operator/=` for each element in \[`a`, `end()`).
 [*Example 11*:
 ``` cpp
 assert(path("/a/d").lexically_relative("/a/b/c") == "../../d");
 assert(path("/a/b/c").lexically_relative("/a/d") == "../b/c");
@@ -1612,28 +1618,28 @@ The above assertions will succeed. On Windows, the returned path’s
 *directory-separator* characters will be backslashes rather than
 slashes, but that does not affect `path` equality.
 — *end example*]
-[*Note 7*: If symlink following semantics are desired, use the
 operational function `relative()`. — *end note*]
-[*Note 8*: If normalization [[fs.path.generic]] is needed to ensure
 consistent matching of elements, apply `lexically_normal()` to `*this`,
 `base`, or both. — *end note*]
 ``` cpp
 path lexically_proximate(const path& base) const;
 ```
 *Returns:* If the value of `lexically_relative(base)` is not an empty
 path, return it. Otherwise return `*this`.
-[*Note 9*: If symlink following semantics are desired, use the
 operational function `proximate()`. — *end note*]
-[*Note 10*: If normalization [[fs.path.generic]] is needed to ensure
 consistent matching of elements, apply `lexically_normal()` to `*this`,
 `base`, or both. — *end note*]
 #### Iterators <a id="fs.path.itr">[[fs.path.itr]]</a>
@@ -1738,14 +1744,10 @@ Path equality and path equivalence have different semantics.
 - Equivalence is determined by the `equivalent()` non-member function,
   which determines if two paths resolve [[fs.class.path]] to the same
   file system entity. \[*Example 2*: `equivalent("foo", "bar")` will be
   `true` when both paths resolve to the same file. — *end example*]
-Programmers wishing to determine if two paths are “the same” must decide
-if “the same” means “the same representation” or “resolve to the same
-actual file”, and choose the appropriate function accordingly.
 — *end note*]
 ``` cpp
 friend strong_ordering operator<=>(const path& lhs, const path& rhs) noexcept;
 ```
@@ -1756,12 +1758,24 @@ friend strong_ordering operator<=>(const path& lhs, const path& rhs) noexcept;
 friend path operator/(const path& lhs, const path& rhs);
 ```
 *Effects:* Equivalent to: `return path(lhs) /= rhs;`
 ### Class `filesystem_error` <a id="fs.class.filesystem.error">[[fs.class.filesystem.error]]</a>
 ``` cpp
 namespace std::filesystem {
   class filesystem_error : public system_error {
   public:
     filesystem_error(const string& what_arg, error_code ec);
@@ -1847,22 +1861,41 @@ and `path2` in the native format in the returned string.
 #### Enum `path::format` <a id="fs.enum.path.format">[[fs.enum.path.format]]</a>
 This enum specifies constants used to identify the format of the
 character sequence, with the meanings listed in [[fs.enum.path.format]].
-[*Note 1*: For POSIX-based systems, native and generic formats are
-equivalent and the character sequence should always be interpreted in
-the same way. — *end note*]
 #### Enum class `file_type` <a id="fs.enum.file.type">[[fs.enum.file.type]]</a>
 This enum class specifies constants used to identify file types, with
 the meanings listed in [[fs.enum.file.type]]. The values of the
 constants are distinct.
-[*Note 1*: The file not being found is not considered an error while
-determining the type of a file. — *end note*]
 #### Enum class `copy_options` <a id="fs.enum.copy.opts">[[fs.enum.copy.opts]]</a>
 The `enum class` type `copy_options` is a bitmask type [[bitmask.types]]
 that specifies bitmask constants used to control the semantics of copy
@@ -1873,16 +1906,16 @@ exposition; implementations shall provide only a single definition.
 Every other constant in the table represents a distinct bitmask element.
 **Table: Enum class `copy_options`** <a id="fs.enum.copy.opts">[fs.enum.copy.opts]</a>
 | Constant             | Meaning                                                                                                                                              |
-| -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `none`               | (Default) Error; file already exists.                                                                                                                |
 | `skip_existing`      | Do not overwrite existing file, do not report an error.                                                                                              |
 | `overwrite_existing` | Overwrite the existing file.                                                                                                                         |
-| `update_existing`    | Overwrite the existing file if it is older than the replacement file. \ohdrx{2}{Option group controlling `copy` function effects for sub-directories} |
-| `recursive`          | Recursively copy sub-directories and their contents. \ohdrx{2}{Option group controlling `copy` function effects for symbolic links}                   |
 | `copy_symlinks`      | Copy symbolic links as symbolic links rather than copying the files that they point to.                                                              |
 | `skip_symlinks`      | Ignore symbolic links. \ohdrx{2}{Option group controlling `copy` function effects for choosing the form of copying}                                  |
 | `directories_only`   | Copy directory structure only, do not copy non-directory files.                                                                                      |
 | `create_symlinks`    | Make symbolic links instead of copies of files. The source path shall be an absolute path unless the destination path is in the current directory.   |
 | `create_hard_links`  | Make hard links instead of copies of files.                                                                                                          |
@@ -1931,12 +1964,12 @@ permissions operations, with the meanings listed in
 **Table: Enum class `perm_options`** <a id="fs.enum.perm.opts">[fs.enum.perm.opts]</a>
 | Name       | Meaning                                                                                                                                                 |
 | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `replace`  | `permissions` shall replace the file's permission bits with `perm`                                                                                      |
-| `add`      | `permissions` shall replace the file's permission bits with the bitwise \logop{OR} of `perm` and the file's current permission bits.                    |
-| `remove`   | `permissions` shall replace the file's permission bits with the bitwise \logop{AND} of the complement of `perm` and the file's current permission bits. |
 | `nofollow` | `permissions` shall change the permissions of a symbolic link itself rather than the permissions of the file the link resolves to.                      |
 #### Enum class `directory_options` <a id="fs.enum.dir.opts">[[fs.enum.dir.opts]]</a>
@@ -1955,10 +1988,12 @@ every other constant in the table represents a distinct bitmask element.
 | `skip_permission_denied`   | Skip directories that would otherwise result in permission denied. |
 ### Class `file_status` <a id="fs.class.file.status">[[fs.class.file.status]]</a>
 ``` cpp
 namespace std::filesystem {
   class file_status {
   public:
     // [fs.file.status.cons], constructors and destructor
@@ -2027,10 +2062,12 @@ void permissions(perms prms) noexcept;
 *Ensures:* `permissions() == prms`.
 ### Class `directory_entry` <a id="fs.class.directory.entry">[[fs.class.directory.entry]]</a>
 ``` cpp
 namespace std::filesystem {
   class directory_entry {
   public:
     // [fs.dir.entry.cons], constructors and destructor
@@ -2086,10 +2123,15 @@ namespace std::filesystem {
     file_status symlink_status(error_code& ec) const noexcept;
     bool operator==(const directory_entry& rhs) const noexcept;
     strong_ordering operator<=>(const directory_entry& rhs) const noexcept;
   private:
     filesystem::path pathobject;        // exposition only
     friend class directory_iterator;    // exposition only
   };
 }
@@ -2192,13 +2234,12 @@ unspecified.
 *Throws:* As specified in  [[fs.err.report]].
 [*Note 1*: Implementations of `directory_iterator`
 [[fs.class.directory.iterator]] are prohibited from directly or
-indirectly calling the `refresh` function since it must access the
-external file system, and the objective of caching is to avoid
-unnecessary file system accesses. — *end note*]
 #### Observers <a id="fs.dir.entry.obs">[[fs.dir.entry.obs]]</a>
 Unqualified function names in the *Returns:* elements of the
 `directory_entry` observers described below refer to members of the
@@ -2363,18 +2404,30 @@ bool operator==(const directory_entry& rhs) const noexcept;
 strong_ordering operator<=>(const directory_entry& rhs) const noexcept;
 ```
 *Returns:* `pathobject <=> rhs.pathobject`.
 ### Class `directory_iterator` <a id="fs.class.directory.iterator">[[fs.class.directory.iterator]]</a>
 An object of type `directory_iterator` provides an iterator for a
 sequence of `directory_entry` elements representing the path and any
 cached attribute values [[fs.class.directory.entry]] for each file in a
 directory or in an *implementation-defined* directory-like file type.
-[*Note 1*: For iteration into sub-directories, see class
 `recursive_directory_iterator` [[fs.class.rec.dir.itr]]. — *end note*]
 ``` cpp
 namespace std::filesystem {
   class directory_iterator {
@@ -2402,10 +2455,14 @@ namespace std::filesystem {
     const directory_entry& operator*() const;
     const directory_entry* operator->() const;
     directory_iterator&    operator++();
     directory_iterator&    increment(error_code& ec);
     // other members as required by [input.iterators], input iterators
   };
 }
 ```
@@ -2424,12 +2481,12 @@ Two end iterators are always equal. An end iterator shall not be equal
 to a non-end iterator.
 The result of calling the `path()` member of the `directory_entry`
 object obtained by dereferencing a `directory_iterator` is a reference
 to a `path` object composed of the directory argument from which the
-iterator was constructed with filename of the directory entry appended
-as if by `operator/=`.
 Directory iteration shall not yield directory entries for the current
 (dot) and parent (dot-dot) directories.
 The order of directory entries obtained by dereferencing successive
@@ -2444,21 +2501,21 @@ call any `directory_entry` `refresh` function.
 [*Note 2*: The exact mechanism for storing cached attribute values is
 not exposed to users. For exposition, class `directory_iterator` is
 shown in [[fs.class.directory.entry]] as a friend of class
 `directory_entry`. — *end note*]
-[*Note 3*: Programs performing directory iteration may wish to test if
-the path obtained by dereferencing a directory iterator actually exists.
-It could be a symbolic link to a non-existent file. Programs recursively
-walking directory trees for purposes of removing and renaming entries
-may wish to avoid following symbolic links. — *end note*]
 [*Note 4*: If a file is removed from or added to a directory after the
 construction of a `directory_iterator` for the directory, it is
 unspecified whether or not subsequently incrementing the iterator will
 ever result in an iterator referencing the removed or added directory
-entry. See POSIX `readdir_r`. — *end note*]
 #### Members <a id="fs.dir.itr.members">[[fs.dir.itr.members]]</a>
 ``` cpp
 directory_iterator() noexcept;
@@ -2532,21 +2589,23 @@ directory_iterator begin(directory_iterator iter) noexcept;
 ```
 *Returns:* `iter`.
 ``` cpp
-directory_iterator end(const directory_iterator&) noexcept;
 ```
 *Returns:* `directory_iterator()`.
 ### Class `recursive_directory_iterator` <a id="fs.class.rec.dir.itr">[[fs.class.rec.dir.itr]]</a>
 An object of type `recursive_directory_iterator` provides an iterator
 for a sequence of `directory_entry` elements representing the files in a
 directory or in an *implementation-defined* directory-like file type,
-and its sub-directories.
 ``` cpp
 namespace std::filesystem {
   class recursive_directory_iterator {
   public:
@@ -2586,10 +2645,14 @@ namespace std::filesystem {
     void pop();
     void pop(error_code& ec);
     void disable_recursion_pending();
     // other members as required by [input.iterators], input iterators
   };
 }
 ```
@@ -2599,11 +2662,12 @@ results in undefined behavior.
 The behavior of a `recursive_directory_iterator` is the same as a
 `directory_iterator` unless otherwise specified.
 [*Note 1*: If the directory structure being iterated over contains
-cycles then the end iterator may be unreachable. — *end note*]
 #### Members <a id="fs.rec.dir.itr.members">[[fs.rec.dir.itr.members]]</a>
 ``` cpp
 recursive_directory_iterator() noexcept;
@@ -2634,13 +2698,13 @@ error.
 `directory_options` argument, otherwise
 `options() == directory_options::none`.
 *Throws:* As specified in  [[fs.err.report]].
-[*Note 1*: To iterate over the current directory, use
-`recursive_directory_iterator(".")` rather than
-`recursive_directory_iterator("")`. — *end note*]
 [*Note 2*: By default, `recursive_directory_iterator` does not follow
 directory symlinks. To follow directory symlinks, specify `options` as
 `directory_options::follow_directory_symlink`. — *end note*]
@@ -2777,40 +2841,42 @@ void disable_recursion_pending();
 recursion into a directory. — *end note*]
 #### Non-member functions <a id="fs.rec.dir.itr.nonmembers">[[fs.rec.dir.itr.nonmembers]]</a>
 These functions enable use of `recursive_directory_iterator` with
-range-based for statements.
 ``` cpp
 recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
 ```
 *Returns:* `iter`.
 ``` cpp
-recursive_directory_iterator end(const recursive_directory_iterator&) noexcept;
 ```
 *Returns:* `recursive_directory_iterator()`.
 ### 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]].
@@ -2820,12 +2886,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*]
@@ -2836,12 +2902,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.
@@ -2854,24 +2920,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`.
@@ -3008,22 +3074,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`.
@@ -3058,12 +3124,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
@@ -3074,12 +3140,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.
@@ -3091,12 +3157,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
@@ -3105,12 +3171,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
@@ -3130,12 +3196,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()`.
@@ -3143,24 +3209,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()`.
@@ -3178,12 +3244,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()`.
@@ -3198,12 +3264,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.
@@ -3217,61 +3283,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.
@@ -3283,12 +3349,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]].
@@ -3305,30 +3371,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.
@@ -3336,18 +3402,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.
@@ -3355,18 +3421,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.
@@ -3374,12 +3440,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)`,
@@ -3402,18 +3468,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.
@@ -3421,19 +3487,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.
@@ -3441,26 +3507,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
@@ -3471,18 +3537,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.
@@ -3490,18 +3556,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.
@@ -3509,74 +3575,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
@@ -3594,12 +3660,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.
@@ -3610,20 +3676,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
@@ -3641,12 +3707,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()`.
@@ -3661,12 +3727,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()`.
@@ -3681,25 +3747,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*]
@@ -3707,24 +3773,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
@@ -3737,16 +3803,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
@@ -3764,11 +3830,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
@@ -3829,20 +3895,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`.
@@ -3854,19 +3920,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
@@ -3885,17 +3951,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
@@ -3903,10 +3966,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]].

 does not exist, the symbolic link is said to be a “dangling” symbolic
 link. — *end note*]
 ### Conformance <a id="fs.conformance">[[fs.conformance]]</a>
+#### General <a id="fs.conformance.general">[[fs.conformance.general]]</a>
 Conformance is specified in terms of behavior. Ideal behavior is not
 always implementable, so the conformance subclauses take that into
 account.
 #### POSIX conformance <a id="fs.conform.9945">[[fs.conform.9945]]</a>
+Some behavior is specified by reference to POSIX. How such behavior is
+actually implemented is unspecified.
 [*Note 1*: This constitutes an “as if” rule allowing implementations to
 call native operating system or other APIs. — *end note*]
 Implementations should provide such behavior as it is defined by POSIX.
 #### File system race behavior <a id="fs.race.behavior">[[fs.race.behavior]]</a>
 A *file system race* is the condition that occurs when multiple threads,
 processes, or computers interleave access and modification of the same
 object within a file system. Behavior is undefined if calls to functions
+provided by subclause  [[filesystems]] introduce a file system race.
 If the possibility of a file system race would make it unreliable for a
 program to test for a precondition before calling a function described
 herein, *Preconditions:* is not specified for the function.
 [*Note 1*: As a design practice, preconditions are not specified when
 it is unreasonable for a program to detect them prior to calling the
 function. — *end note*]
 ### Requirements <a id="fs.req">[[fs.req]]</a>
 Throughout subclause  [[filesystems]], `char`, `wchar_t`, `char8_t`,
 `char16_t`, and `char32_t` are collectively called *encoded character
 types*.
 character set and encoding. Since `signed char` and `unsigned char` have
 no implied character set and encoding, they are not included as
 permitted types. — *end note*]
 Template parameters named `Allocator` shall meet the *Cpp17Allocator*
+requirements [[allocator.requirements.general]].
 ### Header `<filesystem>` synopsis <a id="fs.filesystem.syn">[[fs.filesystem.syn]]</a>
 ``` cpp
 #include <compare>              // see [compare.syn]
   // [fs.class.directory.iterator], directory iterators
   class directory_iterator;
   // [fs.dir.itr.nonmembers], range access for directory iterators
   directory_iterator begin(directory_iterator iter) noexcept;
+  directory_iterator end(directory_iterator) noexcept;
   // [fs.class.rec.dir.itr], recursive directory iterators
   class recursive_directory_iterator;
   // [fs.rec.dir.itr.nonmembers], range access for recursive directory iterators
   recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
+  recursive_directory_iterator end(recursive_directory_iterator) noexcept;
   // [fs.class.file.status], file status
   class file_status;
   struct space_info {
   path temp_directory_path(error_code& ec);
   path weakly_canonical(const path& p);
   path weakly_canonical(const path& p, error_code& ec);
 }
+// [fs.path.hash], hash support
+namespace std {
+  template<class T> struct hash;
+  template<> struct hash<filesystem::path>;
+}
+namespace std::ranges {
+  template<>
+    inline constexpr bool enable_borrowed_range<filesystem::directory_iterator> = true;
+  template<>
+    inline constexpr bool enable_borrowed_range<filesystem::recursive_directory_iterator> = true;
+  template<>
+    inline constexpr bool enable_view<filesystem::directory_iterator> = true;
+  template<>
+    inline constexpr bool enable_view<filesystem::recursive_directory_iterator> = true;
+}
 ```
 Implementations should ensure that the resolution and range of
 `file_time_type` reflect the operating system dependent resolution and
 range of file time values.
   appropriate for the specific operating system dependent error.
   Otherwise, `clear()` is called on the `error_code&` argument.
 ### Class `path` <a id="fs.class.path">[[fs.class.path]]</a>
+#### General <a id="fs.class.path.general">[[fs.class.path.general]]</a>
 An object of class `path` represents a path and contains a pathname.
 Such an object is concerned only with the lexical and syntactic aspects
 of a path. The path does not necessarily exist in external storage, and
 the pathname is not necessarily valid for the current operating system
 or for a particular file system.
 dependent. A *relative path* is a path that is not absolute, and as
 such, only unambiguously identifies the location of a file when resolved
 relative to an implied starting location. The elements of a path that
 determine if it is relative are operating system dependent.
+[*Note 2*: Pathnames “.” and “..” are relative paths. — *end note*]
 A *pathname* is a character string that represents the name of a path.
 Pathnames are formatted according to the generic pathname format grammar
 [[fs.path.generic]] or according to an operating system dependent
 *native pathname format* accepted by the host operating system.
 *Pathname resolution* is the operating system dependent mechanism for
 resolving a pathname to a particular file in a file hierarchy. There may
 be multiple pathnames that resolve to the same file.
+[*Example 1*: POSIX specifies the mechanism in section 4.12, Pathname
 resolution. — *end example*]
 ``` cpp
 namespace std::filesystem {
   class path {
 special meaning. The following characteristics of filenames are
 operating system dependent:
 - The permitted characters. \[*Example 1*: Some operating systems
   prohibit the ASCII control characters (0x00 – 0x1F) in
+  filenames. — *end example*] \[*Note 1*: Wider portability can be
+ achieved by limiting *filename* characters to the POSIX Portable
+ Filename Character Set:
   `A B C D E F G H I J K L M N O P Q R S T U V W X Y Z`
   `a b c d e f g h i j k l m n o p q r s t u v w x y z`
   `0 1 2 3 4 5 6 7 8 9 . _ -` — *end note*]
 - The maximum permitted length.
 - Filenames that are not permitted.
 required.
 [*Note 2*: Many operating systems define a name beginning with two
 *directory-separator* characters as a *root-name* that identifies
 network or other resource locations. Some operating systems define a
+single letter followed by a colon as a drive specifier — a *root-name*
 identifying a specific device such as a disk drive. — *end note*]
 If a *root-name* is otherwise ambiguous, the possibility with the
 longest sequence of characters is chosen.
 1.  If the path is empty, stop.
 2.  Replace each slash character in the *root-name* with a
     *preferred-separator*.
 3.  Replace each *directory-separator* with a *preferred-separator*.
+    \[*Note 4*: The generic pathname grammar defines
     *directory-separator* as one or more slashes and
     *preferred-separator*s. — *end note*]
 4.  Remove each dot filename and any immediately following
     *directory-separator*.
 5.  As long as any appear, remove a non-dot-dot filename immediately
 or a pathname in the native format [[fs.class.path]]. Such an argument
 is taken to be in the generic format if and only if it matches the
 generic format and is not acceptable to the operating system as a native
 path.
+[*Note 2*: Some operating systems have no unambiguous way to
 distinguish between native format and generic format arguments. This is
 by design as it simplifies use for operating systems that do not require
 disambiguation. An implementation for an operating system where
 disambiguation is required is permitted to distinguish between the
 formats. — *end note*]
 directory path if its last element is a *directory-separator*, otherwise
 it shall be treated as a path to a regular file.
 [*Note 4*: A path stores a native format pathname
 [[fs.path.native.obs]] and acts as if it also stores a generic format
+pathname, related as given below. The implementation can generate the
 generic format pathname based on the native format pathname (and
 possibly other information) when requested. — *end note*]
 When a path is constructed from or is assigned a single representation
 separate from any path, the other representation is selected by the
 The *native encoding* of an ordinary character string is the operating
 system dependent current encoding for pathnames [[fs.class.path]]. The
 *native encoding* for wide character strings is the
 implementation-defined execution wide-character set encoding
+[[character.seq]].
 For member function arguments that take character sequences representing
 paths and for member functions returning strings, value type and
 encoding conversion is performed if the value type of the argument or
 return value differs from `path::value_type`. For the argument or return
   return values is performed. For Windows-based operating systems, the
   native ordinary encoding is determined by calling a Windows API
   function. — *end note*] \[*Note 7*: This results in behavior
   identical to other C and C++ standard library functions that perform
   file operations using ordinary character strings to identify paths.
+  Changing this behavior would be surprising and
+ error-prone. — *end note*]
 - `wchar_t`: The encoding is the native wide encoding. The method of
   conversion is unspecified. \[*Note 8*: For Windows-based operating
   systems `path::value_type` is `wchar_t` so no conversion from
   `wchar_t` value type arguments or to `wchar_t` value type return
   values is performed. — *end note*]
 than `path`, and either
 - `Source` is a specialization of `basic_string` or `basic_string_view`,
   or
 - the *qualified-id* `iterator_traits<decay_t<Source>>::value_type` is
+  valid and denotes a possibly const encoded character type
   [[temp.deduct]].
 [*Note 1*: See path conversions [[fs.path.cvt]] for how the value types
 above and their encodings convert to `path::value_type` and its
 encoding. — *end note*]
 ```
 *Effects:* Appends `path(x).native()` to the pathname in the native
 format.
+[*Note 2*: This directly manipulates the value of `native()`, which is
+not necessarily portable between operating systems. — *end note*]
 *Returns:* `*this`.
 ``` cpp
 path& operator+=(value_type x);
 operator string_type() const;
 ```
 *Returns:* `native()`.
 ``` cpp
 template<class EcharT, class traits = char_traits<EcharT>,
          class Allocator = allocator<EcharT>>
   basic_string<EcharT, traits, Allocator>
     string(const Allocator& a = Allocator()) const;
 path("..bar").extension();              // yields ".bar" and stem() is "."
 ```
 — *end example*]
+[*Note 3*: The period is included in the return value so that it is
 possible to distinguish between no extension and an empty
 extension. — *end note*]
+[*Note 4*: On non-POSIX operating systems, for a path `p`, it is
+possible that `p.stem() + p.extension() == p.filename()` is `false`,
+even though the generic format pathnames are the same. — *end note*]
 ##### Query <a id="fs.path.query">[[fs.path.query]]</a>
 ``` cpp
 [[nodiscard]] bool empty() const noexcept;
 ``` cpp
 path lexically_relative(const path& base) const;
 ```
 *Effects:* If:
 - `root_name() != base.root_name()` is `true`, or
 - `is_absolute() != base.is_absolute()` is `true`, or
 - `!has_root_directory() && base.has_root_directory()` is `true`, or
 - any *filename* in `relative_path()` or `base.relative_path()` can be
   interpreted as a *root-name*,
 returns `path()`.
+[*Note 5*: On a POSIX implementation, no *filename* in a
 *relative-path* is acceptable as a *root-name*. — *end note*]
 Determines the first mismatched element of `*this` and `base` as if by:
 ``` cpp
 - returns an object of class `path` that is default-constructed,
   followed by
   - application of `operator/=(path(".."))` `n` times, and then
   - application of `operator/=` for each element in \[`a`, `end()`).
+*Returns:* `*this` made relative to `base`. Does not
+resolve [[fs.class.path]] symlinks. Does not first
+normalize [[fs.path.generic]] `*this` or `base`.
 [*Example 11*:
 ``` cpp
 assert(path("/a/d").lexically_relative("/a/b/c") == "../../d");
 assert(path("/a/b/c").lexically_relative("/a/d") == "../b/c");
 *directory-separator* characters will be backslashes rather than
 slashes, but that does not affect `path` equality.
 — *end example*]
+[*Note 6*: If symlink following semantics are desired, use the
 operational function `relative()`. — *end note*]
+[*Note 7*: If normalization [[fs.path.generic]] is needed to ensure
 consistent matching of elements, apply `lexically_normal()` to `*this`,
 `base`, or both. — *end note*]
 ``` cpp
 path lexically_proximate(const path& base) const;
 ```
 *Returns:* If the value of `lexically_relative(base)` is not an empty
 path, return it. Otherwise return `*this`.
+[*Note 8*: If symlink following semantics are desired, use the
 operational function `proximate()`. — *end note*]
+[*Note 9*: If normalization [[fs.path.generic]] is needed to ensure
 consistent matching of elements, apply `lexically_normal()` to `*this`,
 `base`, or both. — *end note*]
 #### Iterators <a id="fs.path.itr">[[fs.path.itr]]</a>
 - Equivalence is determined by the `equivalent()` non-member function,
   which determines if two paths resolve [[fs.class.path]] to the same
   file system entity. \[*Example 2*: `equivalent("foo", "bar")` will be
   `true` when both paths resolve to the same file. — *end example*]
 — *end note*]
 ``` cpp
 friend strong_ordering operator<=>(const path& lhs, const path& rhs) noexcept;
 ```
 friend path operator/(const path& lhs, const path& rhs);
 ```
 *Effects:* Equivalent to: `return path(lhs) /= rhs;`
+#### Hash support <a id="fs.path.hash">[[fs.path.hash]]</a>
+``` cpp
+template<> struct hash<filesystem::path>;
+```
+For an object `p` of type `filesystem::path`,
+`hash<filesystem::path>()(p)` evaluates to the same result as
+`filesystem::hash_value(p)`.
 ### Class `filesystem_error` <a id="fs.class.filesystem.error">[[fs.class.filesystem.error]]</a>
+#### General <a id="fs.class.filesystem.error.general">[[fs.class.filesystem.error.general]]</a>
 ``` cpp
 namespace std::filesystem {
   class filesystem_error : public system_error {
   public:
     filesystem_error(const string& what_arg, error_code ec);
 #### Enum `path::format` <a id="fs.enum.path.format">[[fs.enum.path.format]]</a>
 This enum specifies constants used to identify the format of the
 character sequence, with the meanings listed in [[fs.enum.path.format]].
+**Table: Enum `path::format`** <a id="fs.enum.path.format">[fs.enum.path.format]</a>
+| Name             | Meaning                                                                                                                                                                                                                                                                                                                                               |
+| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `native_format`  | The native pathname format.                                                                                                                                                                                                                                                                                                                           |
+| `generic_format` | The generic pathname format.                                                                                                                                                                                                                                                                                                                          |
+| `auto_format`    | The interpretation of the format of the character sequence is implementation-defined. The implementation may inspect the content of the character sequence to determine the format. Recommended practice: For POSIX-based systems, native and generic formats are equivalent and the character sequence should always be interpreted in the same way. |
 #### Enum class `file_type` <a id="fs.enum.file.type">[[fs.enum.file.type]]</a>
 This enum class specifies constants used to identify file types, with
 the meanings listed in [[fs.enum.file.type]]. The values of the
 constants are distinct.
+**Table: Enum class `file_type`** <a id="fs.enum.file.type">[fs.enum.file.type]</a>
+| Constant                 | Meaning                                                                                                                                                                                                                     |
+| ------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `none`                   | The type of the file has not been determined or an error occurred while trying to determine the type.                                                                                                                       |
+| `not_found`              | Pseudo-type indicating the file was not found. *The file not being found is not considered an error while determining the type of a file.*                                                                                  |
+| `regular`                | Regular file                                                                                                                                                                                                                |
+| `directory`              | Directory file                                                                                                                                                                                                              |
+| `symlink`                | Symbolic link file                                                                                                                                                                                                          |
+| `block`                  | Block special file                                                                                                                                                                                                          |
+| `character`              | Character special file                                                                                                                                                                                                      |
+| `fifo`                   | FIFO or pipe file                                                                                                                                                                                                           |
+| `socket`                 | Socket file                                                                                                                                                                                                                 |
+| `implementation-defined` | Implementations that support file systems having file types in addition to the above `file_type` types shall supply implementation-defined `file_type` constants to separately identify each of those additional file types |
+| `unknown`                | The file exists but the type cannot be determined                                                                                                                                                                           |
 #### Enum class `copy_options` <a id="fs.enum.copy.opts">[[fs.enum.copy.opts]]</a>
 The `enum class` type `copy_options` is a bitmask type [[bitmask.types]]
 that specifies bitmask constants used to control the semantics of copy
 Every other constant in the table represents a distinct bitmask element.
 **Table: Enum class `copy_options`** <a id="fs.enum.copy.opts">[fs.enum.copy.opts]</a>
 | Constant             | Meaning                                                                                                                                              |
+| -------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `none`               | (Default) Error; file already exists.                                                                                                                |
 | `skip_existing`      | Do not overwrite existing file, do not report an error.                                                                                              |
 | `overwrite_existing` | Overwrite the existing file.                                                                                                                         |
+| `update_existing`    | Overwrite the existing file if it is older than the replacement file. \ohdrx{2}{Option group controlling `copy` function effects for subdirectories} |
+| `recursive`          | Recursively copy subdirectories and their contents. \ohdrx{2}{Option group controlling `copy` function effects for symbolic links}                   |
 | `copy_symlinks`      | Copy symbolic links as symbolic links rather than copying the files that they point to.                                                              |
 | `skip_symlinks`      | Ignore symbolic links. \ohdrx{2}{Option group controlling `copy` function effects for choosing the form of copying}                                  |
 | `directories_only`   | Copy directory structure only, do not copy non-directory files.                                                                                      |
 | `create_symlinks`    | Make symbolic links instead of copies of files. The source path shall be an absolute path unless the destination path is in the current directory.   |
 | `create_hard_links`  | Make hard links instead of copies of files.                                                                                                          |
 **Table: Enum class `perm_options`** <a id="fs.enum.perm.opts">[fs.enum.perm.opts]</a>
 | Name       | Meaning                                                                                                                                                 |
 | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `replace`  | `permissions` shall replace the file's permission bits with `perm`                                                                                      |
+| `add`      | `permissions` shall replace the file's permission bits with the bitwise \logop{or} of `perm` and the file's current permission bits.                    |
+| `remove`   | `permissions` shall replace the file's permission bits with the bitwise \logop{and} of the complement of `perm` and the file's current permission bits. |
 | `nofollow` | `permissions` shall change the permissions of a symbolic link itself rather than the permissions of the file the link resolves to.                      |
 #### Enum class `directory_options` <a id="fs.enum.dir.opts">[[fs.enum.dir.opts]]</a>
 | `skip_permission_denied`   | Skip directories that would otherwise result in permission denied. |
 ### Class `file_status` <a id="fs.class.file.status">[[fs.class.file.status]]</a>
+#### General <a id="fs.class.file.status.general">[[fs.class.file.status.general]]</a>
 ``` cpp
 namespace std::filesystem {
   class file_status {
   public:
     // [fs.file.status.cons], constructors and destructor
 *Ensures:* `permissions() == prms`.
 ### Class `directory_entry` <a id="fs.class.directory.entry">[[fs.class.directory.entry]]</a>
+#### General <a id="fs.class.directory.entry.general">[[fs.class.directory.entry.general]]</a>
 ``` cpp
 namespace std::filesystem {
   class directory_entry {
   public:
     // [fs.dir.entry.cons], constructors and destructor
     file_status symlink_status(error_code& ec) const noexcept;
     bool operator==(const directory_entry& rhs) const noexcept;
     strong_ordering operator<=>(const directory_entry& rhs) const noexcept;
+    // [fs.dir.entry.io], inserter
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const directory_entry& d);
   private:
     filesystem::path pathobject;        // exposition only
     friend class directory_iterator;    // exposition only
   };
 }
 *Throws:* As specified in  [[fs.err.report]].
 [*Note 1*: Implementations of `directory_iterator`
 [[fs.class.directory.iterator]] are prohibited from directly or
+indirectly calling the `refresh` function as described in
+[[fs.class.directory.iterator.general]]. — *end note*]
 #### Observers <a id="fs.dir.entry.obs">[[fs.dir.entry.obs]]</a>
 Unqualified function names in the *Returns:* elements of the
 `directory_entry` observers described below refer to members of the
 strong_ordering operator<=>(const directory_entry& rhs) const noexcept;
 ```
 *Returns:* `pathobject <=> rhs.pathobject`.
+#### Inserter <a id="fs.dir.entry.io">[[fs.dir.entry.io]]</a>
+``` cpp
+template<class charT, class traits>
+  friend basic_ostream<charT, traits>&
+    operator<<(basic_ostream<charT, traits>& os, const directory_entry& d);
+```
+*Effects:* Equivalent to: `return os << d.path();`
 ### Class `directory_iterator` <a id="fs.class.directory.iterator">[[fs.class.directory.iterator]]</a>
+#### General <a id="fs.class.directory.iterator.general">[[fs.class.directory.iterator.general]]</a>
 An object of type `directory_iterator` provides an iterator for a
 sequence of `directory_entry` elements representing the path and any
 cached attribute values [[fs.class.directory.entry]] for each file in a
 directory or in an *implementation-defined* directory-like file type.
+[*Note 1*: For iteration into subdirectories, see class
 `recursive_directory_iterator` [[fs.class.rec.dir.itr]]. — *end note*]
 ``` cpp
 namespace std::filesystem {
   class directory_iterator {
     const directory_entry& operator*() const;
     const directory_entry* operator->() const;
     directory_iterator&    operator++();
     directory_iterator&    increment(error_code& ec);
+    bool operator==(default_sentinel_t) const noexcept {
+      return *this == directory_iterator();
+    }
     // other members as required by [input.iterators], input iterators
   };
 }
 ```
 to a non-end iterator.
 The result of calling the `path()` member of the `directory_entry`
 object obtained by dereferencing a `directory_iterator` is a reference
 to a `path` object composed of the directory argument from which the
+iterator was constructed with the filename of the directory entry
+appended as if by `operator/=`.
 Directory iteration shall not yield directory entries for the current
 (dot) and parent (dot-dot) directories.
 The order of directory entries obtained by dereferencing successive
 [*Note 2*: The exact mechanism for storing cached attribute values is
 not exposed to users. For exposition, class `directory_iterator` is
 shown in [[fs.class.directory.entry]] as a friend of class
 `directory_entry`. — *end note*]
+[*Note 3*: A path obtained by dereferencing a directory iterator might
+not actually exist; it could be a symbolic link to a non-existent file.
+Recursively walking directory trees for purposes of removing and
+renaming entries might invalidate symbolic links that are being
+followed. — *end note*]
 [*Note 4*: If a file is removed from or added to a directory after the
 construction of a `directory_iterator` for the directory, it is
 unspecified whether or not subsequently incrementing the iterator will
 ever result in an iterator referencing the removed or added directory
+entry. See POSIX `readdir`. — *end note*]
 #### Members <a id="fs.dir.itr.members">[[fs.dir.itr.members]]</a>
 ``` cpp
 directory_iterator() noexcept;
 ```
 *Returns:* `iter`.
 ``` cpp
+directory_iterator end(directory_iterator) noexcept;
 ```
 *Returns:* `directory_iterator()`.
 ### Class `recursive_directory_iterator` <a id="fs.class.rec.dir.itr">[[fs.class.rec.dir.itr]]</a>
+#### General <a id="fs.class.rec.dir.itr.general">[[fs.class.rec.dir.itr.general]]</a>
 An object of type `recursive_directory_iterator` provides an iterator
 for a sequence of `directory_entry` elements representing the files in a
 directory or in an *implementation-defined* directory-like file type,
+and its subdirectories.
 ``` cpp
 namespace std::filesystem {
   class recursive_directory_iterator {
   public:
     void pop();
     void pop(error_code& ec);
     void disable_recursion_pending();
+    bool operator==(default_sentinel_t) const noexcept {
+      return *this == recursive_directory_iterator();
+    }
     // other members as required by [input.iterators], input iterators
   };
 }
 ```
 The behavior of a `recursive_directory_iterator` is the same as a
 `directory_iterator` unless otherwise specified.
 [*Note 1*: If the directory structure being iterated over contains
+cycles then it is possible that the end iterator is
+unreachable. — *end note*]
 #### Members <a id="fs.rec.dir.itr.members">[[fs.rec.dir.itr.members]]</a>
 ``` cpp
 recursive_directory_iterator() noexcept;
 `directory_options` argument, otherwise
 `options() == directory_options::none`.
 *Throws:* As specified in  [[fs.err.report]].
+[*Note 1*: Use `recursive_directory_iterator(".")` rather than
+`recursive_directory_iterator("")` to iterate over the current
+directory. — *end note*]
 [*Note 2*: By default, `recursive_directory_iterator` does not follow
 directory symlinks. To follow directory symlinks, specify `options` as
 `directory_options::follow_directory_symlink`. — *end note*]
 recursion into a directory. — *end note*]
 #### Non-member functions <a id="fs.rec.dir.itr.nonmembers">[[fs.rec.dir.itr.nonmembers]]</a>
 These functions enable use of `recursive_directory_iterator` with
+range-based `for` statements.
 ``` cpp
 recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
 ```
 *Returns:* `iter`.
 ``` cpp
+recursive_directory_iterator end(recursive_directory_iterator) noexcept;
 ```
 *Returns:* `recursive_directory_iterator()`.
 ### 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