Proposed resolution:

This wording is relative to N4606.

1. Edit [fs.path.concat] as follows:

   path& operator+=(const path& x);
   path& operator+=(const string_type& x);
   path& operator+=(basic_string_view<value_type> x);
   path& operator+=(const value_type * x);
   path& operator+=(value_type x);
   template <class Source>
       path& operator+=(const Source& x);
   template <class EcharT>
       path& operator+=(EcharT x);
   template <class Source>
       path& concat(const Source& x);
   template <class InputIterator>
       path& concat(InputIterator first, InputIterator last);
   

   -1- Postcondition: native() == prior_native + effective-argument, where prior_native is native() prior to the call to operator+=, and effective-argument is:

   • if x is present and is const path&, x.native(); otherwise,
   • if source is present, the effective range of source path.req; otherwise,
   • >if first and last are present, the range [first, last); otherwise,
   • x.

   If the value type of effective-argument would not be path::value_type, the acctual argument or argument range is first converted path.type.cvt so that effective-argument has value type path::value_type. Effects: Equivalent to pathname.append(path(x).native()) [Note: This directly manipulates the value of native() and may not be portable between operating systems. — end note]

   -2- Returns: *this.

   template <class InputIterator>
       path& concat(InputIterator first, InputIterator last);
   

   -?- Effects: Equivalent to pathname.append(path(first, last).native()) [Note: This directly manipulates the value of native() and may not be portable between operating systems. — end note]

   -?- Returns: *this.