[libc++] [docs] Migrate C++ status pages to RestructuredText (RST).

[curdeius]

Summary

Currently, papers and issues are in separate .csv files (that is easier to update), but I can put them inline.Transforming current html tables into rst are done by the script (attached to the patch FYI but I'll remove it before committing).
I'll of course update RST files before committing to match any modifications that may happen in master branch.

This patch moves the status pages in www/ to RST format in docs/.

It also does some other minor changes: fix copyright year and broken comment end, adds substitutions for coherence (and add colors, but that can be removed easily).
It adds as well redirects from old to new status pages.

[curdeius]

Just thinking out loud, would it be a good idea to add documentation artifacts to BuildKite?
I mean changing buildkite-pipeline.yml:

- label: "Documentation"
  command: "libcxx/utils/ci/run-buildbot documentation"
  artifact_paths:
    - "**/test-results.xml"
    - "projects/libcxx/docs/html/**/*" # <<<<<<<<<<<<<<<< added

[ldionne]

In D92076#2416399, @curdeius wrote:

Just thinking out loud, would it be a good idea to add documentation artifacts to BuildKite?

What would we do with those? I'm not sure what's the setup that currently causes libcxx.llvm.org to be updated. Are you suggesting we tie those together?

I really like this change! I think we should try to move all of our documentation to the same format (rst or anything else we like, and rst seems fine). I've been meaning to do this for a long time, but it never was sufficiently high on my priority list. Thanks for doing this!

I didn't check that your script transcribed all papers correctly, but I trust it does. LGTM if you remove the transition script.

[curdeius]

In D92076#2416874, @ldionne wrote:

In D92076#2416399, @curdeius wrote:

Just thinking out loud, would it be a good idea to add documentation artifacts to BuildKite?

What would we do with those? I'm not sure what's the setup that currently causes libcxx.llvm.org to be updated. Are you suggesting we tie those together?

I don't know either what updates the doc on the site. Anyway, I just thought that could be nice to have it, but anyone that does substantial changes to docs would anyway run make docs-libcxx-html.

I didn't check that your script transcribed all papers correctly, but I trust it does. LGTM if you remove the transition script.

I double-checked that.

And I removed the script.

libcxx/docs/Cxx1yStatus.rst

+.. _cxx1y-status:
+
+================================
+libc++ C++14 Status
+================================
+
+.. include:: Styles.rst
+
+.. contents::
+   :local:
+
+
+Overview
+================================
+
+In April 2013, the C++ standard committee approved the draft for the next version of the C++ standard, initially known as "C++1y".
+
+The draft standard includes papers and issues that were voted on at the previous three meetings (Kona, Portland, and Bristol).
+
+In August 2014, this draft was approved by ISO as C++14.
+
+This page shows the status of libc++; the status of clang's support of the language features is `here <https://clang.llvm.org/cxx_status.html#cxx14>`__.
+
+The groups that have contributed papers:
+
+-  CWG - Core Language Working group
+-  LWG - Library working group
+-  SG1 - Study group #1 (Concurrency working group)
+
+
+.. _paper-status-cxx1y:
+
+Paper Status
+====================================
+
+.. csv-table::
+   :file: Cxx1yStatusPaperStatus.csv
+   :widths: auto
+
+
+.. _issues-status-cxx1y:
+
+Library Working Group Issues Status
+====================================
+
+.. csv-table::
+   :file: Cxx1yStatusIssuesStatus.csv
+   :widths: auto
+
+Last Updated: 25-Mar-2014

libcxx/docs/Cxx1yStatusIssuesStatus.csv

+"Issue #","Issue Name","Meeting","Status"
+"`1214 <https://wg21.link/lwg1214>`__","Insufficient/inconsistent key immutability requirements for associative containers","Kona","|Complete|"
+"`2009 <https://wg21.link/lwg2009>`__","Reporting out-of-bound values on numeric string conversions","Kona","|Complete|"
+"`2010 <https://wg21.link/lwg2010>`__","``is_*``\  traits for binding operations can't be meaningfully specialized","Kona","|Complete|"
+"`2015 <https://wg21.link/lwg2015>`__","Incorrect pre-conditions for some type traits","Kona","|Complete|"
+"`2021 <https://wg21.link/lwg2021>`__","Further incorrect usages of result_of","Kona","|Complete|"
+"`2028 <https://wg21.link/lwg2028>`__","messages_base::catalog overspecified","Kona","|Complete|"
+"`2033 <https://wg21.link/lwg2033>`__","Preconditions of reserve, shrink_to_fit, and resize functions","Kona","|Complete|"
+"`2039 <https://wg21.link/lwg2039>`__","Issues with std::reverse and std::copy_if","Kona","|Complete|"
+"`2044 <https://wg21.link/lwg2044>`__","No definition of ""Stable"" for copy algorithms","Kona","|Complete|"
+"`2045 <https://wg21.link/lwg2045>`__","forward_list::merge and forward_list::splice_after with unequal allocators","Kona","|Complete|"
+"`2047 <https://wg21.link/lwg2047>`__","Incorrect ""mixed"" move-assignment semantics of unique_ptr","Kona","|Complete|"
+"`2050 <https://wg21.link/lwg2050>`__","Unordered associative containers do not use allocator_traits to define member types","Kona","|Complete|"
+"`2053 <https://wg21.link/lwg2053>`__","Errors in regex bitmask types","Kona","|Complete|"
+"`2061 <https://wg21.link/lwg2061>`__","make_move_iterator and arrays","Kona","|Complete|"
+"`2064 <https://wg21.link/lwg2064>`__","More noexcept issues in basic_string","Kona","|Complete|"
+"`2065 <https://wg21.link/lwg2065>`__","Minimal allocator interface","Kona","|Complete|"
+"`2067 <https://wg21.link/lwg2067>`__","packaged_task should have deleted copy c'tor with const parameter","Kona","|Complete|"
+"`2069 <https://wg21.link/lwg2069>`__","Inconsistent exception spec for basic_string move constructor","Kona","|Complete|"
+"`2096 <https://wg21.link/lwg2096>`__","Incorrect constraints of future::get in regard to MoveAssignable","Kona","|Complete|"
+"`2102 <https://wg21.link/lwg2102>`__","Why is std::launch an implementation-defined type?","Kona","|Complete|"
+"","","",""
+"`2071 <https://wg21.link/lwg2071>`__","std::valarray move-assignment","Portland","|Complete|"
+"`2074 <https://wg21.link/lwg2074>`__","Off by one error in std::reverse_copy","Portland","|Complete|"
+"`2081 <https://wg21.link/lwg2081>`__","Allocator requirements should include CopyConstructible","Portland","|Complete|"
+"`2083 <https://wg21.link/lwg2083>`__","const-qualification on weak_ptr::owner_before","Portland","|Complete|"
+"`2086 <https://wg21.link/lwg2086>`__","Overly generic type support for math functions","Portland","|Complete|"
+"`2099 <https://wg21.link/lwg2099>`__","Unnecessary constraints of va_start() usage","Portland","|Complete|"
+"`2103 <https://wg21.link/lwg2103>`__","std::allocator_traits<std::allocator<T>>::propagate_on_container_move_assignment","Portland","|Complete|"
+"`2105 <https://wg21.link/lwg2105>`__","Inconsistent requirements on ``const_iterator``'s value_type","Portland","|Complete|"
+"`2110 <https://wg21.link/lwg2110>`__","remove can't swap but note says it might","Portland","|Complete|"
+"`2123 <https://wg21.link/lwg2123>`__","merge() allocator requirements for lists versus forward lists","Portland","|Complete|"
+"`2005 <https://wg21.link/lwg2005>`__","unordered_map::insert(T&&) protection should apply to map too","Portland","|Complete|"
+"`2011 <https://wg21.link/lwg2011>`__","Unexpected output required of strings","Portland","|Complete|"
+"`2048 <https://wg21.link/lwg2048>`__","Unnecessary mem_fn overloads","Portland","|Complete|"
+"`2049 <https://wg21.link/lwg2049>`__","``is_destructible``\  is underspecified","Portland","|Complete|"
+"`2056 <https://wg21.link/lwg2056>`__","future_errc enums start with value 0 (invalid value for broken_promise)","Portland","|Complete|"
+"`2058 <https://wg21.link/lwg2058>`__","valarray and begin/end","Portland","|Complete|"
+"","","",""
+"`2091 <https://wg21.link/lwg2091>`__","Misplaced effect in m.try_lock_for()","Bristol","|Complete|"
+"`2092 <https://wg21.link/lwg2092>`__","Vague Wording for condition_variable_any","Bristol","|Complete|"
+"`2093 <https://wg21.link/lwg2093>`__","Throws clause of condition_variable::wait with predicate","Bristol","|Complete|"
+"`2094 <https://wg21.link/lwg2094>`__","duration conversion overflow shouldn't participate in overload resolution","Bristol","|Complete|"
+"`2122 <https://wg21.link/lwg2122>`__","merge() stability for lists versus forward lists","Bristol","|Complete|"
+"`2128 <https://wg21.link/lwg2128>`__","Absence of global functions cbegin/cend","Bristol","|Complete|"
+"`2145 <https://wg21.link/lwg2145>`__","error_category default constructor","Bristol","|Complete|"
+"`2147 <https://wg21.link/lwg2147>`__","Unclear hint type in Allocator's allocate function","Bristol","|Complete|"
+"`2148 <https://wg21.link/lwg2148>`__","Hashing enums should be supported directly by std::hash","Bristol","|Complete|"
+"`2149 <https://wg21.link/lwg2149>`__","Concerns about 20.8/5","Bristol","|Complete|"
+"`2162 <https://wg21.link/lwg2162>`__","allocator_traits::max_size missing noexcept","Bristol","|Complete|"
+"`2163 <https://wg21.link/lwg2163>`__","nth_element requires inconsistent post-conditions","Bristol","|Complete|"
+"`2169 <https://wg21.link/lwg2169>`__","Missing reset() requirements in unique_ptr specialization","Bristol","|Complete|"
+"`2172 <https://wg21.link/lwg2172>`__","Does ``atomic_compare_exchange_*``\  accept v == nullptr arguments?","Bristol","|Complete|"
+"`2080 <https://wg21.link/lwg2080>`__","Specify when once_flag becomes invalid","Bristol","|Complete|"
+"`2098 <https://wg21.link/lwg2098>`__","promise throws clauses","Bristol","|Complete|"
+"`2109 <https://wg21.link/lwg2109>`__","Incorrect requirements for hash specializations","Bristol","|Complete|"
+"`2130 <https://wg21.link/lwg2130>`__","missing ordering constraints for fences","Bristol","|Complete|"
+"`2138 <https://wg21.link/lwg2138>`__","atomic_flag::clear ordering constraints","Bristol","|Complete|"
+"`2140 <https://wg21.link/lwg2140>`__","notify_all_at_thread_exit synchronization","Bristol","|Complete|"
+"`2144 <https://wg21.link/lwg2144>`__","Missing noexcept specification in type_index","Bristol","|Complete|"
+"`2174 <https://wg21.link/lwg2174>`__","wstring_convert::converted() should be noexcept","Bristol","|Complete|"
+"`2175 <https://wg21.link/lwg2175>`__","string_convert and wbuffer_convert validity","Bristol","|Complete|"
+"`2176 <https://wg21.link/lwg2176>`__","Special members for wstring_convert and wbuffer_convert","Bristol","|Complete|"
+"`2177 <https://wg21.link/lwg2177>`__","Requirements on Copy/MoveInsertable","Bristol","|Complete|"
+"`2185 <https://wg21.link/lwg2185>`__","Missing throws clause for future/shared_future::wait_for/wait_until","Bristol","|Complete|"
+"`2187 <https://wg21.link/lwg2187>`__","vector<bool> is missing emplace and emplace_back member functions","Bristol","|Complete|"
+"`2190 <https://wg21.link/lwg2190>`__","ordering of condition variable operations, reflects Posix discussion","Bristol","|Complete|"
+"`2196 <https://wg21.link/lwg2196>`__","Specification of ``is_*[copy/move]_[constructible/assignable]``\  unclear for non-referencable types","Bristol","|Complete|"
+"`2197 <https://wg21.link/lwg2197>`__","Specification of ``is_[un]signed``\  unclear for non-arithmetic types","Bristol","|Complete|"
+"`2200 <https://wg21.link/lwg2200>`__","Data race avoidance for all containers, not only for sequences","Bristol","|Complete|"
+"`2203 <https://wg21.link/lwg2203>`__","scoped_allocator_adaptor uses wrong argument types for piecewise construction","Bristol","|Complete|"
+"`2207 <https://wg21.link/lwg2207>`__","basic_string::at should not have a Requires clause","Bristol","|Complete|"
+"`2209 <https://wg21.link/lwg2209>`__","assign() overspecified for sequence containers","Bristol","|Complete|"
+"`2210 <https://wg21.link/lwg2210>`__","Missing allocator-extended constructor for allocator-aware containers","Bristol","|Complete|"
+"`2211 <https://wg21.link/lwg2211>`__","Replace ambiguous use of ""Allocator"" in container requirements","Bristol","|Complete|"
+"`2222 <https://wg21.link/lwg2222>`__","Inconsistency in description of forward_list::splice_after single-element overload","Bristol","|Complete|"
+"`2225 <https://wg21.link/lwg2225>`__","Unrealistic header inclusion checks required","Bristol","|Complete|"
+"`2229 <https://wg21.link/lwg2229>`__","Standard code conversion facets underspecified","Bristol","|Complete|"
+"`2231 <https://wg21.link/lwg2231>`__","DR 704 removes complexity guarantee for clear()","Bristol","|Complete|"
+"`2235 <https://wg21.link/lwg2235>`__","Undefined behavior without proper requirements on basic_string constructors","Bristol","|Complete|"
+"","","",""
+"`2141 <https://wg21.link/lwg2141>`__","common_type trait produces reference types","Chicago","|Complete|"
+"`2246 <https://wg21.link/lwg2246>`__","unique_ptr assignment effects w.r.t. deleter","Chicago","|Complete|"
+"`2247 <https://wg21.link/lwg2247>`__","Type traits and std::nullptr_t","Chicago","|Complete|"
+"`2085 <https://wg21.link/lwg2085>`__","Wrong description of effect 1 of basic_istream::ignore","Chicago","|Complete|"
+"`2087 <https://wg21.link/lwg2087>`__","iostream_category() and noexcept","Chicago","|Complete|"
+"`2143 <https://wg21.link/lwg2143>`__","ios_base::xalloc should be thread-safe","Chicago","|Complete|"
+"`2150 <https://wg21.link/lwg2150>`__","Unclear specification of find_end","Chicago","|Complete|"
+"`2180 <https://wg21.link/lwg2180>`__","Exceptions from std::seed_seq operations","Chicago","|Complete|"
+"`2194 <https://wg21.link/lwg2194>`__","Impossible container requirements for adaptor types","Chicago","|Complete|"
+"`2013 <https://wg21.link/lwg2013>`__","Do library implementers have the freedom to add constexpr?","Chicago","|Complete|"
+"`2018 <https://wg21.link/lwg2018>`__","regex_traits::isctype Returns clause is wrong","Chicago","|Complete|"
+"`2078 <https://wg21.link/lwg2078>`__","Throw specification of async() incomplete","Chicago","|Complete|"
+"`2097 <https://wg21.link/lwg2097>`__","packaged_task constructors should be constrained","Chicago","|Complete|"
+"`2100 <https://wg21.link/lwg2100>`__","Timed waiting functions cannot timeout if launch::async policy used","Chicago","|Complete|"
+"`2120 <https://wg21.link/lwg2120>`__","What should async do if neither 'async' nor 'deferred' is set in policy?","Chicago","|Complete|"
+"`2159 <https://wg21.link/lwg2159>`__","atomic_flag initialization","Chicago","|Complete|"
+"`2275 <https://wg21.link/lwg2275>`__","Why is forward_as_tuple not constexpr?","Chicago","|Complete|"
+"`2284 <https://wg21.link/lwg2284>`__","Inconsistency in allocator_traits::max_size","Chicago","|Complete|"
+"`2298 <https://wg21.link/lwg2298>`__","``is_nothrow_constructible``\  is always false because of create<>","Chicago","|Complete|"
+"`2300 <https://wg21.link/lwg2300>`__","Redundant sections for map and multimap members should be removed","Chicago","|Complete|"
+"NB comment: GB9","Remove gets from C++14","Chicago","|Complete|"
+"","","",""
+"`2135 <https://wg21.link/lwg2135>`__","Unclear requirement for exceptions thrown in condition_variable::wait()","Issaquah","|Complete|"
+"`2291 <https://wg21.link/lwg2291>`__","std::hash is vulnerable to collision DoS attack","Issaquah","|Complete|"
+"`2142 <https://wg21.link/lwg2142>`__","packaged_task::operator() synchronization too broad?","Issaquah","|Complete|"
+"`2240 <https://wg21.link/lwg2240>`__","Probable misuse of term ""function scope"" in [thread.condition]","Issaquah","|Complete|"
+"`2252 <https://wg21.link/lwg2252>`__","Strong guarantee on vector::push_back() still broken with C++11?","Issaquah","|Complete|"
+"`2257 <https://wg21.link/lwg2257>`__","Simplify container requirements with the new algorithms","Issaquah","|Complete|"
+"`2268 <https://wg21.link/lwg2268>`__","Setting a default argument in the declaration of a member function assign of std::basic_string","Issaquah","|Complete|"
+"`2271 <https://wg21.link/lwg2271>`__","regex_traits::lookup_classname specification unclear","Issaquah","|Complete|"
+"`2272 <https://wg21.link/lwg2272>`__","quoted should use char_traits::eq for character comparison","Issaquah","|Complete|"
+"`2278 <https://wg21.link/lwg2278>`__","User-defined literals for Standard Library types","Issaquah","|Complete|"
+"`2280 <https://wg21.link/lwg2280>`__","begin / end for arrays should be constexpr and noexcept","Issaquah","|Complete|"
+"`2285 <https://wg21.link/lwg2285>`__","make_reverse_iterator","Issaquah","|Complete|"
+"`2299 <https://wg21.link/lwg2299>`__","Effects of inaccessible ``key_compare::is_transparent``\  type are not clear","Issaquah","|Complete|"
+"`1450 <https://wg21.link/lwg1450>`__","Contradiction in regex_constants","Issaquah","|Complete|"
+"`2003 <https://wg21.link/lwg2003>`__","String exception inconsistency in erase.","Issaquah","|Complete|"
+"`2112 <https://wg21.link/lwg2112>`__","User-defined classes that cannot be derived from","Issaquah","|Complete|"
+"`2132 <https://wg21.link/lwg2132>`__","std::function ambiguity","Issaquah","|Complete|"
+"`2182 <https://wg21.link/lwg2182>`__","``Container::[const_]reference`` types are misleadingly specified","Issaquah","|Complete|"
+"`2188 <https://wg21.link/lwg2188>`__","Reverse iterator does not fully support targets that overload operator&","Issaquah","|Complete|"
+"`2193 <https://wg21.link/lwg2193>`__","Default constructors for standard library containers are explicit","Issaquah","|Complete|"
+"`2205 <https://wg21.link/lwg2205>`__","Problematic postconditions of regex_match and regex_search","Issaquah","|Complete|"
+"`2213 <https://wg21.link/lwg2213>`__","Return value of std::regex_replace","Issaquah","|Complete|"
+"`2258 <https://wg21.link/lwg2258>`__","a.erase(q1, q2) unable to directly return q2","Issaquah","|Complete|"
+"`2263 <https://wg21.link/lwg2263>`__","Comparing iterators and allocator pointers with different const-character","Issaquah","|Complete|"
+"`2293 <https://wg21.link/lwg2293>`__","Wrong facet used by num_put::do_put","Issaquah","|Complete|"
+"`2301 <https://wg21.link/lwg2301>`__","Why is std::tie not constexpr?","Issaquah","|Complete|"
+"`2304 <https://wg21.link/lwg2304>`__","Complexity of count in unordered associative containers","Issaquah","|Complete|"
+"`2306 <https://wg21.link/lwg2306>`__","match_results::reference should be value_type&, not const value_type&","Issaquah","|Complete|"
+"`2308 <https://wg21.link/lwg2308>`__","Clarify container destructor requirements w.r.t. std::array","Issaquah","|Complete|"
+"`2313 <https://wg21.link/lwg2313>`__","tuple_size should always derive from integral_constant<size_t, N>","Issaquah","|Complete|"
+"`2314 <https://wg21.link/lwg2314>`__","apply() should return decltype(auto) and use decay_t before tuple_size","Issaquah","|Complete|"
+"`2315 <https://wg21.link/lwg2315>`__","weak_ptr should be movable","Issaquah","|Complete|"
+"`2316 <https://wg21.link/lwg2316>`__","weak_ptr::lock() should be atomic","Issaquah","|Complete|"
+"`2317 <https://wg21.link/lwg2317>`__","The type property queries should be UnaryTypeTraits returning size_t","Issaquah","|Complete|"
+"`2320 <https://wg21.link/lwg2320>`__","select_on_container_copy_construction() takes allocators, not containers","Issaquah","|Complete|"
+"`2322 <https://wg21.link/lwg2322>`__","Associative(initializer_list, stuff) constructors are underspecified","Issaquah","|Complete|"
+"`2323 <https://wg21.link/lwg2323>`__","vector::resize(n, t)'s specification should be simplified","Issaquah","|Complete|"
+"`2324 <https://wg21.link/lwg2324>`__","Insert iterator constructors should use addressof()","Issaquah","|Complete|"
+"`2329 <https://wg21.link/lwg2329>`__","regex_match()/regex_search() with match_results should forbid temporary strings","Issaquah","|Complete|"
+"`2330 <https://wg21.link/lwg2330>`__","regex(""meow"", regex::icase) is technically forbidden but should be permitted","Issaquah","|Complete|"
+"`2332 <https://wg21.link/lwg2332>`__","regex_iterator/regex_token_iterator should forbid temporary regexes","Issaquah","|Complete|"
+"`2339 <https://wg21.link/lwg2339>`__","Wording issue in nth_element","Issaquah","|Complete|"
+"`2341 <https://wg21.link/lwg2341>`__","Inconsistency between basic_ostream::seekp(pos) and basic_ostream::seekp(off, dir)","Issaquah","|Complete|"
+"`2344 <https://wg21.link/lwg2344>`__","quoted()'s interaction with padding is unclear","Issaquah","|Complete|"
+"`2346 <https://wg21.link/lwg2346>`__","integral_constant's member functions should be marked noexcept","Issaquah","|Complete|"
+"`2350 <https://wg21.link/lwg2350>`__","min, max, and minmax should be constexpr","Issaquah","|Complete|"
+"`2356 <https://wg21.link/lwg2356>`__","Stability of erasure in unordered associative containers","Issaquah","|Complete|"
+"`2357 <https://wg21.link/lwg2357>`__","Remaining ""Assignable"" requirement","Issaquah","|Complete|"
+"`2359 <https://wg21.link/lwg2359>`__","How does regex_constants::nosubs affect basic_regex::mark_count()?","Issaquah","|Complete|"
+"`2360 <https://wg21.link/lwg2360>`__","``reverse_iterator::operator*()``\  is unimplementable","Issaquah","|Complete|"
+"`2104 <https://wg21.link/lwg2104>`__","unique_lock move-assignment should not be noexcept","Issaquah","|Complete|"
+"`2186 <https://wg21.link/lwg2186>`__","Incomplete action on async/launch::deferred","Issaquah","|Complete|"
+"`2075 <https://wg21.link/lwg2075>`__","Progress guarantees, lock-free property, and scheduling assumptions","Issaquah","|Complete|"
+"`2288 <https://wg21.link/lwg2288>`__","Inconsistent requirements for shared mutexes","Issaquah","|Complete|"

libcxx/docs/Cxx1yStatusPaperStatus.csv

+"Paper #","Group","Paper Name","Meeting","Status","First released version"
+"`3346 <https://wg21.link/n3346>`__","LWG","Terminology for Container Element Requirements - Rev 1","Kona","|Complete|","3.4"
+"","","","","",""
+"`3421 <https://wg21.link/n3421>`__","LWG","Making Operator Functors greater<>","Portland","|Complete|","3.4"
+"`3462 <https://wg21.link/n3462>`__","LWG","std::result_of and SFINAE","Portland","|Complete|","3.4"
+"`3469 <https://wg21.link/n3469>`__","LWG","Constexpr Library Additions: chrono, v3","Portland","|Complete|","3.4"
+"`3470 <https://wg21.link/n3470>`__","LWG","Constexpr Library Additions: containers, v2","Portland","|Complete|","3.4"
+"`3471 <https://wg21.link/n3471>`__","LWG","Constexpr Library Additions: utilities, v3","Portland","|Complete|","3.4"
+"`3302 <https://wg21.link/n3302>`__","LWG","Constexpr Library Additions: complex, v2","Portland","|Complete|","3.4"
+"","","","","",""
+"`3545 <https://wg21.link/n3545>`__","LWG","An Incremental Improvement to integral_constant","Bristol","|Complete|","3.4"
+"`3644 <https://wg21.link/n3644>`__","LWG","Null Forward Iterators","Bristol","|Complete|","3.4"
+"`3668 <https://wg21.link/n3668>`__","LWG","std::exchange()","Bristol","|Complete|","3.4"
+"`3658 <https://wg21.link/n3658>`__","LWG","Compile-time integer sequences","Bristol","|Complete|","3.4"
+"`3670 <https://wg21.link/n3670>`__","LWG","Addressing Tuples by Type","Bristol","|Complete|","3.4"
+"`3671 <https://wg21.link/n3671>`__","LWG","Making non-modifying sequence operations more robust","Bristol","|Complete|","3.4"
+"`3656 <https://wg21.link/n3656>`__","LWG","make_unique","Bristol","|Complete|","3.4"
+"`3654 <https://wg21.link/n3654>`__","LWG","Quoted Strings","Bristol","|Complete|","3.4"
+"`3642 <https://wg21.link/n3642>`__","LWG","User-defined Literals","Bristol","|Complete|","3.4"
+"`3655 <https://wg21.link/n3655>`__","LWG","TransformationTraits Redux (excluding part 4)","Bristol","|Complete|","3.4"
+"`3657 <https://wg21.link/n3657>`__","LWG","Adding heterogeneous comparison lookup to associative containers","Bristol","|Complete|","3.4"
+"`3672 <https://wg21.link/n3672>`__","LWG","A proposal to add a utility class to represent optional objects","Bristol","*Removed from Draft Standard*","n/a"
+"`3669 <https://wg21.link/n3669>`__","LWG","Fixing constexpr member functions without const","Bristol","|Complete|","3.4"
+"`3662 <https://wg21.link/n3662>`__","LWG","C++ Dynamic Arrays (dynarray)","Bristol","*Removed from Draft Standard*","n/a"
+"`3659 <https://wg21.link/n3659>`__","SG1","Shared Locking in C++","Bristol","|Complete|","3.4"
+"","","","","",""
+"`3779 <https://wg21.link/n3779>`__","LWG","User-defined Literals for std::complex","Chicago","|Complete|","3.4"
+"`3789 <https://wg21.link/n3789>`__","LWG","Constexpr Library Additions: functional","Chicago","|Complete|","3.4"
+"","","","","",""
+"`3924 <https://wg21.link/n3924>`__","LWG","Discouraging rand() in C++14","Issaquah","|Complete|","3.5"
+"`3887 <https://wg21.link/n3887>`__","LWG","Consistent Metafunction Aliases","Issaquah","|Complete|","3.5"
+"`3891 <https://wg21.link/n3891>`__","SG1","A proposal to rename shared_mutex to shared_timed_mutex","Issaquah","|Complete|","3.5"

libcxx/docs/Cxx1zStatus.rst

+.. _cxx1z-status:
+
+================================
+libc++ C++17 Status
+================================
+
+.. include:: Styles.rst
+
+.. contents::
+   :local:
+
+
+Overview
+================================
+
+In November 2014, the C++ standard committee created a draft for the next version of the C++ standard, initially known as "C++1z".
+In February 2017, the C++ standard committee approved this draft, and sent it to ISO for approval as C++17.
+
+This page shows the status of libc++; the status of clang's support of the language features is `here <https://clang.llvm.org/cxx_status.html#cxx17>`__.
+
+.. attention:: Features in unreleased drafts of the standard are subject to change.
+
+The groups that have contributed papers:
+
+-  CWG - Core Language Working group
+-  LWG - Library working group
+-  SG1 - Study group #1 (Concurrency working group)
+
+.. note:: "Nothing to do" means that no library changes were needed to implement this change.
+
+.. _paper-status-cxx1z:
+
+Paper Status
+====================================
+
+.. csv-table::
+   :file: Cxx1zStatusPaperStatus.csv
+   :widths: auto
+
+.. note::
+
+   .. [#note-P0433] P0433: So far, only the ``<string>``, sequence containers, container adaptors and ``<regex>`` portions of P0433 have been implemented.
+   .. [#note-P0607] P0607: The parts of P0607 that are not done are the ``<regex>`` bits.
+
+
+.. _issues-status-cxx1z:
+
+Library Working Group Issues Status
+====================================
+
+.. csv-table::
+   :file: Cxx1zStatusIssuesStatus.csv
+   :widths: auto
+
+Last Updated: 17-Nov-2020

libcxx/docs/Cxx1zStatusIssuesStatus.csv

+"Issue #","Issue Name","Meeting","Status"
+"`2016 <https://wg21.link/LWG2016>`__","Allocators must be no-throw swappable","Urbana","|Complete|"
+"`2118 <https://wg21.link/LWG2376>`__","``unique_ptr``\  for array does not support cv qualification conversion of actual argument","Urbana","|Complete|"
+"`2170 <https://wg21.link/LWG2170>`__","Aggregates cannot be ``DefaultConstructible``\ ","Urbana","|Complete|"
+"`2308 <https://wg21.link/LWG2308>`__","Clarify container destructor requirements w.r.t. ``std::array``\ ","Urbana","|Complete|"
+"`2340 <https://wg21.link/LWG2340>`__","Replacement allocation functions declared as inline","Urbana","|Complete|"
+"`2354 <https://wg21.link/LWG2354>`__","Unnecessary copying when inserting into maps with braced-init syntax","Urbana","|Complete|"
+"`2377 <https://wg21.link/LWG2377>`__","``std::align``\  requirements overly strict","Urbana","|Complete|"
+"`2396 <https://wg21.link/LWG2396>`__","``underlying_type``\  doesn't say what to do for an incomplete enumeration type","Urbana","|Complete|"
+"`2399 <https://wg21.link/LWG2399>`__","``shared_ptr``\ 's constructor from ``unique_ptr``\  should be constrained","Urbana","|Complete|"
+"`2400 <https://wg21.link/LWG2400>`__","``shared_ptr``\ 's ``get_deleter()``\  should use ``addressof()``\ ","Urbana","|Complete|"
+"`2401 <https://wg21.link/LWG2401>`__","``std::function``\  needs more noexcept","Urbana","|Complete|"
+"`2404 <https://wg21.link/LWG2404>`__","``mismatch()``\ 's complexity needs to be updated","Urbana","|Complete|"
+"`2408 <https://wg21.link/LWG2408>`__","SFINAE-friendly ``common_type``\  / ``iterator_traits``\  is missing in C++14","Urbana","|Complete|"
+"","","",""
+"`2106 <https://wg21.link/LWG2106>`__","``move_iterator``\  wrapping iterators returning prvalues","Urbana","|Complete|"
+"`2129 <https://wg21.link/LWG2129>`__","User specializations of ``std::initializer_list``\ ","Urbana","|Complete|"
+"`2212 <https://wg21.link/LWG2212>`__","``tuple_size``\  for ``const pair``\  request <tuple> header","Urbana","|Complete|"
+"`2217 <https://wg21.link/LWG2217>`__","``operator==(sub_match, string)``\  slices on embedded '\0's","Urbana","|Complete|"
+"`2230 <https://wg21.link/LWG2230>`__","""see below"" for ``initializer_list``\  constructors of unordered containers","Urbana","|Complete|"
+"`2233 <https://wg21.link/LWG2233>`__","``bad_function_call::what()``\  unhelpful","Urbana","|Complete|"
+"`2266 <https://wg21.link/LWG2266>`__","``vector``\  and ``deque``\  have incorrect insert requirements","Urbana","|Complete|"
+"`2325 <https://wg21.link/LWG2325>`__","``minmax_element()``\ 's behavior differing from ``max_element()``\ 's should be noted","Urbana","|Complete|"
+"`2361 <https://wg21.link/LWG2361>`__","Apply 2299 resolution throughout library","Urbana","|Complete|"
+"`2365 <https://wg21.link/LWG2365>`__","Missing noexcept in ``shared_ptr::shared_ptr(nullptr_t)``\ ","Urbana","|Complete|"
+"`2376 <https://wg21.link/LWG2376>`__","``bad_weak_ptr::what()``\  overspecified","Urbana","|Complete|"
+"`2387 <https://wg21.link/LWG2387>`__","More nested types that must be accessible and unambiguous","Urbana","|Complete|"
+"","","",""
+"`2059 <https://wg21.link/LWG2059>`__","C++0x ambiguity problem with map::erase","Lenexa","|Complete|"
+"`2063 <https://wg21.link/LWG2063>`__","Contradictory requirements for string move assignment","Lenexa","|Complete|"
+"`2076 <https://wg21.link/LWG2076>`__","Bad CopyConstructible requirement in set constructors","Lenexa","|Complete|"
+"`2160 <https://wg21.link/LWG2160>`__","Unintended destruction ordering-specification of resize","Lenexa","|Complete|"
+"`2168 <https://wg21.link/LWG2168>`__","Inconsistent specification of uniform_real_distribution constructor","Lenexa","|Complete|"
+"`2239 <https://wg21.link/LWG2239>`__","min/max/minmax requirements","Lenexa","|Complete|"
+"`2364 <https://wg21.link/LWG2364>`__","deque and vector pop_back don't specify iterator invalidation requirements","Lenexa","|Complete|"
+"`2369 <https://wg21.link/LWG2369>`__","constexpr max(initializer_list) vs max_element","Lenexa","|Complete|"
+"`2378 <https://wg21.link/LWG2378>`__","Behaviour of standard exception types","Lenexa","|Complete|"
+"`2403 <https://wg21.link/LWG2403>`__","stof() should call strtof() and wcstof()","Lenexa","|Complete|"
+"`2406 <https://wg21.link/LWG2406>`__","negative_binomial_distribution should reject p == 1","Lenexa","|Complete|"
+"`2407 <https://wg21.link/LWG2407>`__","packaged_task(allocator_arg_t, const Allocator&, F&&) should neither be constrained nor explicit","Lenexa","|Complete|"
+"`2411 <https://wg21.link/LWG2411>`__","shared_ptr is only contextually convertible to bool","Lenexa","|Complete|"
+"`2415 <https://wg21.link/LWG2415>`__","Inconsistency between unique_ptr and shared_ptr","Lenexa","|Complete|"
+"`2420 <https://wg21.link/LWG2420>`__","function<void(ArgTypes...)> does not discard the return value of the target object","Lenexa","|Complete|"
+"`2425 <https://wg21.link/LWG2425>`__","``operator delete(void*, size_t)``\  doesn't invalidate pointers sufficiently","Lenexa","|Complete|"
+"`2427 <https://wg21.link/LWG2427>`__","Container adaptors as sequence containers, redux","Lenexa","|Complete|"
+"`2428 <https://wg21.link/LWG2428>`__","""External declaration"" used without being defined","Lenexa","|Complete|"
+"`2433 <https://wg21.link/LWG2433>`__","``uninitialized_copy()``\ /etc. should tolerate overloaded operator&","Lenexa","|Complete|"
+"`2434 <https://wg21.link/LWG2434>`__","``shared_ptr::use_count()``\  is efficient","Lenexa","|Complete|"
+"`2437 <https://wg21.link/LWG2437>`__","``iterator_traits::reference``\  can and can't be void","Lenexa","|Complete|"
+"`2438 <https://wg21.link/LWG2438>`__","``std::iterator``\  inheritance shouldn't be mandated","Lenexa","|Complete|"
+"`2439 <https://wg21.link/LWG2439>`__","``unique_copy()``\  sometimes can't fall back to reading its output","Lenexa","|Complete|"
+"`2440 <https://wg21.link/LWG2440>`__","``seed_seq::size()``\  should be noexcept","Lenexa","|Complete|"
+"`2442 <https://wg21.link/LWG2442>`__","``call_once()``\  shouldn't DECAY_COPY()","Lenexa","|Complete|"
+"`2448 <https://wg21.link/LWG2448>`__","Non-normative Container destructor specification","Lenexa","|Complete|"
+"`2454 <https://wg21.link/LWG2454>`__","Add ``raw_storage_iterator::base()``\  member","Lenexa","|Complete|"
+"`2455 <https://wg21.link/LWG2455>`__","Allocator default construction should be allowed to throw","Lenexa","|Complete|"
+"`2458 <https://wg21.link/LWG2458>`__","N3778 and new library deallocation signatures","Lenexa","|Complete|"
+"`2459 <https://wg21.link/LWG2459>`__","``std::polar``\  should require a non-negative rho","Lenexa","|Complete|"
+"`2464 <https://wg21.link/LWG2464>`__","``try_emplace``\  and ``insert_or_assign``\  misspecified","Lenexa","|Complete|"
+"`2467 <https://wg21.link/LWG2467>`__","``is_always_equal``\  has slightly inconsistent default","Lenexa","|Complete|"
+"`2470 <https://wg21.link/LWG2470>`__","Allocator's destroy function should be allowed to fail to instantiate","Lenexa","|Complete|"
+"`2482 <https://wg21.link/LWG2482>`__","[c.strings] Table 73 mentions nonexistent functions","Lenexa","|Complete|"
+"`2488 <https://wg21.link/LWG2488>`__","Placeholders should be allowed and encouraged to be constexpr","Lenexa","|Complete|"
+"","","",""
+"`1169 <https://wg21.link/LWG1169>`__","``num_get``\  not fully compatible with ``strto*``\ ","Kona","|Complete|"
+"`2072 <https://wg21.link/LWG2072>`__","Unclear wording about capacity of temporary buffers","Kona","|Complete|"
+"`2101 <https://wg21.link/LWG2101>`__","Some transformation types can produce impossible types","Kona","|Complete|"
+"`2111 <https://wg21.link/LWG2111>`__","Which ``unexpected``\ &#47;``terminate``\  handler is called from the exception handling runtime?","Kona","|Complete|"
+"`2119 <https://wg21.link/LWG2119>`__","Missing ``hash``\  specializations for extended integer types","Kona","|Complete|"
+"`2127 <https://wg21.link/LWG2127>`__","Move-construction with ``raw_storage_iterator``\ ","Kona","|Complete|"
+"`2133 <https://wg21.link/LWG2133>`__","Attitude to overloaded comma for iterators","Kona","|Complete|"
+"`2156 <https://wg21.link/LWG2156>`__","Unordered containers' ``reserve(n)``\  reserves for ``n-1``\  elements","Kona","|Complete|"
+"`2218 <https://wg21.link/LWG2218>`__","Unclear how containers use ``allocator_traits::construct()``\ ","Kona","|Complete|"
+"`2219 <https://wg21.link/LWG2219>`__","``*INVOKE*``\ -ing a pointer to member with a ``reference_wrapper``\  as the object expression","Kona","|Complete|"
+"`2224 <https://wg21.link/LWG2224>`__","Ambiguous status of access to non-live objects","Kona","|Complete|"
+"`2234 <https://wg21.link/LWG2234>`__","``assert()``\  should allow usage in constant expressions","Kona","|Complete|"
+"`2244 <https://wg21.link/LWG2244>`__","Issue on ``basic_istream::seekg``\ ","Kona","|Complete|"
+"`2250 <https://wg21.link/LWG2250>`__","Follow-up On Library Issue 2207","Kona","|Complete|"
+"`2259 <https://wg21.link/LWG2259>`__","Issues in 17.6.5.5 rules for member functions","Kona","|Complete|"
+"`2273 <https://wg21.link/LWG2273>`__","``regex_match``\  ambiguity","Kona","|Complete|"
+"`2336 <https://wg21.link/LWG2336>`__","``is_trivially_constructible``\ /``is_trivially_assignable``\  traits are always false","Kona","|Complete|"
+"`2353 <https://wg21.link/LWG2353>`__","``std::next``\  is over-constrained","Kona","|Complete|"
+"`2367 <https://wg21.link/LWG2367>`__","``pair``\  and ``tuple``\  are not correctly implemented for ``is_constructible``\  with no args","Kona","|Complete|"
+"`2380 <https://wg21.link/LWG2380>`__","May ``<cstdlib>``\  provide ``long ::abs(long)``\  and ``long long ::abs(long long)``\ ?","Kona","|Complete|"
+"`2384 <https://wg21.link/LWG2384>`__","Allocator's ``deallocate``\  function needs better specification","Kona","|Complete|"
+"`2385 <https://wg21.link/LWG2385>`__","``function::assign``\  allocator argument doesn't make sense","Kona","|Complete|"
+"`2435 <https://wg21.link/LWG2435>`__","``reference_wrapper::operator()``\ 's Remark should be deleted","Kona","|Complete|"
+"`2447 <https://wg21.link/LWG2447>`__","Allocators and ``volatile``\ -qualified value types","Kona","|Complete|"
+"`2462 <https://wg21.link/LWG2462>`__","``std::ios_base::failure``\  is overspecified","Kona","|Complete|"
+"`2466 <https://wg21.link/LWG2466>`__","``allocator_traits::max_size()``\  default behavior is incorrect","Kona","|Complete|"
+"`2469 <https://wg21.link/LWG2469>`__","Wrong specification of Requires clause of ``operator[]``\  for ``map``\  and ``unordered_map``\ ","Kona","|Complete|"
+"`2473 <https://wg21.link/LWG2473>`__","``basic_filebuf``\ 's relation to C ``FILE``\  semantics","Kona","|Complete|"
+"`2476 <https://wg21.link/LWG2476>`__","``scoped_allocator_adaptor``\  is not assignable","Kona","|Complete|"
+"`2477 <https://wg21.link/LWG2477>`__","Inconsistency of wordings in ``std::vector::erase()``\  and ``std::deque::erase()``\ ","Kona","|Complete|"
+"`2483 <https://wg21.link/LWG2483>`__","``throw_with_nested()``\  should use ``is_final``\ ","Kona","|Complete|"
+"`2484 <https://wg21.link/LWG2484>`__","``rethrow_if_nested()``\  is doubly unimplementable","Kona","|Complete|"
+"`2485 <https://wg21.link/LWG2485>`__","``get()``\  should be overloaded for ``const tuple&&``\ ","Kona","|Complete|"
+"`2486 <https://wg21.link/LWG2486>`__","``mem_fn()``\  should be required to use perfect forwarding","Kona","|Complete|"
+"`2487 <https://wg21.link/LWG2487>`__","``bind()``\  should be ``const``\ -overloaded, not *cv*-overloaded","Kona","|Complete|"
+"`2489 <https://wg21.link/LWG2489>`__","``mem_fn()``\  should be ``noexcept``\ ","Kona","|Complete|"
+"`2492 <https://wg21.link/LWG2492>`__","Clarify requirements for ``comp``\ ","Kona","|Complete|"
+"`2495 <https://wg21.link/LWG2495>`__","There is no such thing as an Exception Safety element","Kona","|Complete|"
+"","","",""
+"`2192 <https://wg21.link/LWG2192>`__","Validity and return type of ``std::abs(0u)``\  is unclear","Jacksonville","|Complete|"
+"`2276 <https://wg21.link/LWG2276>`__","Missing requirement on ``std::promise::set_exception``\ ","Jacksonville","|Complete|"
+"`2296 <https://wg21.link/LWG2296>`__","``std::addressof``\  should be ``constexpr``\ ","Jacksonville","Complete (Clang Only)"
+"`2450 <https://wg21.link/LWG2450>`__","``(greater|less|greater_equal|less_equal)<void>``\  do not yield a total order for pointers","Jacksonville","|Complete|"
+"`2520 <https://wg21.link/LWG2520>`__","N4089 broke initializing ``unique_ptr<T[]>``\  from a ``nullptr``\ ","Jacksonville","|Complete|"
+"`2522 <https://wg21.link/LWG2522>`__","[fund.ts.v2] Contradiction in ``set_default_resource``\  specification","Jacksonville","|Complete|"
+"`2523 <https://wg21.link/LWG2523>`__","``std::promise``\  synopsis shows two ``set_value_at_thread_exit()``\ 's for no apparent reason","Jacksonville","|Complete|"
+"`2537 <https://wg21.link/LWG2537>`__","Constructors for ``priority_queue``\  taking allocators should call ``make_heap``\ ","Jacksonville","|Complete|"
+"`2539 <https://wg21.link/LWG2539>`__","[fund.ts.v2] ``invocation_trait``\  definition definition doesn't work for surrogate call functions","Jacksonville",""
+"`2545 <https://wg21.link/LWG2545>`__","Simplify wording for ``bind``\  without explicitly specified return type","Jacksonville","|Complete|"
+"`2557 <https://wg21.link/LWG2557>`__","Logical operator traits are broken in the zero-argument case","Jacksonville","|Complete|"
+"`2558 <https://wg21.link/LWG2558>`__","[fund.ts.v2] Logical operator traits are broken in the zero-argument case","Jacksonville","|Complete|"
+"`2559 <https://wg21.link/LWG2559>`__","Error in LWG 2234's resolution","Jacksonville","|Complete|"
+"`2560 <https://wg21.link/LWG2560>`__","``is_constructible``\  underspecified when applied to a function type","Jacksonville","Broken in 3.6; See r261653."
+"`2565 <https://wg21.link/LWG2565>`__","``std::function``\ 's move constructor should guarantee nothrow for ``reference_wrapper``\ s and function pointers","Jacksonville","|Complete|"
+"`2566 <https://wg21.link/LWG2566>`__","Requirements on the first template parameter of container adaptors","Jacksonville","|Complete|"
+"`2571 <https://wg21.link/LWG2571>`__","|sect|\ [map.modifiers]/2 imposes nonsensical requirement on ``insert(InputIterator, InputIterator)``\ ","Jacksonville","|Complete|"
+"`2572 <https://wg21.link/LWG2572>`__","The remarks for ``shared_ptr::operator*``\  should apply to *cv*-qualified ``void``\  as well","Jacksonville","|Complete|"
+"`2574 <https://wg21.link/LWG2574>`__","[fund.ts.v2] ``std::experimental::function::operator=(F&&)``\  should be constrained","Jacksonville","|Complete|"
+"`2575 <https://wg21.link/LWG2575>`__","[fund.ts.v2] ``experimental::function::assign``\  should be removed","Jacksonville",""
+"`2576 <https://wg21.link/LWG2576>`__","``istream_iterator``\  and ``ostream_iterator``\  should use ``std::addressof``\ ","Jacksonville","|Complete|"
+"`2577 <https://wg21.link/LWG2577>`__","``{shared,unique}_lock``\  should use ``std::addressof``\ ","Jacksonville","|Complete|"
+"`2579 <https://wg21.link/LWG2579>`__","Inconsistency wrt Allocators in ``basic_string``\  assignment vs. ``basic_string::assign``\ ","Jacksonville","|Complete|"
+"`2581 <https://wg21.link/LWG2581>`__","Specialization of ``<type_traits>``\  variable templates should be prohibited","Jacksonville","|Complete|"
+"`2582 <https://wg21.link/LWG2582>`__","|sect|\ [res.on.functions]/2's prohibition against incomplete types shouldn't apply to type traits","Jacksonville","|Complete|"
+"`2583 <https://wg21.link/LWG2583>`__","There is no way to supply an allocator for ``basic_string(str, pos)``\ ","Jacksonville","|Complete|"
+"`2585 <https://wg21.link/LWG2585>`__","``forward_list::resize(size_type, const value_type&)``\  effects incorrect","Jacksonville","|Complete|"
+"`2586 <https://wg21.link/LWG2586>`__","Wrong value category used in ``scoped_allocator_adaptor::construct()``\ ","Jacksonville","|Complete|"
+"`2590 <https://wg21.link/LWG2590>`__","Aggregate initialization for ``std::array``\ ","Jacksonville","|Complete|"
+"","","",""
+"`2181 <https://wg21.link/LWG2181>`__","Exceptions from seed sequence operations","Oulu","|Complete|"
+"`2309 <https://wg21.link/LWG2309>`__","mutex::lock() should not throw device_or_resource_busy","Oulu","|Complete|"
+"`2310 <https://wg21.link/LWG2310>`__","Public exposition only member in std::array","Oulu","|Complete|"
+"`2312 <https://wg21.link/LWG2312>`__","tuple's constructor constraints need to be phrased more precisely","Oulu","|Complete|"
+"`2328 <https://wg21.link/LWG2328>`__","Rvalue stream extraction should use perfect forwarding","Oulu","|Complete|"
+"`2393 <https://wg21.link/LWG2393>`__","std::function's Callable definition is broken","Oulu","|Complete|"
+"`2422 <https://wg21.link/LWG2422>`__","``std::numeric_limits<T>::is_modulo``\  description: ""most machines"" errata","Oulu","|Complete|"
+"`2426 <https://wg21.link/LWG2426>`__","Issue about compare_exchange","Oulu",""
+"`2436 <https://wg21.link/LWG2436>`__","Comparators for associative containers should always be CopyConstructible","Oulu","|Complete|"
+"`2441 <https://wg21.link/LWG2441>`__","Exact-width atomic typedefs should be provided","Oulu","|Complete|"
+"`2451 <https://wg21.link/LWG2451>`__","[fund.ts.v2] optional should 'forward' T's implicit conversions","Oulu","|Nothing To Do|"
+"`2509 <https://wg21.link/LWG2509>`__","[fund.ts.v2] any_cast doesn't work with rvalue reference targets and cannot move with a value target","Oulu","|Complete|"
+"`2516 <https://wg21.link/LWG2516>`__","[fund.ts.v2] Public ""exposition only"" members in observer_ptr","Oulu",""
+"`2542 <https://wg21.link/LWG2542>`__","Missing const requirements for associative containers","Oulu",""
+"`2549 <https://wg21.link/LWG2549>`__","Tuple EXPLICIT constructor templates that take tuple parameters end up taking references to temporaries and will create dangling references","Oulu","|Complete|"
+"`2550 <https://wg21.link/LWG2550>`__","Wording of unordered container's clear() method complexity","Oulu","|Complete|"
+"`2551 <https://wg21.link/LWG2551>`__","[fund.ts.v2] ""Exception safety"" cleanup in library fundamentals required","Oulu","|Complete|"
+"`2555 <https://wg21.link/LWG2555>`__","[fund.ts.v2] No handling for over-aligned types in optional","Oulu","|Complete|"
+"`2573 <https://wg21.link/LWG2573>`__","[fund.ts.v2] std::hash<std::experimental::shared_ptr> does not work for arrays","Oulu",""
+"`2596 <https://wg21.link/LWG2596>`__","vector::data() should use addressof","Oulu","|Complete|"
+"`2667 <https://wg21.link/LWG2667>`__","path::root_directory() description is confusing","Oulu","|Complete|"
+"`2669 <https://wg21.link/LWG2669>`__","recursive_directory_iterator effects refers to non-existent functions","Oulu","|Complete|"
+"`2670 <https://wg21.link/LWG2670>`__","system_complete refers to undefined variable 'base'","Oulu","|Complete|"
+"`2671 <https://wg21.link/LWG2671>`__","Errors in Copy","Oulu","|Complete|"
+"`2673 <https://wg21.link/LWG2673>`__","status() effects cannot be implemented as specified","Oulu","|Complete|"
+"`2674 <https://wg21.link/LWG2674>`__","Bidirectional iterator requirement on path::iterator is very expensive","Oulu","|Complete|"
+"`2683 <https://wg21.link/LWG2683>`__","filesystem::copy() says ""no effects""","Oulu","|Complete|"
+"`2684 <https://wg21.link/LWG2684>`__","priority_queue lacking comparator typedef","Oulu","|Complete|"
+"`2685 <https://wg21.link/LWG2685>`__","shared_ptr deleters must not throw on move construction","Oulu","|Complete|"
+"`2687 <https://wg21.link/LWG2687>`__","{inclusive,exclusive}_scan misspecified","Oulu",""
+"`2688 <https://wg21.link/LWG2688>`__","clamp misses preconditions and has extraneous condition on result","Oulu","|Complete|"
+"`2689 <https://wg21.link/LWG2689>`__","Parallel versions of std::copy and std::move shouldn't be in order","Oulu",""
+"`2698 <https://wg21.link/LWG2698>`__","Effect of assign() on iterators/pointers/references","Oulu","|Complete|"
+"`2704 <https://wg21.link/LWG2704>`__","recursive_directory_iterator's members should require '``*this`` is dereferenceable'","Oulu","|Complete|"
+"`2706 <https://wg21.link/LWG2706>`__","Error reporting for recursive_directory_iterator::pop() is under-specified","Oulu","|Complete|"
+"`2707 <https://wg21.link/LWG2707>`__","path construction and assignment should have ""string_type&&"" overloads","Oulu","|Complete|"
+"`2709 <https://wg21.link/LWG2709>`__","offsetof is unnecessarily imprecise","Oulu",""
+"`2710 <https://wg21.link/LWG2710>`__","""Effects: Equivalent to ..."" doesn't count ""Synchronization:"" as determined semantics","Oulu","|Complete|"
+"`2711 <https://wg21.link/LWG2711>`__","path is convertible from approximately everything under the sun","Oulu","|Complete|"
+"`2716 <https://wg21.link/LWG2716>`__","Specification of shuffle and sample disallows lvalue URNGs","Oulu","|Complete|"
+"`2718 <https://wg21.link/LWG2718>`__","Parallelism bug in [algorithms.parallel.exec] p2","Oulu",""
+"`2719 <https://wg21.link/LWG2719>`__","permissions function should not be noexcept due to narrow contract","Oulu","|Complete|"
+"`2720 <https://wg21.link/LWG2720>`__","permissions function incorrectly specified for symlinks","Oulu","|Complete|"
+"`2721 <https://wg21.link/LWG2721>`__","remove_all has incorrect post conditions","Oulu","|Complete|"
+"`2723 <https://wg21.link/LWG2723>`__","Do directory_iterator and recursive_directory_iterator become the end iterator upon error?","Oulu","|Complete|"
+"`2724 <https://wg21.link/LWG2724>`__","The protected virtual member functions of memory_resource should be private","Oulu",""
+"`2725 <https://wg21.link/LWG2725>`__","filesystem::exists(const path&, error_code&) error reporting","Oulu","|Complete|"
+"`2726 <https://wg21.link/LWG2726>`__","``[recursive_]directory_iterator::increment(error_code&)`` is underspecified","Oulu","|Complete|"
+"`2727 <https://wg21.link/LWG2727>`__","Parallel algorithms with constexpr specifier","Oulu",""
+"`2728 <https://wg21.link/LWG2728>`__","status(p).permissions() and symlink_status(p).permissions() are not specified","Oulu","|Complete|"
+"","","",""
+"`2062 <https://wg21.link/LWG2062>`__","Effect contradictions w/o no-throw guarantee of std::function swaps","Issaquah","|Complete|"
+"`2166 <https://wg21.link/LWG2166>`__","Heap property underspecified?","Issaquah",""
+"`2221 <https://wg21.link/LWG2221>`__","No formatted output operator for nullptr","Issaquah","|Complete|"
+"`2223 <https://wg21.link/LWG2223>`__","shrink_to_fit effect on iterator validity","Issaquah","|Complete|"
+"`2261 <https://wg21.link/LWG2261>`__","Are containers required to use their 'pointer' type internally?","Issaquah",""
+"`2394 <https://wg21.link/LWG2394>`__","locale::name specification unclear - what is implementation-defined?","Issaquah","|Complete|"
+"`2460 <https://wg21.link/LWG2460>`__","LWG issue 2408 and value categories","Issaquah","|Complete|"
+"`2468 <https://wg21.link/LWG2468>`__","Self-move-assignment of library types","Issaquah",""
+"`2475 <https://wg21.link/LWG2475>`__","Allow overwriting of std::basic_string terminator with charT() to allow cleaner interoperation with legacy APIs","Issaquah","|Complete|"
+"`2503 <https://wg21.link/LWG2503>`__","multiline option should be added to syntax_option_type","Issaquah","|Complete|"
+"`2510 <https://wg21.link/LWG2510>`__","Tag types should not be DefaultConstructible","Issaquah","|Complete|"
+"`2514 <https://wg21.link/LWG2514>`__","Type traits must not be final","Issaquah","|Complete|"
+"`2518 <https://wg21.link/LWG2518>`__","[fund.ts.v2] Non-member swap for propagate_const should call member swap","Issaquah","|Complete|"
+"`2519 <https://wg21.link/LWG2519>`__","Iterator operator-= has gratuitous undefined behaviour","Issaquah","|Complete|"
+"`2521 <https://wg21.link/LWG2521>`__","[fund.ts.v2] weak_ptr's converting move constructor should be modified as well for array support","Issaquah",""
+"`2525 <https://wg21.link/LWG2525>`__","[fund.ts.v2] get_memory_resource should be const and noexcept","Issaquah",""
+"`2527 <https://wg21.link/LWG2527>`__","[fund.ts.v2] ALLOCATOR_OF for function::operator= has incorrect default","Issaquah",""
+"`2531 <https://wg21.link/LWG2531>`__","future::get should explicitly state that the shared state is released","Issaquah",""
+"`2534 <https://wg21.link/LWG2534>`__","Constrain rvalue stream operators","Issaquah",""
+"`2536 <https://wg21.link/LWG2536>`__","What should <complex.h> do?","Issaquah","|Complete|"
+"`2540 <https://wg21.link/LWG2540>`__","unordered_multimap::insert hint iterator","Issaquah","|Complete|"
+"`2543 <https://wg21.link/LWG2543>`__","LWG 2148 (hash support for enum types) seems under-specified","Issaquah","|Complete|"
+"`2544 <https://wg21.link/LWG2544>`__","``istreambuf_iterator(basic_streambuf<charT, traits>* s)``\  effects unclear when s is 0","Issaquah","|Complete|"
+"`2556 <https://wg21.link/LWG2556>`__","Wide contract for future::share()","Issaquah","|Complete|"
+"`2562 <https://wg21.link/LWG2562>`__","Consistent total ordering of pointers by comparison functors","Issaquah",""
+"`2567 <https://wg21.link/LWG2567>`__","Specification of logical operator traits uses BaseCharacteristic, which is defined only for UnaryTypeTraits and BinaryTypeTraits","Issaquah","|Complete|"
+"`2568 <https://wg21.link/LWG2568>`__","[fund.ts.v2] Specification of logical operator traits uses BaseCharacteristic, which is defined only for UnaryTypeTraits and BinaryTypeTraits","Issaquah",""
+"`2569 <https://wg21.link/LWG2569>`__","conjunction and disjunction requirements are too strict","Issaquah","|Complete|"
+"`2570 <https://wg21.link/LWG2570>`__","[fund.ts.v2] conjunction and disjunction requirements are too strict","Issaquah",""
+"`2578 <https://wg21.link/LWG2578>`__","Iterator requirements should reference iterator traits","Issaquah","|Complete|"
+"`2584 <https://wg21.link/LWG2584>`__","<regex> ECMAScript IdentityEscape is ambiguous","Issaquah",""
+"`2587 <https://wg21.link/LWG2587>`__","""Convertible to bool"" requirement in conjunction and disjunction","Issaquah","Resolved by 2567"
+"`2588 <https://wg21.link/LWG2588>`__","[fund.ts.v2] ""Convertible to bool"" requirement in conjunction and disjunction","Issaquah",""
+"`2589 <https://wg21.link/LWG2589>`__","match_results can't satisfy the requirements of a container","Issaquah","|Complete|"
+"`2591 <https://wg21.link/LWG2591>`__","std::function's member template target() should not lead to undefined behaviour","Issaquah","|Complete|"
+"`2598 <https://wg21.link/LWG2598>`__","addressof works on temporaries","Issaquah","|Complete|"
+"`2664 <https://wg21.link/LWG2664>`__","operator/ (and other append) semantics not useful if argument has root","Issaquah","|Complete|"
+"`2665 <https://wg21.link/LWG2665>`__","remove_filename() post condition is incorrect","Issaquah","|Complete|"
+"`2672 <https://wg21.link/LWG2672>`__","Should ``is_empty``\  use error_code in its specification?","Issaquah","|Complete|"
+"`2678 <https://wg21.link/LWG2678>`__","std::filesystem enum classes overspecified","Issaquah","|Complete|"
+"`2679 <https://wg21.link/LWG2679>`__","Inconsistent Use of Effects and Equivalent To","Issaquah","|Complete|"
+"`2680 <https://wg21.link/LWG2680>`__","Add ""Equivalent to"" to filesystem","Issaquah","|Complete|"
+"`2681 <https://wg21.link/LWG2681>`__","filesystem::copy() cannot copy symlinks","Issaquah","|Complete|"
+"`2682 <https://wg21.link/LWG2682>`__","filesystem::copy() won't create a symlink to a directory","Issaquah","|Complete|"
+"`2686 <https://wg21.link/LWG2686>`__","Why is std::hash specialized for error_code, but not error_condition?","Issaquah","|Complete|"
+"`2694 <https://wg21.link/LWG2694>`__","Application of LWG 436 accidentally deleted definition of ""facet""","Issaquah","|Complete|"
+"`2696 <https://wg21.link/LWG2696>`__","Interaction between make_shared and enable_shared_from_this is underspecified","Issaquah","|Nothing To Do|"
+"`2699 <https://wg21.link/LWG2699>`__","Missing restriction in [numeric.requirements]","Issaquah","|Complete|"
+"`2712 <https://wg21.link/LWG2712>`__","copy_file(from, to, ...) has a number of unspecified error conditions","Issaquah","|Complete|"
+"`2722 <https://wg21.link/LWG2722>`__","equivalent incorrectly specifies throws clause","Issaquah","|Complete|"
+"`2729 <https://wg21.link/LWG2729>`__","Missing SFINAE on std::pair::operator=","Issaquah",""
+"`2732 <https://wg21.link/LWG2732>`__","Questionable specification of path::operator/= and path::append","Issaquah","|Complete|"
+"`2733 <https://wg21.link/LWG2733>`__","[fund.ts.v2] gcd / lcm and bool","Issaquah","|Complete|"
+"`2735 <https://wg21.link/LWG2735>`__","std::abs(short), std::abs(signed char) and others should return int instead of double in order to be compatible with C++98 and C","Issaquah","|Complete|"
+"`2736 <https://wg21.link/LWG2736>`__","nullopt_t insufficiently constrained","Issaquah","|Complete|"
+"`2738 <https://wg21.link/LWG2738>`__","``is_constructible``\  with void types","Issaquah","|Complete|"
+"`2739 <https://wg21.link/LWG2739>`__","Issue with time_point non-member subtraction with an unsigned duration","Issaquah","|Complete|"
+"`2740 <https://wg21.link/LWG2740>`__","constexpr optional<T>::operator->","Issaquah","|Complete|"
+"`2742 <https://wg21.link/LWG2742>`__","Inconsistent string interface taking string_view","Issaquah","|Complete|"
+"`2744 <https://wg21.link/LWG2744>`__","any's in_place constructors","Issaquah","|Complete|"
+"`2745 <https://wg21.link/LWG2745>`__","[fund.ts.v2] Implementability of LWG 2451","Issaquah","|Complete|"
+"`2747 <https://wg21.link/LWG2747>`__","Possibly redundant std::move in [alg.foreach]","Issaquah","|Complete|"
+"`2748 <https://wg21.link/LWG2748>`__","swappable traits for optionals","Issaquah","|Complete|"
+"`2749 <https://wg21.link/LWG2749>`__","swappable traits for variants","Issaquah","|Complete|"
+"`2750 <https://wg21.link/LWG2750>`__","[fund.ts.v2] LWG 2451 conversion constructor constraint","Issaquah","|Nothing To Do|"
+"`2752 <https://wg21.link/LWG2752>`__","""Throws:"" clauses of async and packaged_task are unimplementable","Issaquah",""
+"`2755 <https://wg21.link/LWG2755>`__","[string.view.io] uses non-existent basic_string_view::to_string function","Issaquah","|Complete|"
+"`2756 <https://wg21.link/LWG2756>`__","C++ WP optional<T> should 'forward' T's implicit conversions","Issaquah","|Complete|"
+"`2758 <https://wg21.link/LWG2758>`__","std::string{}.assign(""ABCDE"", 0, 1) is ambiguous","Issaquah","|Complete|"
+"`2759 <https://wg21.link/LWG2759>`__","gcd / lcm and bool for the WP","Issaquah","|Complete|"
+"`2760 <https://wg21.link/LWG2760>`__","non-const basic_string::data should not invalidate iterators","Issaquah","|Complete|"
+"`2765 <https://wg21.link/LWG2765>`__","Did LWG 1123 go too far?","Issaquah","|Complete|"
+"`2767 <https://wg21.link/LWG2767>`__","not_fn call_wrapper can form invalid types","Issaquah","|Complete|"
+"`2769 <https://wg21.link/LWG2769>`__","Redundant const in the return type of any_cast(const any&)","Issaquah","|Complete|"
+"`2771 <https://wg21.link/LWG2771>`__","Broken Effects of some basic_string::compare functions in terms of basic_string_view","Issaquah","|Complete|"
+"`2773 <https://wg21.link/LWG2773>`__","Making std::ignore constexpr","Issaquah","|Complete|"
+"`2777 <https://wg21.link/LWG2777>`__","basic_string_view::copy should use char_traits::copy","Issaquah","|Complete|"
+"`2778 <https://wg21.link/LWG2778>`__","basic_string_view is missing constexpr","Issaquah","|Complete|"
+"","","",""
+"`2260 <https://wg21.link/LWG2260>`__","Missing requirement for Allocator::pointer","Kona","|Complete|"
+"`2676 <https://wg21.link/LWG2676>`__","Provide filesystem::path overloads for File-based streams","Kona","|Complete|"
+"`2768 <https://wg21.link/LWG2768>`__","any_cast and move semantics","Kona","|Complete|"
+"`2769 <https://wg21.link/LWG2769>`__","Redundant const in the return type of any_cast(const any&)","Kona","|Complete|"
+"`2781 <https://wg21.link/LWG2781>`__","Contradictory requirements for std::function and std::reference_wrapper","Kona","|Complete|"
+"`2782 <https://wg21.link/LWG2782>`__","scoped_allocator_adaptor constructors must be constrained","Kona","|Complete|"
+"`2784 <https://wg21.link/LWG2784>`__","Resolution to LWG 2484 is missing ""otherwise, no effects"" and is hard to parse","Kona","|Complete|"
+"`2785 <https://wg21.link/LWG2785>`__","quoted should work with basic_string_view","Kona","|Complete|"
+"`2786 <https://wg21.link/LWG2786>`__","Annex C should mention shared_ptr changes for array support","Kona","|Complete|"
+"`2787 <https://wg21.link/LWG2787>`__","|sect|\ [file_status.cons] doesn't match class definition","Kona","|Complete|"
+"`2788 <https://wg21.link/LWG2788>`__","basic_string range mutators unintentionally require a default constructible allocator","Kona","|Complete|"
+"`2789 <https://wg21.link/LWG2789>`__","Equivalence of contained objects","Kona","|Complete|"
+"`2790 <https://wg21.link/LWG2790>`__","Missing specification of istreambuf_iterator::operator->","Kona","|Complete|"
+"`2794 <https://wg21.link/LWG2794>`__","Missing requirements for allocator pointers","Kona","|Nothing To Do|"
+"`2795 <https://wg21.link/LWG2795>`__","|sect|\ [global.functions] provides incorrect example of ADL use","Kona","|Complete|"
+"`2796 <https://wg21.link/LWG2796>`__","tuple should be a literal type","Kona","|Complete|"
+"`2801 <https://wg21.link/LWG2801>`__","Default-constructibility of unique_ptr","Kona","|Complete|"
+"`2802 <https://wg21.link/LWG2802>`__","shared_ptr constructor requirements for a deleter","Kona",""
+"`2804 <https://wg21.link/LWG2804>`__","Unconditional constexpr default constructor for istream_iterator","Kona","|Complete|"
+"`2806 <https://wg21.link/LWG2806>`__","Base class of bad_optional_access","Kona","|Complete|"
+"`2807 <https://wg21.link/LWG2807>`__","std::invoke should use ``std::is_nothrow_callable``\ ","Kona","|Complete|"
+"`2812 <https://wg21.link/LWG2812>`__","Range access is available with <string_view>","Kona","|Complete|"
+"`2824 <https://wg21.link/LWG2824>`__","list::sort should say that the order of elements is unspecified if an exception is thrown","Kona","|Complete|"
+"`2826 <https://wg21.link/LWG2826>`__","string_view iterators use old wording","Kona","|Complete|"
+"`2834 <https://wg21.link/LWG2834>`__","Resolution LWG 2223 is missing wording about end iterators","Kona","|Complete|"
+"`2835 <https://wg21.link/LWG2835>`__","LWG 2536 seems to misspecify <tgmath.h>","Kona","|Complete|"
+"`2837 <https://wg21.link/LWG2837>`__","gcd and lcm should support a wider range of input values","Kona","|Complete|"
+"`2838 <https://wg21.link/LWG2838>`__","is_literal_type specification needs a little cleanup","Kona","|Complete|"
+"`2842 <https://wg21.link/LWG2842>`__","in_place_t check for optional::optional(U&&) should decay U","Kona","|Complete|"
+"`2850 <https://wg21.link/LWG2850>`__","std::function move constructor does unnecessary work","Kona","|Complete|"
+"`2853 <https://wg21.link/LWG2853>`__","Possible inconsistency in specification of erase in [vector.modifiers]","Kona","|Complete|"
+"`2855 <https://wg21.link/LWG2855>`__","std::throw_with_nested(""string_literal"")","Kona","|Complete|"
+"`2857 <https://wg21.link/LWG2857>`__","{variant,optional,any}::emplace should return the constructed value","Kona","|Complete|"
+"`2861 <https://wg21.link/LWG2861>`__","basic_string should require that charT match traits::char_type","Kona","|Complete|"
+"`2866 <https://wg21.link/LWG2866>`__","Incorrect derived classes constraints","Kona","|Nothing To Do|"
+"`2868 <https://wg21.link/LWG2868>`__","Missing specification of bad_any_cast::what()","Kona","|Complete|"
+"`2872 <https://wg21.link/LWG2872>`__","Add definition for direct-non-list-initialization","Kona","|Complete|"
+"`2873 <https://wg21.link/LWG2873>`__","Add noexcept to several shared_ptr related functions","Kona","|Complete|"
+"`2874 <https://wg21.link/LWG2874>`__","Constructor ``shared_ptr::shared_ptr(Y*)``\  should be constrained","Kona",""
+"`2875 <https://wg21.link/LWG2875>`__","shared_ptr::shared_ptr(Y\*, D, [|hellip|\ ]) constructors should be constrained","Kona",""
+"`2876 <https://wg21.link/LWG2876>`__","``shared_ptr::shared_ptr(const weak_ptr<Y>&)``\  constructor should be constrained","Kona",""
+"`2878 <https://wg21.link/LWG2878>`__","Missing DefaultConstructible requirement for istream_iterator default constructor","Kona","|Complete|"
+"`2890 <https://wg21.link/LWG2890>`__","The definition of 'object state' applies only to class types","Kona","|Complete|"
+"`2900 <https://wg21.link/LWG2900>`__","The copy and move constructors of optional are not constexpr","Kona","|Complete|"
+"`2903 <https://wg21.link/LWG2903>`__","The form of initialization for the emplace-constructors is not specified","Kona","|Complete|"
+"`2904 <https://wg21.link/LWG2904>`__","Make variant move-assignment more exception safe","Kona","|Complete|"
+"`2905 <https://wg21.link/LWG2905>`__","is_constructible_v<unique_ptr<P, D>, P, D const &> should be false when D is not copy constructible","Kona","|Complete|"
+"`2908 <https://wg21.link/LWG2908>`__","The less-than operator for shared pointers could do more","Kona","|Complete|"
+"`2911 <https://wg21.link/LWG2911>`__","An is_aggregate type trait is needed","Kona","|Complete|"
+"`2921 <https://wg21.link/LWG2921>`__","packaged_task and type-erased allocators","Kona","|Complete|"
+"`2934 <https://wg21.link/LWG2934>`__","optional<const T> doesn't compare with T","Kona","|Complete|"
+"","","",""
+"`2901 <https://wg21.link/LWG2901>`__","Variants cannot properly support allocators","Toronto","|Complete|"
+"`2955 <https://wg21.link/LWG2955>`__","``to_chars / from_chars``\  depend on ``std::string``\ ","Toronto","Resolved by `P0682R1 <https://wg21.link/P0682R1>`__"
+"`2956 <https://wg21.link/LWG2956>`__","``filesystem::canonical()``\  still defined in terms of ``absolute(p, base)``\ ","Toronto","|Complete|"

libcxx/docs/Cxx1zStatusPaperStatus.csv

+"Paper #","Group","Paper Name","Meeting","Status","First released version"
+"`N3911 <https://wg21.link/n3911>`__","LWG","TransformationTrait Alias ``void_t``\ .","Urbana","|Complete|","3.6"
+"`N4089 <https://wg21.link/n4089>`__","LWG","Safe conversions in ``unique_ptr<T[]>``\ .","Urbana","|In Progress|","3.9"
+"`N4169 <https://wg21.link/n4169>`__","LWG","A proposal to add invoke function template","Urbana","|Complete|","3.7"
+"`N4190 <https://wg21.link/n4190>`__","LWG","Removing auto_ptr, random_shuffle(), And Old <functional> Stuff.","Urbana","|In Progress|",""
+"`N4258 <https://wg21.link/n4258>`__","LWG","Cleaning-up noexcept in the Library.","Urbana","|In Progress|","3.7"
+"`N4259 <https://wg21.link/n4259>`__","CWG","Wording for std::uncaught_exceptions","Urbana","|Complete|","3.7"
+"`N4277 <https://wg21.link/n4277>`__","LWG","TriviallyCopyable ``reference_wrapper``\ .","Urbana","|Complete|","3.2"
+"`N4279 <https://wg21.link/n4279>`__","LWG","Improved insertion interface for unique-key maps.","Urbana","|Complete|","3.7"
+"`N4280 <https://wg21.link/n4280>`__","LWG","Non-member size() and more","Urbana","|Complete|","3.6"
+"`N4284 <https://wg21.link/n4284>`__","LWG","Contiguous Iterators.","Urbana","|Complete|","3.6"
+"`N4285 <https://wg21.link/n4285>`__","CWG","Cleanup for exception-specification and throw-expression.","Urbana","|Complete|","4.0"
+"","","","","",""
+"`N4387 <https://wg21.link/n4387>`__","LWG","improving pair and tuple","Lenexa","|Complete|","4.0"
+"`N4389 <https://wg21.link/n4389>`__","LWG","bool_constant","Lenexa","|Complete|","3.7"
+"`N4508 <https://wg21.link/n4508>`__","LWG","shared_mutex for C++17","Lenexa","|Complete|","3.7"
+"`N4366 <https://wg21.link/n4366>`__","LWG","LWG 2228 missing SFINAE rule","Lenexa","|Complete|","3.1"
+"`N4510 <https://wg21.link/n4510>`__","LWG","Minimal incomplete type support for standard containers, revision 4","Lenexa","|Complete|","3.6"
+"","","","","",""
+"`P0004R1 <https://wg21.link/p0004r1>`__","LWG","Remove Deprecated iostreams aliases.","Kona","|Complete|","3.8"
+"`P0006R0 <https://wg21.link/p0006r0>`__","LWG","Adopt Type Traits Variable Templates for C++17.","Kona","|Complete|","3.8"
+"`P0092R1 <https://wg21.link/p0092r1>`__","LWG","Polishing <chrono>","Kona","|Complete|","3.8"
+"`P0007R1 <https://wg21.link/p0007r1>`__","LWG","Constant View: A proposal for a ``std::as_const``\  helper function template.","Kona","|Complete|","3.8"
+"`P0156R0 <https://wg21.link/p0156r0>`__","LWG","Variadic lock_guard(rev 3).","Kona","*Reverted in Kona*","3.9"
+"`P0074R0 <https://wg21.link/p0074r0>`__","LWG","Making ``std::owner_less``\  more flexible","Kona","|Complete|","3.8"
+"`P0013R1 <https://wg21.link/p0013r1>`__","LWG","Logical type traits rev 2","Kona","|Complete|","3.8"
+"","","","","",""
+"`P0024R2 <https://wg21.link/P0024R2>`__","LWG","The Parallelism TS Should be Standardized","Jacksonville","",""
+"`P0226R1 <https://wg21.link/P0226R1>`__","LWG","Mathematical Special Functions for C++17","Jacksonville","",""
+"`P0220R1 <https://wg21.link/P0220R1>`__","LWG","Adopt Library Fundamentals V1 TS Components for C++17","Jacksonville","|In Progress|",""
+"`P0218R1 <https://wg21.link/P0218R1>`__","LWG","Adopt the File System TS for C++17","Jacksonville","|Complete|","7.0"
+"`P0033R1 <https://wg21.link/P0033R1>`__","LWG","Re-enabling shared_from_this","Jacksonville","|Complete|","3.9"
+"`P0005R4 <https://wg21.link/P0005R4>`__","LWG","Adopt not_fn from Library Fundamentals 2 for C++17","Jacksonville","|Complete|","3.9"
+"`P0152R1 <https://wg21.link/P0152R1>`__","LWG","constexpr ``atomic::is_always_lock_free``\ ","Jacksonville","|Complete|","3.9"
+"`P0185R1 <https://wg21.link/P0185R1>`__","LWG","Adding [nothrow-]swappable traits","Jacksonville","|Complete|","3.9"
+"`P0253R1 <https://wg21.link/P0253R1>`__","LWG","Fixing a design mistake in the searchers interface","Jacksonville","|Complete|","3.9"
+"`P0025R0 <https://wg21.link/P0025R0>`__","LWG","An algorithm to ""clamp"" a value between a pair of boundary values","Jacksonville","|Complete|","3.9"
+"`P0154R1 <https://wg21.link/P0154R1>`__","LWG","constexpr std::hardware_{constructive,destructive}_interference_size","Jacksonville","",""
+"`P0030R1 <https://wg21.link/P0030R1>`__","LWG","Proposal to Introduce a 3-Argument Overload to std::hypot","Jacksonville","|Complete|","3.9"
+"`P0031R0 <https://wg21.link/P0031R0>`__","LWG","A Proposal to Add Constexpr Modifiers to reverse_iterator, move_iterator, array and Range Access","Jacksonville","|Complete|","4.0"
+"`P0272R1 <https://wg21.link/P0272R1>`__","LWG","Give ``std::string``\  a non-const ``.data()``\  member function","Jacksonville","|Complete|","3.9"
+"`P0077R2 <https://wg21.link/P0077R2>`__","LWG","``is_callable``\ , the missing INVOKE related trait","Jacksonville","|Complete|","3.9"
+"","","","","",""
+"`p0032r3 <https://wg21.link/p0032r3>`__","LWG","Homogeneous interface for variant, any and optional","Oulu","|Complete|","4.0"
+"`p0040r3 <https://wg21.link/p0040r3>`__","LWG","Extending memory management tools","Oulu","|Complete|","4.0"
+"`p0063r3 <https://wg21.link/p0063r3>`__","LWG","C++17 should refer to C11 instead of C99","Oulu","|Complete|","7.0"
+"`p0067r3 <https://wg21.link/p0067r3>`__","LWG","Elementary string conversions","Oulu","Now `P0067R5 <https://wg21.link/P0067R5>`__","n/a"
+"`p0083r3 <https://wg21.link/p0083r3>`__","LWG","Splicing Maps and Sets","Oulu","|Complete|","8.0"
+"`p0084r2 <https://wg21.link/p0084r2>`__","LWG","Emplace Return Type","Oulu","|Complete|","4.0"
+"`p0088r3 <https://wg21.link/p0088r3>`__","LWG","Variant: a type-safe union for C++17","Oulu","|Complete|","4.0"
+"`p0137r1 <https://wg21.link/p0137r1>`__","CWG","Core Issue 1776: Replacement of class objects containing reference members","Oulu","|Complete|","6.0"
+"`p0163r0 <https://wg21.link/p0163r0>`__","LWG","shared_ptr::weak_type","Oulu","|Complete|","3.9"
+"`p0174r2 <https://wg21.link/p0174r2>`__","LWG","Deprecating Vestigial Library Parts in C++17","Oulu","|Partial|",""
+"`p0175r1 <https://wg21.link/p0175r1>`__","LWG","Synopses for the C library","Oulu","",""
+"`p0180r2 <https://wg21.link/p0180r2>`__","LWG","Reserve a New Library Namespace for Future Standardization","Oulu","|Nothing To Do|","n/a"
+"`p0181r1 <https://wg21.link/p0181r1>`__","LWG","Ordered by Default","Oulu","*Removed in Kona*","n/a"
+"`p0209r2 <https://wg21.link/p0209r2>`__","LWG","make_from_tuple: apply for construction","Oulu","|Complete|","3.9"
+"`p0219r1 <https://wg21.link/p0219r1>`__","LWG","Relative Paths for Filesystem","Oulu","|Complete|","7.0"
+"`p0254r2 <https://wg21.link/p0254r2>`__","LWG","Integrating std::string_view and std::string","Oulu","|Complete|","4.0"
+"`p0258r2 <https://wg21.link/p0258r2>`__","LWG","has_unique_object_representations","Oulu","|Complete|","6.0"
+"`p0295r0 <https://wg21.link/p0295r0>`__","LWG","Adopt Selected Library Fundamentals V2 Components for C++17","Oulu","|Complete|","4.0"
+"`p0302r1 <https://wg21.link/p0302r1>`__","LWG","Removing Allocator Support in std::function","Oulu","|Complete|","4.0"
+"`p0307r2 <https://wg21.link/p0307r2>`__","LWG","Making Optional Greater Equal Again","Oulu","|Complete|","4.0"
+"`p0336r1 <https://wg21.link/p0336r1>`__","LWG","Better Names for Parallel Execution Policies in C++17","Oulu","",""
+"`p0337r0 <https://wg21.link/p0337r0>`__","LWG","Delete ``operator=``\  for polymorphic_allocator","Oulu","|Complete|","3.9"
+"`p0346r1 <https://wg21.link/p0346r1>`__","LWG","A <random> Nomenclature Tweak","Oulu","|Complete|","3.9"
+"`p0358r1 <https://wg21.link/p0358r1>`__","LWG","Fixes for not_fn","Oulu","|Complete|","3.9"
+"`p0371r1 <https://wg21.link/p0371r1>`__","LWG","Temporarily discourage memory_order_consume","Oulu","|Nothing To Do|","n/a"
+"`p0392r0 <https://wg21.link/p0392r0>`__","LWG","Adapting string_view by filesystem paths","Oulu","|Complete|","4.0"
+"`p0393r3 <https://wg21.link/p0393r3>`__","LWG","Making Variant Greater Equal","Oulu","|Complete|","4.0"
+"`P0394r4 <https://wg21.link/P0394r4>`__","LWG","Hotel Parallelifornia: terminate() for Parallel Algorithms Exception Handling","Oulu","",""
+"","","","","",""
+"`P0003R5 <https://wg21.link/P0003R5>`__","LWG","Removing Deprecated Exception Specifications from C++17","Issaquah","|Complete|","5.0"
+"`P0067R5 <https://wg21.link/P0067R5>`__","LWG","Elementary string conversions, revision 5","Issaquah","|Partial|",""
+"`P0403R1 <https://wg21.link/P0403R1>`__","LWG","Literal suffixes for ``basic_string_view``\ ","Issaquah","|Complete|","4.0"
+"`P0414R2 <https://wg21.link/P0414R2>`__","LWG","Merging shared_ptr changes from Library Fundamentals to C++17","Issaquah","|Complete|","11.0"
+"`P0418R2 <https://wg21.link/P0418R2>`__","LWG","Fail or succeed: there is no atomic lattice","Issaquah","",""
+"`P0426R1 <https://wg21.link/P0426R1>`__","LWG","Constexpr for ``std::char_traits``\ ","Issaquah","|Complete|","4.0"
+"`P0435R1 <https://wg21.link/P0435R1>`__","LWG","Resolving LWG Issues re ``common_type``\ ","Issaquah","|Complete|","4.0"
+"`P0502R0 <https://wg21.link/P0502R0>`__","LWG","Throwing out of a parallel algorithm terminates - but how?","Issaquah","",""
+"`P0503R0 <https://wg21.link/P0503R0>`__","LWG","Correcting library usage of ""literal type""","Issaquah","|Complete|","4.0"
+"`P0504R0 <https://wg21.link/P0504R0>`__","LWG","Revisiting in-place tag types for any/optional/variant","Issaquah","|Complete|","4.0"
+"`P0505R0 <https://wg21.link/P0505R0>`__","LWG","Wording for GB 50 - constexpr for chrono","Issaquah","|Complete|","4.0"
+"`P0508R0 <https://wg21.link/P0508R0>`__","LWG","Wording for GB 58 - structured bindings for node_handles","Issaquah","",""
+"`P0509R1 <https://wg21.link/P0509R1>`__","LWG","Updating ""Restrictions on exception handling""","Issaquah","|Nothing To Do|","n/a"
+"`P0510R0 <https://wg21.link/P0510R0>`__","LWG","Disallowing references, incomplete types, arrays, and empty variants","Issaquah","|Complete|","4.0"
+"`P0513R0 <https://wg21.link/P0513R0>`__","LWG","Poisoning the Hash","Issaquah","|Complete|","5.0"
+"`P0516R0 <https://wg21.link/P0516R0>`__","LWG","Clarify That shared_future's Copy Operations have Wide Contracts","Issaquah","|Complete|","4.0"
+"`P0517R0 <https://wg21.link/P0517R0>`__","LWG","Make future_error Constructible","Issaquah","|Complete|","4.0"
+"`P0521R0 <https://wg21.link/P0521R0>`__","LWG","Proposed Resolution for CA 14 (shared_ptr use_count/unique)","Issaquah","|Nothing To Do|","n/a"
+"","","","","",""
+"`P0156R2 <https://wg21.link/P0156R2>`__","LWG","Variadic Lock guard(rev 5)","Kona","|Complete|","5.0"
+"`P0270R3 <https://wg21.link/P0270R3>`__","CWG","Removing C dependencies from signal handler wording","Kona","",""
+"`P0298R3 <https://wg21.link/P0298R3>`__","CWG","A byte type definition","Kona","|Complete|","5.0"
+"`P0317R1 <https://wg21.link/P0317R1>`__","LWG","Directory Entry Caching for Filesystem","Kona","|Complete|","7.0"
+"`P0430R2 <https://wg21.link/P0430R2>`__","LWG","File system library on non-POSIX-like operating systems","Kona","|Complete|","7.0"
+"`P0433R2 <https://wg21.link/P0433R2>`__","LWG","Toward a resolution of US7 and US14: Integrating template deduction for class templates into the standard library","Kona","|In Progress| [#note-P0433]_","7.0"
+"`P0452R1 <https://wg21.link/P0452R1>`__","LWG","Unifying <numeric> Parallel Algorithms","Kona","",""
+"`P0467R2 <https://wg21.link/P0467R2>`__","LWG","Iterator Concerns for Parallel Algorithms","Kona","",""
+"`P0492R2 <https://wg21.link/P0492R2>`__","LWG","Proposed Resolution of C++17 National Body Comments for Filesystems","Kona","|Complete|","7.0"
+"`P0518R1 <https://wg21.link/P0518R1>`__","LWG","Allowing copies as arguments to function objects given to parallel algorithms in response to CH11","Kona","",""
+"`P0523R1 <https://wg21.link/P0523R1>`__","LWG","Wording for CH 10: Complexity of parallel algorithms","Kona","",""
+"`P0548R1 <https://wg21.link/P0548R1>`__","LWG","common_type and duration","Kona","|Complete|","5.0"
+"`P0558R1 <https://wg21.link/P0558R1>`__","LWG","Resolving atomic<T> named base class inconsistencies","Kona","",""
+"`P0574R1 <https://wg21.link/P0574R1>`__","LWG","Algorithm Complexity Constraints and Parallel Overloads","Kona","",""
+"`P0599R1 <https://wg21.link/P0599R1>`__","LWG","noexcept for hash functions","Kona","|Complete|","5.0"
+"`P0604R0 <https://wg21.link/P0604R0>`__","LWG","Resolving GB 55, US 84, US 85, US 86","Kona","|Complete|",""
+"`P0607R0 <https://wg21.link/P0607R0>`__","LWG","Inline Variables for the Standard Library","Kona","|In Progress| [#note-P0607]_","6.0"
+"`P0618R0 <https://wg21.link/P0618R0>`__","LWG","Deprecating <codecvt>","Kona","",""
+"`P0623R0 <https://wg21.link/P0623R0>`__","LWG","Final C++17 Parallel Algorithms Fixes","Kona","",""
+"","","","","",""
+"`P0682R1 <https://wg21.link/P0682R1>`__","LWG","Repairing elementary string conversions","Toronto","",""
+"`P0739R0 <https://wg21.link/P0739R0>`__","LWG","Some improvements to class template argument deduction integration into the standard library","Toronto","|Complete|","5.0"

libcxx/docs/Cxx2aStatus.rst

+.. _cxx2a-status:
+
+================================
+libc++ C++2a Status
+================================
+
+.. include:: Styles.rst
+
+.. contents::
+   :local:
+
+
+Overview
+================================
+
+In July 2017, the C++ standard committee created a draft for the next version of the C++ standard, known here as "C++2a" (probably to be C++20).
+
+This page shows the status of libc++; the status of clang's support of the language features is `here <https://clang.llvm.org/cxx_status.html#cxx2a>`__.
+
+.. attention:: Features in unreleased drafts of the standard are subject to change.
+
+The groups that have contributed papers:
+
+-  CWG - Core Language Working group
+-  LWG - Library working group
+-  SG1 - Study group #1 (Concurrency working group)
+
+.. note:: "Nothing to do" means that no library changes were needed to implement this change.
+
+.. _paper-status-cxx2a:
+
+Paper Status
+====================================
+
+.. csv-table::
+   :file: Cxx2aStatusPaperStatus.csv
+   :widths: auto
+
+.. note::
+
+   .. [#note-P0202] P0202: The missing bits in P0202 are in ``copy`` and ``copy_backwards`` (and the ones that call them: ``copy_n``, ``set_union``, ``set_difference``, and ``set_symmetric_difference``). This is because the first two algorithms have specializations that call ``memmove`` which is not constexpr. See `Bug 25165 <https://bugs.llvm.org/show_bug.cgi?id=25165>`__
+   .. [#note-P0600] P0600: The missing bits in P0600 are in |sect|\ [mem.res.class], |sect|\ [mem.poly.allocator.class], and |sect|\ [container.node.overview].
+
+   .. [#note-P0619] P0619: Only ``std::allocator`` part is implemented.
+
+
+.. _issues-status-cxx2a:
+
+Library Working Group Issues Status
+====================================
+
+.. csv-table::
+   :file: Cxx2aStatusIssuesStatus.csv
+   :widths: auto
+
+Last Updated: 24-Nov-2020

libcxx/docs/Cxx2aStatusIssuesStatus.csv

+"Issue #","Issue Name","Meeting","Status"
+"`2070 <https://wg21.link/LWG2070>`__","``allocate_shared``\  should use ``allocator_traits<A>::construct``\ ","Toronto","Resolved by `P0674R1 <https://wg21.link/P0674R1>`__"
+"`2444 <https://wg21.link/LWG2444>`__","Inconsistent complexity for ``std::sort_heap``\ ","Toronto",""
+"`2593 <https://wg21.link/LWG2593>`__","Moved-from state of Allocators","Toronto",""
+"`2597 <https://wg21.link/LWG2597>`__","``std::log``\  misspecified for complex numbers","Toronto",""
+"`2783 <https://wg21.link/LWG2783>`__","``stack::emplace()``\  and ``queue::emplace()``\  should return ``decltype(auto)``\ ","Toronto","|Complete|"
+"`2932 <https://wg21.link/LWG2932>`__","Constraints on parallel algorithm implementations are underspecified","Toronto",""
+"`2937 <https://wg21.link/LWG2937>`__","Is ``equivalent(""existing_thing"", ""not_existing_thing"")``\  an error","Toronto","|Complete|"
+"`2940 <https://wg21.link/LWG2940>`__","``result_of``\  specification also needs a little cleanup","Toronto",""
+"`2942 <https://wg21.link/LWG2942>`__","LWG 2873's resolution missed ``weak_ptr::owner_before``\ ","Toronto","|Complete|"
+"`2954 <https://wg21.link/LWG2954>`__","Specialization of the convenience variable templates should be prohibited","Toronto","|Complete|"
+"`2961 <https://wg21.link/LWG2961>`__","Bad postcondition for ``set_default_resource``\ ","Toronto",""
+"`2966 <https://wg21.link/LWG2966>`__","Incomplete resolution of US 74","Toronto","|Nothing To Do|"
+"`2974 <https://wg21.link/LWG2974>`__","Diagnose out of bounds ``tuple_element/variant_alternative``\ ","Toronto","|Complete|"
+"","","",""
+"`2779 <https://wg21.link/LWG2779>`__","[networking.ts] Relax requirements on buffer sequence iterators","Albuquerque",""
+"`2870 <https://wg21.link/LWG2870>`__","Default value of parameter theta of polar should be dependent","Albuquerque","|Complete|"
+"`2935 <https://wg21.link/LWG2935>`__","What should create_directories do when p already exists but is not a directory?","Albuquerque",""
+"`2941 <https://wg21.link/LWG2941>`__","[thread.req.timing] wording should apply to both member and namespace-level functions","Albuquerque","|Nothing To Do|"
+"`2944 <https://wg21.link/LWG2944>`__","LWG 2905 accidentally removed requirement that construction of the deleter doesn't throw an exception","Albuquerque","|Nothing To Do|"
+"`2945 <https://wg21.link/LWG2945>`__","Order of template parameters in optional comparisons","Albuquerque","|Complete|"
+"`2948 <https://wg21.link/LWG2948>`__","unique_ptr does not define operator<< for stream output","Albuquerque","|Complete|"
+"`2950 <https://wg21.link/LWG2950>`__","std::byte operations are misspecified","Albuquerque","|Complete|"
+"`2952 <https://wg21.link/LWG2952>`__","iterator_traits should work for pointers to cv T","Albuquerque","|Complete|"
+"`2953 <https://wg21.link/LWG2953>`__","LWG 2853 should apply to deque::erase too","Albuquerque","|Complete|"
+"`2958 <https://wg21.link/LWG2958>`__","Moves improperly defined as deleted","Albuquerque","*We already do this*"
+"`2964 <https://wg21.link/LWG2964>`__","Apparently redundant requirement for dynamic_pointer_cast","Albuquerque",""
+"`2965 <https://wg21.link/LWG2965>`__","Non-existing path::native_string() in filesystem_error::what() specification","Albuquerque","|Nothing To Do|"
+"`2972 <https://wg21.link/LWG2972>`__","What is ``is_trivially_destructible_v<int>``\ ?","Albuquerque","|Complete|"
+"`2976 <https://wg21.link/LWG2976>`__","Dangling uses_allocator specialization for packaged_task","Albuquerque","|Complete|"
+"`2977 <https://wg21.link/LWG2977>`__","unordered_meow::merge() has incorrect Throws: clause","Albuquerque","|Nothing To Do|"
+"`2978 <https://wg21.link/LWG2978>`__","Hash support for pmr::string and friends","Albuquerque",""
+"`2979 <https://wg21.link/LWG2979>`__","aligned_union should require complete object types","Albuquerque","|Complete|"
+"`2980 <https://wg21.link/LWG2980>`__","Cannot compare_exchange empty pointers","Albuquerque",""
+"`2981 <https://wg21.link/LWG2981>`__","Remove redundant deduction guides from standard library","Albuquerque",""
+"`2982 <https://wg21.link/LWG2982>`__","Making size_type consistent in associative container deduction guides","Albuquerque",""
+"`2988 <https://wg21.link/LWG2988>`__","Clause 32 cleanup missed one typename","Albuquerque",""
+"`2993 <https://wg21.link/LWG2993>`__","reference_wrapper<T> conversion from T&&","Albuquerque",""
+"`2998 <https://wg21.link/LWG2998>`__","Requirements on function objects passed to {``forward_``,}list-specific algorithms","Albuquerque","|Nothing To Do|"
+"`3001 <https://wg21.link/LWG3001>`__","weak_ptr::element_type needs remove_extent_t","Albuquerque",""
+"`3024 <https://wg21.link/LWG3024>`__","variant's copies must be deleted instead of disabled via SFINAE","Albuquerque","|Complete|"
+"","","",""
+"`2164 <https://wg21.link/LWG2164>`__","What are the semantics of ``vector.emplace(vector.begin(), vector.back())``\ ?","Jacksonville","|Complete|"
+"`2243 <https://wg21.link/LWG2243>`__","``istream::putback``\  problem","Jacksonville","|Complete|"
+"`2816 <https://wg21.link/LWG2816>`__","``resize_file``\  has impossible postcondition","Jacksonville","|Nothing To Do|"
+"`2843 <https://wg21.link/LWG2843>`__","Unclear behavior of ``std::pmr::memory_resource::do_allocate()``\ ","Jacksonville","|Complete|"
+"`2849 <https://wg21.link/LWG2849>`__","Why does ``!is_regular_file(from)``\  cause ``copy_file``\  to report a ""file already exists"" error?","Jacksonville","|Nothing To Do|"
+"`2851 <https://wg21.link/LWG2851>`__","``std::filesystem``\  enum classes are now underspecified","Jacksonville","|Nothing To Do|"
+"`2946 <https://wg21.link/LWG2946>`__","LWG 2758's resolution missed further corrections","Jacksonville","|Complete|"
+"`2969 <https://wg21.link/LWG2969>`__","``polymorphic_allocator::construct()``\  shouldn't pass ``resource()``\ ","Jacksonville","|Complete|"
+"`2975 <https://wg21.link/LWG2975>`__","Missing case for ``pair``\  construction in scoped and polymorphic allocators","Jacksonville",""
+"`2989 <https://wg21.link/LWG2989>`__","``path``\ 's stream insertion operator lets you insert everything under the sun","Jacksonville","|Complete|"
+"`3000 <https://wg21.link/LWG3000>`__","``monotonic_memory_resource::do_is_equal``\  uses ``dynamic_cast``\  unnecessarily","Jacksonville",""
+"`3002 <https://wg21.link/LWG3002>`__","[networking.ts] ``basic_socket_acceptor::is_open()``\  isn't ``noexcept``\ ","Jacksonville",""
+"`3004 <https://wg21.link/LWG3004>`__","|sect|\ [string.capacity] and |sect|\ [vector.capacity] should specify time complexity for ``capacity()``\ ","Jacksonville","|Nothing To Do|"
+"`3005 <https://wg21.link/LWG3005>`__","Destruction order of arrays by ``make_shared/allocate_shared``\  only recommended?","Jacksonville",""
+"`3007 <https://wg21.link/LWG3007>`__","``allocate_shared``\  should rebind allocator to *cv*-unqualified ``value_type``\  for construction","Jacksonville",""
+"`3009 <https://wg21.link/LWG3009>`__","Including ``<string_view>``\  doesn't provide ``std::size/empty/data``\ ","Jacksonville","|Complete|"
+"`3010 <https://wg21.link/LWG3010>`__","[networking.ts] ``uses_executor``\  says ""if a type ``T::executor_type``\  exists""","Jacksonville",""
+"`3013 <https://wg21.link/LWG3013>`__","``(recursive_)directory_iterator``\  construction and traversal should not be ``noexcept``\ ","Jacksonville","|Complete|"
+"`3014 <https://wg21.link/LWG3014>`__","More ``noexcept``\  issues with filesystem operations","Jacksonville","|Complete|"
+"`3015 <https://wg21.link/LWG3015>`__","``copy_options::*unspecified*``\  underspecified","Jacksonville","|Nothing To Do|"
+"`3017 <https://wg21.link/LWG3017>`__","``list splice``\  functions should use ``addressof``\ ","Jacksonville","|Complete|"
+"`3020 <https://wg21.link/LWG3020>`__","[networking.ts] Remove spurious nested ``value_type``\  buffer sequence requirement","Jacksonville",""
+"`3026 <https://wg21.link/LWG3026>`__","``filesystem::weakly_canonical``\  still defined in terms of ``canonical(p, base)``\ ","Jacksonville","|Complete|"
+"`3030 <https://wg21.link/LWG3030>`__","Who shall meet the requirements of ``try_lock``\ ?","Jacksonville","|Nothing To Do|"
+"`3034 <https://wg21.link/LWG3034>`__","P0767R1 breaks previously-standard-layout types","Jacksonville","|Complete|"
+"`3035 <https://wg21.link/LWG3035>`__","``std::allocator``\ 's constructors should be ``constexpr``\ ","Jacksonville","|Complete|"
+"`3039 <https://wg21.link/LWG3039>`__","Unnecessary ``decay``\  in ``thread``\  and ``packaged_task``\ ","Jacksonville","|Complete|"
+"`3041 <https://wg21.link/LWG3041>`__","Unnecessary ``decay``\  in ``reference_wrapper``\ ","Jacksonville","|Complete|"
+"`3042 <https://wg21.link/LWG3042>`__","``is_literal_type_v``\  should be inline","Jacksonville","|Complete|"
+"`3043 <https://wg21.link/LWG3043>`__","Bogus postcondition for ``filesystem_error``\  constructor","Jacksonville","|Complete|"
+"`3045 <https://wg21.link/LWG3045>`__","``atomic<*floating-point*>``\  doesn't have ``value_type``\  or ``difference_type``\ ","Jacksonville",""
+"`3048 <https://wg21.link/LWG3048>`__","``transform_reduce(exec, first1, last1, first2, init)``\  discards execution policy","Jacksonville",""
+"`3051 <https://wg21.link/LWG3051>`__","Floating point classifications were inadvertently changed in P0175","Jacksonville","|Nothing To Do|"
+"`3075 <https://wg21.link/LWG3075>`__","``basic_string``\  needs deduction guides from ``basic_string_view``\ ","Jacksonville","|Complete|"
+"","","",""
+"`2139 <https://wg21.link/LWG2139>`__","What is a user-defined type?","Rapperswil",""
+"`2970 <https://wg21.link/LWG2970>`__","Return type of std::visit misspecified","Rapperswil",""
+"`3058 <https://wg21.link/LWG3058>`__","Parallel adjacent_difference shouldn't require creating temporaries","Rapperswil",""
+"`3062 <https://wg21.link/LWG3062>`__","Unnecessary decay_t in is_execution_policy_v should be remove_cvref_t","Rapperswil",""
+"`3067 <https://wg21.link/LWG3067>`__","recursive_directory_iterator::pop must invalidate","Rapperswil","|Nothing To Do|"
+"`3071 <https://wg21.link/LWG3071>`__","[networking.ts] read_until still refers to ""input sequence""","Rapperswil","|Nothing To Do|"
+"`3074 <https://wg21.link/LWG3074>`__","Non-member functions for valarray should only deduce from the valarray","Rapperswil",""
+"`3076 <https://wg21.link/LWG3076>`__","basic_string CTAD ambiguity","Rapperswil","|Complete|"
+"`3079 <https://wg21.link/LWG3079>`__","LWG 2935 forgot to fix the existing_p overloads of create_directory","Rapperswil",""
+"`3080 <https://wg21.link/LWG3080>`__","Floating point from_chars pattern specification breaks round-tripping","Rapperswil",""
+"`3083 <https://wg21.link/LWG3083>`__","What should ios::iword(-1) do?","Rapperswil","|Nothing To Do|"
+"`3094 <https://wg21.link/LWG3094>`__","[time.duration.io]p4 makes surprising claims about encoding","Rapperswil",""
+"`3100 <https://wg21.link/LWG3100>`__","Unnecessary and confusing ""empty span"" wording","Rapperswil","|Nothing To Do|"
+"`3102 <https://wg21.link/LWG3102>`__","Clarify span iterator and ``const_iterator`` behavior","Rapperswil","|Complete|"
+"`3104 <https://wg21.link/LWG3104>`__","Fixing duration division","Rapperswil","|Complete|"
+"","","",""
+"`2183 <https://wg21.link/LWG2183>`__","Muddled allocator requirements for ``match_results``\  constructors","San Diego","|Complete|"
+"`2184 <https://wg21.link/LWG2184>`__","Muddled allocator requirements for ``match_results``\  assignments","San Diego","|Complete|"
+"`2412 <https://wg21.link/LWG2412>`__","``promise::set_value()``\  and ``promise::get_future()``\  should not race","San Diego",""
+"`2499 <https://wg21.link/LWG2499>`__","``operator>>(basic_istream&, CharT*)``\  makes it hard to avoid buffer overflows","San Diego","Resolved by P0487R1"
+"`2682 <https://wg21.link/LWG2682>`__","``filesystem::copy()``\  won't create a symlink to a directory","San Diego","|Nothing To Do|"
+"`2697 <https://wg21.link/LWG2697>`__","[concurr.ts] Behavior of ``future/shared_future``\  unwrapping constructor when given an invalid ``future``\ ","San Diego",""
+"`2797 <https://wg21.link/LWG2797>`__","Trait precondition violations","San Diego","Resolved by 1285R0"
+"`2936 <https://wg21.link/LWG2936>`__","Path comparison is defined in terms of the generic format","San Diego","|Complete|"
+"`2943 <https://wg21.link/LWG2943>`__","Problematic specification of the wide version of ``basic_filebuf::open``\ ","San Diego","|Nothing To Do|"
+"`2960 <https://wg21.link/LWG2960>`__","[fund.ts.v3] ``nonesuch``\  is insufficiently useless","San Diego","|Complete|"
+"`2995 <https://wg21.link/LWG2995>`__","``basic_stringbuf``\  default constructor forbids it from using SSO capacity","San Diego",""
+"`2996 <https://wg21.link/LWG2996>`__","Missing rvalue overloads for ``shared_ptr``\  operations","San Diego",""
+"`3008 <https://wg21.link/LWG3008>`__","``make_shared``\  (sub)object destruction semantics are not specified","San Diego",""
+"`3022 <https://wg21.link/LWG3022>`__","``is_convertible<derived*, base*>``\  may lead to ODR","San Diego","Resolved by 1285R0"
+"`3025 <https://wg21.link/LWG3025>`__","Map-like container deduction guides should use ``pair<Key, T>``\ , not ``pair<const Key, T>``\ ","San Diego","|Complete|"
+"`3031 <https://wg21.link/LWG3031>`__","Algorithms and predicates with non-const reference arguments","San Diego",""
+"`3037 <https://wg21.link/LWG3037>`__","``polymorphic_allocator``\  and incomplete types","San Diego",""
+"`3038 <https://wg21.link/LWG3038>`__","``polymorphic_allocator::allocate``\  should not allow integer overflow to create vulnerabilities","San Diego",""
+"`3054 <https://wg21.link/LWG3054>`__","``uninitialized_copy``\  appears to not be able to meet its exception-safety guarantee","San Diego",""
+"`3065 <https://wg21.link/LWG3065>`__","LWG 2989 missed that all ``path``\ 's other operators should be hidden friends as well","San Diego","|Complete|"
+"`3096 <https://wg21.link/LWG3096>`__","``path::lexically_relative``\  is confused by trailing slashes","San Diego","|Complete|"
+"`3116 <https://wg21.link/LWG3116>`__","``*OUTERMOST_ALLOC_TRAITS*``\  needs ``remove_reference_t``\ ","San Diego",""
+"`3122 <https://wg21.link/LWG3122>`__","``__cpp_lib_chrono_udls``\  was accidentally dropped","San Diego","|Complete|"
+"`3127 <https://wg21.link/LWG3127>`__","``basic_osyncstream::rdbuf``\  needs a ````const_cast````\ ","San Diego",""
+"`3128 <https://wg21.link/LWG3128>`__","``strstream::rdbuf``\  needs a ````const_cast````\ ","San Diego","|Nothing To Do|"
+"`3129 <https://wg21.link/LWG3129>`__","``regex_token_iterator``\  constructor uses wrong pointer arithmetic","San Diego",""
+"`3130 <https://wg21.link/LWG3130>`__","|sect|\ [input.output] needs many ``addressof``\ ","San Diego",""
+"`3131 <https://wg21.link/LWG3131>`__","``addressof``\  all the things","San Diego",""
+"`3132 <https://wg21.link/LWG3132>`__","Library needs to ban macros named ``expects``\  or ``ensures``\ ","San Diego","|Nothing To Do|"
+"`3134 <https://wg21.link/LWG3134>`__","[fund.ts.v3] LFTSv3 contains extraneous [meta] variable templates that should have been deleted by P09961","San Diego","Resolved by P1210R0"
+"`3137 <https://wg21.link/LWG3137>`__","Header for ``__cpp_lib_to_chars``\ ","San Diego","|Complete|"
+"`3145 <https://wg21.link/LWG3145>`__","``file_clock``\  breaks ABI for C++17 implementations","San Diego","|Complete|"
+"`3147 <https://wg21.link/LWG3147>`__","Definitions of ""likely"" and ""unlikely"" are likely to cause problems","San Diego",""
+"`3148 <https://wg21.link/LWG3148>`__","``<concepts>``\  should be freestanding","San Diego",""
+"`3153 <https://wg21.link/LWG3153>`__","``Common``\  and ``common_type``\  have too little in common","San Diego",""
+"`3154 <https://wg21.link/LWG3154>`__","``Common``\  and ``CommonReference``\  have a common defect","San Diego",""
+"","","",""
+"`3012 <https://wg21.link/LWG3012>`__","``atomic<T>``\  is unimplementable for non-``is_trivially_copy_constructible T``\ ","Kona",""
+"`3040 <https://wg21.link/LWG3040>`__","``basic_string_view::starts_with``\  *Effects* are incorrect","Kona","|Complete|"
+"`3077 <https://wg21.link/LWG3077>`__","``(push|emplace)_back``\  should invalidate the ``end``\  iterator","Kona","|Nothing To Do|"
+"`3087 <https://wg21.link/LWG3087>`__","One final ``&x``\  in |sect|\ [list.ops]","Kona","|Nothing To Do|"
+"`3101 <https://wg21.link/LWG3101>`__","``span``\ 's ``Container``\  constructors need another constraint","Kona","|Complete|"
+"`3112 <https://wg21.link/LWG3112>`__","``system_error``\  and ``filesystem_error``\  constructors taking a ``string``\  may not be able to meet their postconditions","Kona",""
+"`3119 <https://wg21.link/LWG3119>`__","Program-definedness of closure types","Kona","|Nothing To Do|"
+"`3133 <https://wg21.link/LWG3133>`__","Modernizing numeric type requirements","Kona",""
+"`3144 <https://wg21.link/LWG3144>`__","``span``\  does not have a ````const_pointer````\  typedef","Kona","|Complete|"
+"`3173 <https://wg21.link/LWG3173>`__","Enable CTAD for *``ref-view``*\ ","Kona",""
+"`3179 <https://wg21.link/LWG3179>`__","``subrange``\  should always model ``Range``\ ","Kona",""
+"`3180 <https://wg21.link/LWG3180>`__","Inconsistently named return type for ``ranges::minmax_element``\ ","Kona",""
+"`3182 <https://wg21.link/LWG3182>`__","Specification of ``Same``\  could be clearer","Kona",""
+"","","",""
+"`2899 <https://wg21.link/LWG2899>`__","``is_(nothrow_)move_constructible``\  and ``tuple``\ , ``optional``\  and ``unique_ptr``\ ","Cologne",""
+"`3055 <https://wg21.link/LWG3055>`__","``path::operator+=(*single-character*)``\  misspecified","Cologne",""
+"`3158 <https://wg21.link/LWG3158>`__","``tuple(allocator_arg_t, const Alloc&)``\  should be conditionally explicit","Cologne",""
+"`3169 <https://wg21.link/LWG3169>`__","``ranges``\  permutation generators discard useful information","Cologne",""
+"`3183 <https://wg21.link/LWG3183>`__","Normative permission to specialize Ranges variable templates","Cologne",""
+"`3184 <https://wg21.link/LWG3184>`__","Inconsistencies in ``bind_front``\  wording","Cologne",""
+"`3185 <https://wg21.link/LWG3185>`__","Uses-allocator construction functions missing ``constexpr``\  and ``noexcept``\ ","Cologne",""
+"`3186 <https://wg21.link/LWG3186>`__","``ranges``\  removal, partition, and ``partial_sort_copy``\  algorithms discard useful information","Cologne",""
+"`3187 <https://wg21.link/LWG3187>`__","`P0591R4 <https://wg21.link/p0591r4>`__ reverted DR 2586 fixes to ``scoped_allocator_adaptor::construct()``\ ","Cologne",""
+"`3191 <https://wg21.link/LWG3191>`__","``std::ranges::shuffle``\  synopsis does not match algorithm definition","Cologne",""
+"`3196 <https://wg21.link/LWG3196>`__","``std::optional<T>``\  is ill-formed is ``T``\  is an array","Cologne","|Complete|"
+"`3198 <https://wg21.link/LWG3198>`__","Bad constraint on ``std::span::span()``\ ","Cologne","|Complete|"
+"`3199 <https://wg21.link/LWG3199>`__","``istream >> bitset<0>``\  fails","Cologne",""
+"`3202 <https://wg21.link/LWG3202>`__","P0318R1 was supposed to be revised","Cologne","|Complete|"
+"`3206 <https://wg21.link/LWG3206>`__","``year_month_day``\  conversion to ``sys_days``\  uses not-existing member function","Cologne","|Complete|"
+"`3208 <https://wg21.link/LWG3208>`__","``Boolean``\ 's expression requirements are ordered inconsistently","Cologne","|Nothing To Do|"
+"`3209 <https://wg21.link/LWG3209>`__","Expression in ``year::ok()``\  returns clause is ill-formed","Cologne","|Complete|"
+"","","",""
+"`3231 <https://wg21.link/LWG3231>`__","``year_month_day_last::day``\  specification does not cover ``!ok()``\  values","Belfast","|Nothing To Do|"
+"`3225 <https://wg21.link/LWG3225>`__","``zoned_time``\  converting constructor shall not be ``noexcept``\ ","Belfast",""
+"`3190 <https://wg21.link/LWG3190>`__","``std::allocator::allocate``\  sometimes returns too little storage","Belfast",""
+"`3218 <https://wg21.link/LWG3218>`__","Modifier for ``%d``\  parse flag does not match POSIX and ``format``\  specification","Belfast",""
+"`3224 <https://wg21.link/LWG3224>`__","``zoned_time``\  constructor from ``TimeZonePtr``\  does not specify initialization of ``tp_``\ ","Belfast",""
+"`3230 <https://wg21.link/LWG3230>`__","Format specifier ``%y/%Y``\  is missing locale alternative versions","Belfast",""
+"`3232 <https://wg21.link/LWG3232>`__","Inconsistency in ``zoned_time``\  deduction guides","Belfast",""
+"`3222 <https://wg21.link/LWG3222>`__","P0574R1 introduced preconditions on non-existent parameters","Belfast",""
+"`3221 <https://wg21.link/LWG3221>`__","Result of ``year_month``\  arithmetic with ``months``\  is ambiguous","Belfast",""
+"`3235 <https://wg21.link/LWG3235>`__","``parse``\  manipulator without abbreviation is not callable","Belfast",""
+"`3246 <https://wg21.link/LWG3246>`__","What are the constraints on the template parameter of ``basic_format_arg``\ ?","Belfast",""
+"`3253 <https://wg21.link/LWG3253>`__","``basic_syncbuf::basic_syncbuf()``\  should not be explicit","Belfast",""
+"`3245 <https://wg21.link/LWG3245>`__","Unnecessary restriction on ``'%p'``\  parse specifier","Belfast",""
+"`3244 <https://wg21.link/LWG3244>`__","Constraints for ``Source``\  in |sect|\ [fs.path.req] insufficiently constrainty","Belfast",""
+"`3241 <https://wg21.link/LWG3241>`__","``chrono-spec``\  grammar ambiguity in |sect|\ [time.format]","Belfast",""
+"`3257 <https://wg21.link/LWG3257>`__","Missing feature testing macro update from P0858","Belfast",""
+"`3256 <https://wg21.link/LWG3256>`__","Feature testing macro for ``constexpr``\  algorithms","Belfast",""
+"`3273 <https://wg21.link/LWG3273>`__","Specify ``weekday_indexed``\  to range of ``[0, 7]``\ ","Belfast",""
+"`3070 <https://wg21.link/LWG3070>`__","``path::lexically_relative``\  causes surprising results if a filename can also be a  *root-name*","Belfast",""
+"`3266 <https://wg21.link/LWG3266>`__","``to_chars(bool)``\  should be deleted","Belfast",""
+"`3272 <https://wg21.link/LWG3272>`__","``%I%p``\  should parse/format ``duration``\  since midnight","Belfast",""
+"`3259 <https://wg21.link/LWG3259>`__","The definition of *constexpr iterators* should be adjusted","Belfast",""
+"`3103 <https://wg21.link/LWG3103>`__","Errors in taking subview of ``span``\  should be ill-formed where possible","Belfast",""
+"`3274 <https://wg21.link/LWG3274>`__","Missing feature test macro for ``<span>``\ ","Belfast",""
+"`3276 <https://wg21.link/LWG3276>`__","Class ``split_view::outer_iterator::value_type``\  should inherit from ``view_interface``\ ","Belfast",""
+"`3277 <https://wg21.link/LWG3277>`__","Pre-increment on prvalues is not a requirement of ``weakly_incrementable``\ ","Belfast",""
+"`3149 <https://wg21.link/LWG3149>`__","``DefaultConstructible``\  should require default initialization","Belfast",""
+"","","",""
+"`1203 <https://wg21.link/LWG1203>`__","More useful rvalue stream insertion","Prague","12.0"
+"`2859 <https://wg21.link/LWG2859>`__","Definition of *reachable* in [ptr.launder] misses pointer arithmetic from pointer-interconvertible object","Prague",""
+"`3018 <https://wg21.link/LWG3018>`__","``shared_ptr``\  of function type","Prague",""
+"`3050 <https://wg21.link/LWG3050>`__","Conversion specification problem in ``chrono::duration``\  constructor","Prague",""
+"`3141 <https://wg21.link/LWG3141>`__","``CopyConstructible``\  doesn't preserve source values","Prague",""
+"`3150 <https://wg21.link/LWG3150>`__","``UniformRandomBitGenerator``\  should validate ``min``\  and ``max``\ ","Prague",""
+"`3175 <https://wg21.link/LWG3175>`__","The ``CommonReference``\  requirement of concept ``SwappableWith``\  is not satisfied in the example","Prague",""
+"`3194 <https://wg21.link/LWG3194>`__","``ConvertibleTo``\  prose does not match code","Prague",""
+"`3200 <https://wg21.link/LWG3200>`__","``midpoint``\  should not constrain ``T``\  is complete","Prague",""
+"`3201 <https://wg21.link/LWG3201>`__","``lerp``\  should be marked as ``noexcept``\ ","Prague","|Complete|"
+"`3226 <https://wg21.link/LWG3226>`__","``zoned_time``\  constructor from ``string_view``\  should accept ``zoned_time<Duration2, TimeZonePtr2>``\ ","Prague",""
+"`3233 <https://wg21.link/LWG3233>`__","Broken requirements for ``shared_ptr``\  converting constructors","Prague",""
+"`3237 <https://wg21.link/LWG3237>`__","LWG 3038 and 3190 have inconsistent PRs","Prague",""
+"`3238 <https://wg21.link/LWG3238>`__","Insufficiently-defined behavior of ``std::function``\  deduction guides","Prague",""
+"`3242 <https://wg21.link/LWG3242>`__","``std::format``\ : missing rules for ``arg-id``\  in ``width``\  and ``precision``\ ","Prague",""
+"`3243 <https://wg21.link/LWG3243>`__","``std::format``\  and negative zeroes","Prague",""
+"`3247 <https://wg21.link/LWG3247>`__","``ranges::iter_move``\  should perform ADL-only lookup of ``iter_move``\ ","Prague",""
+"`3248 <https://wg21.link/LWG3248>`__","``std::format``\  ``#b``\ , ``#B``\ , ``#o``\ , ``#x``\ , and ``#X``\   presentation types misformat negative numbers","Prague",""
+"`3250 <https://wg21.link/LWG3250>`__","``std::format``\ : ``#``\  (alternate form) for NaN and inf","Prague",""
+"`3251 <https://wg21.link/LWG3251>`__","Are ``std::format``\  alignment specifiers applied to string arguments?","Prague",""
+"`3252 <https://wg21.link/LWG3252>`__","Parse locale's aware modifiers for commands are not consistent with POSIX spec","Prague",""
+"`3254 <https://wg21.link/LWG3254>`__","Strike ``stop_token``\ 's ``operator!=``\ ","Prague",""
+"`3255 <https://wg21.link/LWG3255>`__","``span``\ 's ``array``\  constructor is too strict","Prague","|Complete|"
+"`3260 <https://wg21.link/LWG3260>`__","``year_month*``\  arithmetic rejects durations convertible to years","Prague",""
+"`3262 <https://wg21.link/LWG3262>`__","Formatting of negative durations is not specified","Prague",""
+"`3264 <https://wg21.link/LWG3264>`__","``sized_range``\  and ``ranges::size``\  redundantly use ``disable_sized_range``\ ","Prague",""
+"`3269 <https://wg21.link/LWG3269>`__","Parse manipulators do not specify the result of the extraction from stream","Prague",""
+"`3270 <https://wg21.link/LWG3270>`__","Parsing and formatting ``%j``\  with ``duration``\ s","Prague",""
+"`3280 <https://wg21.link/LWG3280>`__","View converting constructors can cause constraint recursion and are unneeded","Prague",""
+"`3281 <https://wg21.link/LWG3281>`__","Conversion from ``*pair-like*``\  types to ``subrange``\  is a silent semantic promotion","Prague",""
+"`3282 <https://wg21.link/LWG3282>`__","``subrange``\  converting constructor should disallow derived to base conversions","Prague",""
+"`3284 <https://wg21.link/LWG3284>`__","``random_access_iterator``\  semantic constraints accidentally promote difference type  using unary negate","Prague",""
+"`3285 <https://wg21.link/LWG3285>`__","The type of a customization point object shall satisfy ``semiregular``\ ","Prague",""
+"`3286 <https://wg21.link/LWG3286>`__","``ranges::size``\  is not required to be valid after a call to ``ranges::begin``\  on an input range","Prague",""
+"`3291 <https://wg21.link/LWG3291>`__","``iota_view::iterator``\  has the wrong ``iterator_category``\ ","Prague",""
+"`3292 <https://wg21.link/LWG3292>`__","``iota_view``\  is under-constrained","Prague",""
+"`3294 <https://wg21.link/LWG3294>`__","``zoned_time``\  deduction guides misinterprets ``string``\ /``char*``\ ","Prague",""
+"`3296 <https://wg21.link/LWG3296>`__","Inconsistent default argument for ``basic_regex<>::assign``\ ","Prague",""
+"`3299 <https://wg21.link/LWG3299>`__","Pointers don't need customized iterator behavior","Prague",""
+"`3300 <https://wg21.link/LWG3300>`__","Non-array ``ssize``\  overload is underconstrained","Prague",""
+"`3301 <https://wg21.link/LWG3301>`__","``transform_view::iterator``\  has incorrect ``iterator_category``\ ","Prague",""
+"`3302 <https://wg21.link/LWG3302>`__","Range adaptor objects ``keys``\  and ``values``\  are unspecified","Prague",""
+"`3303 <https://wg21.link/LWG3303>`__","Bad ""``constexpr``\ "" marker for ``destroy/destroy_n``\ ","Prague",""
+"`3304 <https://wg21.link/LWG3304>`__","Allocate functions of ``std::polymorphic_allocator``\  should require ``[[nodiscard]]``\ ","Prague",""
+"`3307 <https://wg21.link/LWG3307>`__","``std::allocator<void>().allocate(n)``\ ","Prague",""
+"`3310 <https://wg21.link/LWG3310>`__","Replace ``SIZE_MAX``\  with ``numeric_limits<size_t>::max()``\ ","Prague",""
+"`3313 <https://wg21.link/LWG3313>`__","``join_view::iterator::operator--``\  is incorrectly constrained","Prague",""
+"`3314 <https://wg21.link/LWG3314>`__","Is stream insertion behavior locale dependent when ``Period::type``\  is ``micro``\ ?","Prague",""
+"`3315 <https://wg21.link/LWG3315>`__","Correct Allocator Default Behavior","Prague",""
+"`3316 <https://wg21.link/LWG3316>`__","Correctly define epoch for ``utc_clock``\  / ``utc_timepoint``\ ","Prague",""
+"`3317 <https://wg21.link/LWG3317>`__","Incorrect ``operator<<``\  for floating-point durations","Prague",""
+"`3318 <https://wg21.link/LWG3318>`__","Clarify whether clocks can represent time before their epoch","Prague",""
+"`3319 <https://wg21.link/LWG3319>`__","Properly reference specification of IANA time zone database","Prague",""
+"`3320 <https://wg21.link/LWG3320>`__","``span::cbegin/cend``\  methods produce different results than ``std::[ranges::]cbegin/cend``\ ","Prague","|Complete|"
+"`3321 <https://wg21.link/LWG3321>`__","``uninitialized_construct_using_allocator``\  should use ``construct_at``\ ","Prague",""
+"`3323 <https://wg21.link/LWG3323>`__","``*has-tuple-element*``\  helper concept needs ``convertible_to``\ ","Prague",""
+"`3324 <https://wg21.link/LWG3324>`__","Special-case ``std::strong/weak/partial_order``\  for pointers","Prague",""
+"`3325 <https://wg21.link/LWG3325>`__","Constrain return type of transformation function for ``transform_view``\ ","Prague",""
+"`3326 <https://wg21.link/LWG3326>`__","``enable_view``\  has false positives","Prague",""
+"`3327 <https://wg21.link/LWG3327>`__","Format alignment specifiers vs. text direction","Prague",""
+"`3328 <https://wg21.link/LWG3328>`__","Clarify that ``std::string``\  is not good for UTF-8","Prague",""
+"`3329 <https://wg21.link/LWG3329>`__","``totally_ordered_with``\  both directly and indirectly requires ``common_reference_with``\ ","Prague",""
+"`3330 <https://wg21.link/LWG3330>`__","Include ``<compare>``\  from most library headers","Prague",""
+"`3331 <https://wg21.link/LWG3331>`__","Define ``totally_ordered/_with``\  in terms of ``*partially-ordered-with*``\ ","Prague",""
+"`3332 <https://wg21.link/LWG3332>`__","Issue in |sect|\ [time.format]","Prague",""
+"`3334 <https://wg21.link/LWG3334>`__","``basic_osyncstream``\  move assignment and destruction calls ``basic_syncbuf::emit()``\  twice","Prague",""
+"`3335 <https://wg21.link/LWG3335>`__","Resolve C++20 NB comments US 273 and GB 274","Prague",""
+"`3338 <https://wg21.link/LWG3338>`__","Rename ``default_constructible``\  to ``default_initializable``\ ","Prague",""
+"`3340 <https://wg21.link/LWG3340>`__","Formatting functions should throw on argument/format string mismatch in |sect|\ [format.functions]","Prague",""
+"`3346 <https://wg21.link/LWG3346>`__","``pair``\  and ``tuple``\  copy and move constructor have backwards specification","Prague",""
+"`3347 <https://wg21.link/LWG3347>`__","``std::pair<T, U>``\  now requires ``T``\  and ``U``\  to be less-than-comparable","Prague",""
+"`3348 <https://wg21.link/LWG3348>`__","``__cpp_lib_unwrap_ref``\  in wrong header","Prague",""
+"`3349 <https://wg21.link/LWG3349>`__","Missing ``__cpp_lib_constexpr_complex``\  for P0415R1","Prague",""
+"`3350 <https://wg21.link/LWG3350>`__","Simplify return type of ``lexicographical_compare_three_way``\ ","Prague",""
+"`3351 <https://wg21.link/LWG3351>`__","``ranges::enable_safe_range``\  should not be constrained","Prague",""
+"`3352 <https://wg21.link/LWG3352>`__","``strong_equality``\  isn't a thing","Prague",""
+"`3354 <https://wg21.link/LWG3354>`__","``has_strong_structural_equality``\  has a meaningless definition","Prague",""
+"`3355 <https://wg21.link/LWG3355>`__","The memory algorithms should support move-only input iterators introduced by P1207","Prague",""
+"`3356 <https://wg21.link/LWG3356>`__","``__cpp_lib_nothrow_convertible``\  should be ``__cpp_lib_is_nothrow_convertible``\ ","Prague",""
+"`3358 <https://wg21.link/LWG3358>`__","|sect|\ [span.cons] is mistaken that ``to_address``\  can throw","Prague",""
+"`3359 <https://wg21.link/LWG3359>`__","``<chrono>``\  leap second support should allow for negative leap seconds","Prague",""
+"`3360 <https://wg21.link/LWG3360>`__","``three_way_comparable_with``\  is inconsistent with similar concepts","Prague",""
+"`3362 <https://wg21.link/LWG3362>`__","Strike ``stop_source``\ 's ``operator!=``\ ","Prague",""
+"`3363 <https://wg21.link/LWG3363>`__","``drop_while_view``\  should opt-out of ``sized_range``\ ","Prague",""
+"`3364 <https://wg21.link/LWG3364>`__","Initialize data members of ranges and their iterators","Prague",""
+"`3367 <https://wg21.link/LWG3367>`__","Integer-class conversions should not throw","Prague",""
+"`3369 <https://wg21.link/LWG3369>`__","``span``\ 's deduction-guide for built-in arrays doesn't work","Prague",""
+"`3371 <https://wg21.link/LWG3371>`__","``visit_format_arg``\  and ``make_format_args``\  are not hidden friends","Prague",""
+"`3372 <https://wg21.link/LWG3372>`__","``vformat_to``\  should not try to deduce ``Out``\  twice","Prague",""
+"`3373 <https://wg21.link/LWG3373>`__","``{to,from}_chars_result``\  and ``format_to_n_result``\  need the  ""we really mean what we say"" wording","Prague",""
+"`3374 <https://wg21.link/LWG3374>`__","P0653 + P1006 should have made the other ``std::to_address``\  overload ``constexpr``\ ","Prague",""
+"`3375 <https://wg21.link/LWG3375>`__","``decay``\  in ``viewable_range``\  should be ``remove_cvref``\ ","Prague",""
+"`3377 <https://wg21.link/LWG3377>`__","``elements_view::iterator``\  befriends a specialization of itself","Prague",""
+"`3379 <https://wg21.link/LWG3379>`__","""``safe``\ "" in several library names is misleading","Prague",""
+"`3380 <https://wg21.link/LWG3380>`__","``common_type``\  and comparison categories","Prague",""
+"`3381 <https://wg21.link/LWG3381>`__","``begin``\  and ``data``\  must agree for ``contiguous_range``\ ","Prague",""
+"`3382 <https://wg21.link/LWG3382>`__","NTTP for ``pair``\  and ``array``\ ","Prague",""
+"`3383 <https://wg21.link/LWG3383>`__","|sect|\ [time.zone.leap.nonmembers] ``sys_seconds``\  should be replaced with ``seconds``\ ","Prague",""
+"`3384 <https://wg21.link/LWG3384>`__","``transform_view::*sentinel*``\  has an incorrect ``operator-``\ ","Prague",""
+"`3385 <https://wg21.link/LWG3385>`__","``common_iterator``\  is not sufficiently constrained for non-copyable iterators","Prague",""
+"`3387 <https://wg21.link/LWG3387>`__","|sect|\ [range.reverse.view] ``reverse_view<V>``\  unintentionally requires ``range<const V>``\ ","Prague",""
+"`3388 <https://wg21.link/LWG3388>`__","``view``\  iterator types have ill-formed ``<=>``\  operators","Prague",""
+"`3389 <https://wg21.link/LWG3389>`__","A move-only iterator still does not have a ``counted_iterator``\ ","Prague",""
+"`3390 <https://wg21.link/LWG3390>`__","``make_move_iterator()``\  cannot be used to construct a ``move_iterator``\  for a move-only iterator","Prague",""
+"`3393 <https://wg21.link/LWG3393>`__","Missing/incorrect feature test macro for coroutines","Prague",""
+"`3395 <https://wg21.link/LWG3395>`__","Definition for three-way comparison needs to be updated (US 152)","Prague",""
+"`3396 <https://wg21.link/LWG3396>`__","Clarify point of reference for ``source_location::current()``\  (DE 169)","Prague",""
+"`3397 <https://wg21.link/LWG3397>`__","``ranges::basic_istream_view::iterator``\  should not provide ``iterator_category``\ ","Prague",""
+"`3398 <https://wg21.link/LWG3398>`__","``tuple_element_t``\  is also wrong for ``const subrange``\ ","Prague",""

libcxx/docs/Cxx2aStatusPaperStatus.csv

+"Paper #","Group","Paper Name","Meeting","Status","First released version"
+"`P0463R1 <https://wg21.link/P0463R1>`__","LWG","Endian just Endian","Toronto","|Complete|","7.0"
+"`P0674R1 <https://wg21.link/P0674R1>`__","LWG","Extending make_shared to Support Arrays","Toronto","",""
+"","","","","",""
+"`P0020R6 <https://wg21.link/P0020R6>`__","LWG","Floating Point Atomic","Albuquerque","",""
+"`P0053R7 <https://wg21.link/P0053R7>`__","LWG","C++ Synchronized Buffered Ostream","Albuquerque","",""
+"`P0202R3 <https://wg21.link/P0202R3>`__","LWG","Add constexpr modifiers to functions in <algorithm> and <utility> Headers","Albuquerque","|In Progress| [#note-P0202]_","7.0"
+"`P0415R1 <https://wg21.link/P0415R1>`__","LWG","Constexpr for ``std::complex``\ ","Albuquerque","|In Progress|","7.0"
+"`P0439R0 <https://wg21.link/P0439R0>`__","LWG","Make ``std::memory_order``\  a scoped enumeration","Albuquerque","|Complete|",""
+"`P0457R2 <https://wg21.link/P0457R2>`__","LWG","String Prefix and Suffix Checking","Albuquerque","|Complete|","6.0"
+"`P0550R2 <https://wg21.link/P0550R2>`__","LWG","Transformation Trait ``remove_cvref``\ ","Albuquerque","|Complete|","6.0"
+"`P0600R1 <https://wg21.link/P0600R1>`__","LWG","nodiscard in the Library","Albuquerque","|In Progress| [#note-P0600]_","7.0"
+"`P0616R0 <https://wg21.link/P0616R0>`__","LWG","de-pessimize legacy <numeric> algorithms with std::move","Albuquerque","",""
+"`P0653R2 <https://wg21.link/P0653R2>`__","LWG","Utility to convert a pointer to a raw pointer","Albuquerque","|Complete|","6.0"
+"`P0718R2 <https://wg21.link/P0718R2>`__","LWG","Atomic shared_ptr","Albuquerque","",""
+"`P0767R1 <https://wg21.link/P0767R1>`__","CWG","Deprecate POD","Albuquerque","|Complete|","7.0"
+"`P0768R1 <https://wg21.link/P0768R1>`__","CWG","Library Support for the Spaceship (Comparison) Operator","Albuquerque","|Complete|",""
+"`P0777R1 <https://wg21.link/P0777R1>`__","LWG","Treating Unnecessary ``decay``\ ","Albuquerque","|Complete|","7.0"
+"`P0122R7 <https://wg21.link/P0122R7>`__","LWG","<span>","Jacksonville","|Complete|","7.0"
+"`P0355R7 <https://wg21.link/P0355R7>`__","LWG","Extending chrono to Calendars and Time Zones","Jacksonville","|In Progress|",""
+"`P0551R3 <https://wg21.link/P0551R3>`__","LWG","Thou Shalt Not Specialize ``std``\  Function Templates!","Jacksonville","|Complete|","11.0"
+"`P0753R2 <https://wg21.link/P0753R2>`__","LWG","Manipulators for C++ Synchronized Buffered Ostream","Jacksonville","",""
+"`P0754R2 <https://wg21.link/P0754R2>`__","LWG","<version>","Jacksonville","|Complete|","7.0"
+"`P0809R0 <https://wg21.link/P0809R0>`__","LWG","Comparing Unordered Containers","Jacksonville","",""
+"`P0858R0 <https://wg21.link/P0858R0>`__","LWG","Constexpr iterator requirements","Jacksonville","",""
+"`P0905R1 <https://wg21.link/P0905R1>`__","CWG","Symmetry for spaceship","Jacksonville","",""
+"`P0966R1 <https://wg21.link/P0966R1>`__","LWG","``string::reserve``\  Should Not Shrink","Jacksonville","|Complete|","8.0"
+"","","","","",""
+"`P0019R8 <https://wg21.link/P0019R8>`__","LWG","Atomic Ref","Rapperswil","",""
+"`P0458R2 <https://wg21.link/P0458R2>`__","LWG","Checking for Existence of an Element in Associative Containers","Rapperswil","|Complete|",""
+"`P0475R1 <https://wg21.link/P0475R1>`__","LWG","LWG 2511: guaranteed copy elision for piecewise construction","Rapperswil","",""
+"`P0476R2 <https://wg21.link/P0476R2>`__","LWG","Bit-casting object representations","Rapperswil","",""
+"`P0528R3 <https://wg21.link/P0528R3>`__","CWG","The Curious Case of Padding Bits, Featuring Atomic Compare-and-Exchange","Rapperswil","",""
+"`P0542R5 <https://wg21.link/P0542R5>`__","CWG","Support for contract based programming in C++","Rapperswil","",""
+"`P0556R3 <https://wg21.link/P0556R3>`__","LWG","Integral power-of-2 operations","Rapperswil","|Complete|","9.0"
+"`P0619R4 <https://wg21.link/P0619R4>`__","LWG","Reviewing Deprecated Facilities of C++17 for C++20","Rapperswil","|Partial| [#note-P0619]_",""
+"`P0646R1 <https://wg21.link/P0646R1>`__","LWG","Improving the Return Value of Erase-Like Algorithms","Rapperswil","|Complete|","10.0"
+"`P0722R3 <https://wg21.link/P0722R3>`__","CWG","Efficient sized delete for variable sized classes","Rapperswil","|Complete|","9.0"
+"`P0758R1 <https://wg21.link/P0758R1>`__","LWG","Implicit conversion traits and utility functions","Rapperswil","|Complete|",""
+"`P0759R1 <https://wg21.link/P0759R1>`__","LWG","fpos Requirements","Rapperswil","|Complete|","11.0"
+"`P0769R2 <https://wg21.link/P0769R2>`__","LWG","Add shift to <algorithm>","Rapperswil","",""
+"`P0788R3 <https://wg21.link/P0788R3>`__","LWG","Standard Library Specification in a Concepts and Contracts World","Rapperswil","",""
+"`P0879R0 <https://wg21.link/P0879R0>`__","LWG","Constexpr for swap and swap related functions Also resolves LWG issue 2800.","Rapperswil","",""
+"`P0887R1 <https://wg21.link/P0887R1>`__","LWG","The identity metafunction","Rapperswil","|Complete|","8.0"
+"`P0892R2 <https://wg21.link/P0892R2>`__","CWG","explicit(bool)","Rapperswil","",""
+"`P0898R3 <https://wg21.link/P0898R3>`__","LWG","Standard Library Concepts","Rapperswil","",""
+"`P0935R0 <https://wg21.link/P0935R0>`__","LWG","Eradicating unnecessarily explicit default constructors from the standard library","Rapperswil","",""
+"`P0941R2 <https://wg21.link/P0941R2>`__","CWG","Integrating feature-test macros into the C++ WD","Rapperswil","|In Progress|",""
+"`P1023R0 <https://wg21.link/P1023R0>`__","LWG","constexpr comparison operators for std::array","Rapperswil","|Complete|","8.0"
+"`P1025R1 <https://wg21.link/P1025R1>`__","CWG","Update The Reference To The Unicode Standard","Rapperswil","",""
+"`P1120R0 <https://wg21.link/P1120R0>`__","CWG","Consistency improvements for <=> and other comparison operators","Rapperswil","",""
+"","","","","",""
+"`P0318R1 <https://wg21.link/P0318R1>`__","LWG","unwrap_ref_decay and unwrap_reference","San Diego","|Complete|","8.0"
+"`P0356R5 <https://wg21.link/P0356R5>`__","LWG","Simplified partial function application","San Diego","* *",""
+"`P0357R3 <https://wg21.link/P0357R3>`__","LWG","reference_wrapper for incomplete types","San Diego","|Complete|","8.0"
+"`P0482R6 <https://wg21.link/P0482R6>`__","CWG","char8_t: A type for UTF-8 characters and strings","San Diego","|In Progress|",""
+"`P0487R1 <https://wg21.link/P0487R1>`__","LWG","Fixing ``operator>>(basic_istream&, CharT*)``\  (LWG 2499)","San Diego","|Complete|","8.0"
+"`P0591R4 <https://wg21.link/P0591R4>`__","LWG","Utility functions to implement uses-allocator construction","San Diego","* *",""
+"`P0595R2 <https://wg21.link/P0595R2>`__","CWG","P0595R2 std::is_constant_evaluated()","San Diego","|Complete|","9.0"
+"`P0602R4 <https://wg21.link/P0602R4>`__","LWG","variant and optional should propagate copy/move triviality","San Diego","|Complete|","8.0"
+"`P0608R3 <https://wg21.link/P0608R3>`__","LWG","A sane variant converting constructor","San Diego","|Complete|","9.0"
+"`P0655R1 <https://wg21.link/P0655R1>`__","LWG","visit<R>: Explicit Return Type for visit","San Diego","* *",""
+"`P0771R1 <https://wg21.link/P0771R1>`__","LWG","std::function move constructor should be noexcept","San Diego","|Complete|","6.0"
+"`P0896R4 <https://wg21.link/P0896R4>`__","LWG","The One Ranges Proposal","San Diego","* *",""
+"`P0899R1 <https://wg21.link/P0899R1>`__","LWG","P0899R1 - LWG 3016 is not a defect","San Diego","|Nothing To Do|",""
+"`P0919R3 <https://wg21.link/P0919R3>`__","LWG","Heterogeneous lookup for unordered containers","San Diego","|Complete|","12.0"
+"`P0972R0 <https://wg21.link/P0972R0>`__","LWG","<chrono> ``zero()``\ , ``min()``\ , and ``max()``\  should be noexcept","San Diego","|Complete|","8.0"
+"`P1006R1 <https://wg21.link/P1006R1>`__","LWG","Constexpr in std::pointer_traits","San Diego","|Complete|","8.0"
+"`P1007R3 <https://wg21.link/P1007R3>`__","LWG","``std::assume_aligned``\ ","San Diego","* *",""
+"`P1020R1 <https://wg21.link/P1020R1>`__","LWG","Smart pointer creation with default initialization","San Diego","* *",""
+"`P1032R1 <https://wg21.link/P1032R1>`__","LWG","Misc constexpr bits","San Diego","* *",""
+"`P1085R2 <https://wg21.link/P1085R2>`__","LWG","Should Span be Regular?","San Diego","|Complete|","8.0"
+"`P1123R0 <https://wg21.link/P1123R0>`__","LWG","Editorial Guidance for merging P0019r8 and P0528r3","San Diego","* *",""
+"`P1148R0 <https://wg21.link/P1148R0>`__","LWG","Cleaning up Clause 20","San Diego","* *",""
+"`P1165R1 <https://wg21.link/P1165R1>`__","LWG","Make stateful allocator propagation more consistent for ``operator+(basic_string)``\ ","San Diego","* *",""
+"`P1209R0 <https://wg21.link/P1209R0>`__","LWG","Adopt Consistent Container Erasure from Library Fundamentals 2 for C++20","San Diego","|Complete|","8.0"
+"`P1210R0 <https://wg21.link/P1210R0>`__","LWG","Completing the Rebase of Library Fundamentals, Version 3, Working Draft","San Diego","* *",""
+"`P1236R1 <https://wg21.link/P1236R1>`__","CWG","Alternative Wording for P0907R4 Signed Integers are Two's Complement","San Diego","* *",""
+"`P1248R1 <https://wg21.link/P1248R1>`__","LWG","Remove CommonReference requirement from StrictWeakOrdering (a.k.a Fixing Relations)","San Diego","* *",""
+"`P1285R0 <https://wg21.link/P1285R0>`__","LWG","Improving Completeness Requirements for Type Traits","San Diego","* *",""
+"`P1353R0 <https://wg21.link/P1353R0>`__","CWG","Missing feature test macros","San Diego","* *",""
+"","","","","",""
+"`P0339R6 <https://wg21.link/P0339R6>`__","LWG","polymorphic_allocator<> as a vocabulary type","Kona","",""
+"`P0340R3 <https://wg21.link/P0340R3>`__","LWG","Making std::underlying_type SFINAE-friendly","Kona","|Complete|","9.0"
+"`P0738R2 <https://wg21.link/P0738R2>`__","LWG","I Stream, You Stream, We All Stream for istream_iterator","Kona","",""
+"`P0811R3 <https://wg21.link/P0811R3>`__","LWG","Well-behaved interpolation for numbers and pointers","Kona","|Complete|","9.0"
+"`P0920R2 <https://wg21.link/P0920R2>`__","LWG","Precalculated hash values in lookup","Kona","Reverted by `P1661 <https://wg21.link/P1661>`__",""
+"`P1001R2 <https://wg21.link/P1001R2>`__","LWG","Target Vectorization Policies from Parallelism V2 TS to C++20","Kona","",""
+"`P1024R3 <https://wg21.link/P1024R3>`__","LWG","Usability Enhancements for std::span","Kona","|Complete|","9.0"
+"`P1164R1 <https://wg21.link/P1164R1>`__","LWG","Make create_directory() Intuitive","Kona","",""
+"`P1227R2 <https://wg21.link/P1227R2>`__","LWG","Signed ssize() functions, unsigned size() functions","Kona","|Complete|","9.0"
+"`P1252R2 <https://wg21.link/P1252R2>`__","LWG","Ranges Design Cleanup","Kona","",""
+"`P1286R2 <https://wg21.link/P1286R2>`__","CWG","Contra CWG DR1778","Kona","",""
+"`P1357R1 <https://wg21.link/P1357R1>`__","LWG","Traits for [Un]bounded Arrays","Kona","|Complete|","9.0"
+"`P1458R1 <https://wg21.link/P1458R1>`__","LWG","Mandating the Standard Library: Clause 16 - Language support library","Kona","|Complete|","9.0"
+"`P1459R1 <https://wg21.link/P1459R1>`__","LWG","Mandating the Standard Library: Clause 18 - Diagnostics library","Kona","|Complete|","9.0"
+"`P1462R1 <https://wg21.link/P1462R1>`__","LWG","Mandating the Standard Library: Clause 20 - Strings library","Kona","|Complete|","9.0"
+"`P1463R1 <https://wg21.link/P1463R1>`__","LWG","Mandating the Standard Library: Clause 21 - Containers library","Kona","",""
+"`P1464R1 <https://wg21.link/P1464R1>`__","LWG","Mandating the Standard Library: Clause 22 - Iterators library","Kona","|Complete|","9.0"
+"","","","","",""
+"`P0325 <https://wg21.link/P0325>`__","LWG","to_array from LFTS with updates","Cologne","|Complete|","10.0"
+"`P0408 <https://wg21.link/P0408>`__","LWG","Efficient Access to basic_stringbuf's Buffer","Cologne","",""
+"`P0466 <https://wg21.link/P0466>`__","LWG","Layout-compatibility and Pointer-interconvertibility Traits","Cologne","",""
+"`P0553 <https://wg21.link/P0553>`__","LWG","Bit operations","Cologne","|Complete|","9.0"
+"`P0631 <https://wg21.link/P0631>`__","LWG","Math Constants","Cologne","|Complete|","11.0"
+"`P0645 <https://wg21.link/P0645>`__","LWG","Text Formatting","Cologne","",""
+"`P0660 <https://wg21.link/P0660>`__","LWG","Stop Token and Joining Thread, Rev 10","Cologne","",""
+"`P0784 <https://wg21.link/P0784>`__","CWG","More constexpr containers","Cologne","|Complete|","12.0"
+"`P0980 <https://wg21.link/P0980>`__","LWG","Making std::string constexpr","Cologne","",""
+"`P1004 <https://wg21.link/P1004>`__","LWG","Making std::vector constexpr","Cologne","",""
+"`P1035 <https://wg21.link/P1035>`__","LWG","Input Range Adaptors","Cologne","",""
+"`P1065 <https://wg21.link/P1065>`__","LWG","Constexpr INVOKE","Cologne","",""
+"`P1135 <https://wg21.link/P1135>`__","LWG","The C++20 Synchronization Library","Cologne","|Complete|",""
+"`P1207 <https://wg21.link/P1207>`__","LWG","Movability of Single-pass Iterators","Cologne","",""
+"`P1208 <https://wg21.link/P1208>`__","LWG","Adopt source_location for C++20","Cologne","",""
+"`P1355 <https://wg21.link/P1355>`__","LWG","Exposing a narrow contract for ceil2","Cologne","|Complete|","9.0"
+"`P1361 <https://wg21.link/P1361>`__","LWG","Integration of chrono with text formatting","Cologne","",""
+"`P1423 <https://wg21.link/P1423>`__","LWG","char8_t backward compatibility remediation","Cologne","",""
+"`P1424 <https://wg21.link/P1424>`__","LWG","'constexpr' feature macro concerns","Cologne","",""
+"`P1466 <https://wg21.link/P1466>`__","LWG","Miscellaneous minor fixes for chrono","Cologne","",""
+"`P1474 <https://wg21.link/P1474>`__","LWG","Helpful pointers for ContiguousIterator","Cologne","",""
+"`P1502 <https://wg21.link/P1502>`__","LWG","Standard library header units for C++20","Cologne","",""
+"`P1522 <https://wg21.link/P1522>`__","LWG","Iterator Difference Type and Integer Overflow","Cologne","",""
+"`P1523 <https://wg21.link/P1523>`__","LWG","Views and Size Types","Cologne","",""
+"`P1612 <https://wg21.link/P1612>`__","LWG","Relocate Endian's Specification","Cologne","|Complete|","10.0"
+"`P1614 <https://wg21.link/P1614>`__","LWG","The Mothership has Landed","Cologne","|In Progress|",""
+"`P1638 <https://wg21.link/P1638>`__","LWG","basic_istream_view::iterator should not be copyable","Cologne","",""
+"`P1643 <https://wg21.link/P1643>`__","LWG","Add wait/notify to atomic_ref","Cologne","",""
+"`P1644 <https://wg21.link/P1644>`__","LWG","Add wait/notify to atomic<shared_ptr>","Cologne","",""
+"`P1650 <https://wg21.link/P1650>`__","LWG","Output std::chrono::days with 'd' suffix","Cologne","",""
+"`P1651 <https://wg21.link/P1651>`__","LWG","bind_front should not unwrap reference_wrapper","Cologne","",""
+"`P1652 <https://wg21.link/P1652>`__","LWG","Printf corner cases in std::format","Cologne","",""
+"`P1661 <https://wg21.link/P1661>`__","LWG","Remove dedicated precalculated hash lookup interface","Cologne","|Nothing To Do|",""
+"`P1754 <https://wg21.link/P1754>`__","LWG","Rename concepts to standard_case for C++20, while we still can","Cologne","",""
+"","","","","",""
+"`P0883 <https://wg21.link/P0883>`__","LWG","Fixing Atomic Initialization","Belfast","* *",""
+"`P1391 <https://wg21.link/P1391>`__","LWG","Range constructor for std::string_view","Belfast","* *",""
+"`P1394 <https://wg21.link/P1394>`__","LWG","Range constructor for std::span","Belfast","* *",""
+"`P1456 <https://wg21.link/P1456>`__","LWG","Move-only views","Belfast","* *",""
+"`P1622 <https://wg21.link/P1622>`__","LWG","Mandating the Standard Library: Clause 32 - Thread support library","Belfast","* *",""
+"`P1645 <https://wg21.link/P1645>`__","LWG","constexpr for numeric algorithms","Belfast","* *",""
+"`P1664 <https://wg21.link/P1664>`__","LWG","reconstructible_range - a concept for putting ranges back together","Belfast","* *",""
+"`P1686 <https://wg21.link/P1686>`__","LWG","Mandating the Standard Library: Clause 27 - Time library","Belfast","* *",""
+"`P1690 <https://wg21.link/P1690>`__","LWG","Refinement Proposal for P0919 Heterogeneous lookup for unordered containers","Belfast","|Complete|","12.0"
+"`P1716 <https://wg21.link/P1716>`__","LWG","ranges compare algorithm are over-constrained","Belfast","* *",""
+"`P1718 <https://wg21.link/P1718>`__","LWG","Mandating the Standard Library: Clause 25 - Algorithms library","Belfast","* *",""
+"`P1719 <https://wg21.link/P1719>`__","LWG","Mandating the Standard Library: Clause 26 - Numerics library","Belfast","* *",""
+"`P1720 <https://wg21.link/P1720>`__","LWG","Mandating the Standard Library: Clause 28 - Localization library","Belfast","* *",""
+"`P1721 <https://wg21.link/P1721>`__","LWG","Mandating the Standard Library: Clause 29 - Input/Output library","Belfast","* *",""
+"`P1722 <https://wg21.link/P1722>`__","LWG","Mandating the Standard Library: Clause 30 - Regular Expression library","Belfast","* *",""
+"`P1723 <https://wg21.link/P1723>`__","LWG","Mandating the Standard Library: Clause 31 - Atomics library","Belfast","* *",""
+"`P1855 <https://wg21.link/P1855>`__","LWG","Make ``<compare>``\  freestanding","Belfast","* *",""
+"`P1862 <https://wg21.link/P1862>`__","LWG","Ranges adaptors for non-copyable iterators","Belfast","* *",""
+"`P1865 <https://wg21.link/P1865>`__","LWG","Add max() to latch and barrier","Belfast","* *",""
+"`P1869 <https://wg21.link/P1869>`__","LWG","Rename 'condition_variable_any' interruptible wait methods","Belfast","* *",""
+"`P1870 <https://wg21.link/P1870>`__","LWG","forwarding-range is too subtle","Belfast","* *",""
+"`P1871 <https://wg21.link/P1871>`__","LWG","Should concepts be enabled or disabled?","Belfast","* *",""
+"`P1872 <https://wg21.link/P1872>`__","LWG","span should have size_type, not index_type","Belfast","|Complete|","10.0"
+"`P1878 <https://wg21.link/P1878>`__","LWG","Constraining Readable Types","Belfast","* *",""
+"`P1892 <https://wg21.link/P1892>`__","LWG","Extended locale-specific presentation specifiers for std::format","Belfast","* *",""
+"`P1902 <https://wg21.link/P1902>`__","LWG","Missing feature-test macros 2018-2019","Belfast","* *",""
+"`P1959 <https://wg21.link/P1959>`__","LWG","Remove std::weak_equality and std::strong_equality","Belfast","* *",""
+"`P1960 <https://wg21.link/P1960>`__","LWG","NB Comment Changes Reviewed by SG1","Belfast","* *",""
+"`P1961 <https://wg21.link/P1961>`__","LWG","Harmonizing the definitions of total order for pointers","Belfast","* *",""
+"`P1965 <https://wg21.link/P1965>`__","LWG","Blanket Wording for Specifying ""Hidden Friends""","Belfast","* *",""
+"","","","","",""
+"`P0586 <https://wg21.link/P0586>`__","LWG","Safe integral comparisons","Prague","* *",""
+"`P0593 <https://wg21.link/P0593>`__","CWG","Implicit creation of objects for low-level object manipulation","Prague","* *",""
+"`P1115 <https://wg21.link/P1115>`__","LWG","Improving the Return Value of Erase-Like Algorithms II: Free erase/erase if","Prague","|Complete|","11.0"
+"`P1243 <https://wg21.link/P1243>`__","LWG","Rangify New Algorithms","Prague","* *",""
+"`P1460 <https://wg21.link/P1460>`__","LWG","Mandating the Standard Library: Clause 20 - Utilities library","Prague","* *",""
+"`P1739 <https://wg21.link/P1739>`__","LWG","Avoid template bloat for safe_ranges in combination with ""subrange-y"" view adaptors","Prague","* *",""
+"`P1831 <https://wg21.link/P1831>`__","LWG","Deprecating volatile: library","Prague","* *",""
+"`P1868 <https://wg21.link/P1868>`__","LWG","width: clarifying units of width and precision in std::format","Prague","* *",""
+"`P1908 <https://wg21.link/P1908>`__","CWG","Reserving Attribute Namespaces for Future Use","Prague","* *",""
+"`P1937 <https://wg21.link/P1937>`__","CWG","Fixing inconsistencies between constexpr and consteval functions","Prague","* *",""
+"`P1956 <https://wg21.link/P1956>`__","LWG","On the names of low-level bit manipulation functions","Prague","|Complete|","12.0"
+"`P1957 <https://wg21.link/P1957>`__","CWG","Converting from ``T*``\  to bool should be considered narrowing (re: US 212)","Prague","* *",""
+"`P1963 <https://wg21.link/P1963>`__","LWG","Fixing US 313","Prague","* *",""
+"`P1964 <https://wg21.link/P1964>`__","LWG","Wording for boolean-testable","Prague","* *",""
+"`P1970 <https://wg21.link/P1970>`__","LWG","Consistency for size() functions: Add ranges::ssize","Prague","* *",""
+"`P1973 <https://wg21.link/P1973>`__","LWG","Rename ""_default_init"" Functions, Rev1","Prague","* *",""
+"`P1976 <https://wg21.link/P1976>`__","LWG","Fixed-size span construction from dynamic range","Prague","|Complete|","11.0"
+"`P1981 <https://wg21.link/P1981>`__","LWG","Rename leap to leap_second","Prague","* *",""
+"`P1982 <https://wg21.link/P1982>`__","LWG","Rename link to time_zone_link","Prague","* *",""
+"`P1983 <https://wg21.link/P1983>`__","LWG","Wording for GB301, US296, US292, US291, and US283","Prague","* *",""
+"`P1994 <https://wg21.link/P1994>`__","LWG","elements_view needs its own sentinel","Prague","* *",""
+"`P2002 <https://wg21.link/P2002>`__","CWG","Defaulted comparison specification cleanups","Prague","* *",""
+"`P2045 <https://wg21.link/P2045>`__","LWG","Missing Mandates for the standard library","Prague","* *",""
+"`P2085 <https://wg21.link/P2085>`__","CWG","Consistent defaulted comparisons","Prague","* *",""
+"`P2091 <https://wg21.link/P2091>`__","LWG","Issues with range access CPOs","Prague","* *",""
+"`P2101 <https://wg21.link/P2101>`__","LWG","'Models' subsumes 'satisfies' (Wording for US298 and US300)","Prague","* *",""
+"`P2102 <https://wg21.link/P2102>`__","LWG","Make 'implicit expression variations' more explicit (Wording for US185)","Prague","* *",""
+"`P2106 <https://wg21.link/P2106>`__","LWG","Alternative wording for GB315 and GB316","Prague","* *",""
+"`P2116 <https://wg21.link/P2116>`__","LWG","Remove tuple-like protocol support from fixed-extent span","Prague","|Complete|","11.0"

libcxx/docs/Styles.rst

+.. raw:: html
+
+      <style type="text/css">
+        .nothingtodo {
+            background-color: #99FF99;
+            font-style: italic;
+         }
+        .inprogress {
+            background-color: #FFFF99;
+            font-style: italic;
+         }
+        .partial {
+            background-color: #2CCCFF;
+            font-style: italic;
+         }
+        .complete { background-color: #99FF99; }
+      </style>
+
+.. role:: nothingtodo
+.. role:: inprogress
+.. role:: partial
+.. role:: complete
+
+
+.. |Nothing To Do| replace:: :nothingtodo:`Nothing To Do`
+.. |In Progress| replace:: :inprogress:`In Progress`
+.. |Partial| replace:: :partial:`Partial`
+.. |Complete| replace:: :complete:`Complete`
+
+.. |sect| unicode:: U+00A7
+.. |hellip| unicode:: U+2026

libcxx/docs/conf.py

 # The encoding of source files.
 #source_encoding = 'utf-8-sig'
 
 # The master toctree document.
 master_doc = 'index'
 
 # General information about the project.
 project = u'libc++'
-copyright = u'2011-2018, LLVM Project'
+copyright = u'2011-2020, LLVM Project'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
 # built documents.
 #
 # The short X.Y version.
 version = '12.0'
 # The full version, including alpha/beta/rc tags.

libcxx/docs/index.rst

 
 .. toctree::
    :maxdepth: 2
 
    ReleaseNotes
    UsingLibcxx
    BuildingLibcxx
    TestingLibcxx
+   Cxx1yStatus
+   Cxx1zStatus
+   Cxx2aStatus
 
 
 .. toctree::
     :hidden:
 
     AddingNewCIJobs
     FeatureTestMacroTable
 

 * Clang 4.0 and above
 * GCC 5.0 and above.
 
 
 C++ Dialect Support
 ---------------------
 
 * C++11 - Complete
-* `C++14 - Complete <http://libcxx.llvm.org/cxx1y_status.html>`__
-* `C++17 - In Progress <http://libcxx.llvm.org/cxx1z_status.html>`__
+* :ref:`C++14 - Complete <cxx1y-status>`
+* :ref:`C++17 - In Progress <cxx1z-status>`
+* :ref:`C++20 - In Progress <cxx2a-status>`
 * `Post C++14 Technical Specifications - In Progress <http://libcxx.llvm.org/ts1z_status.html>`__
 * :ref:`C++ Feature Test Macro Status <feature-status>`
 
 Notes and Known Issues
 ----------------------
 
 This list contains known issues with libc++
 

libcxx/www/cxx1y_status.html

-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
-          "http://www.w3.org/TR/html4/strict.dtd">
-<!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ -->
-<html>
+<!DOCTYPE HTML>
+<html lang="en-US">
 <head>
-  <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+    <meta charset="UTF-8">
+    <meta http-equiv="refresh" content="0; url=docs/Cxx1yStatus.html">
+    <script type="text/javascript">
+        window.location.href = "docs/Cxx1yStatus.html"
+    </script>
     <title>libc++ C++14 Status</title>
-  <link type="text/css" rel="stylesheet" href="menu.css">
-  <link type="text/css" rel="stylesheet" href="content.css">
 </head>
-
 <body>
-<div id="menu">
-  <div>
-    <a href="https://llvm.org/">LLVM Home</a>
-  </div>
-
-  <div class="submenu">
-    <label>libc++ Info</label>
-    <a href="/index.html">About</a>
-  </div>
-
-  <div class="submenu">
-    <label>Quick Links</label>
-    <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
-    <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
-    <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
-  </div>
-</div>
-
-<div id="content">
-  <!--*********************************************************************-->
-  <h1>libc++ C++14 Status</h1>
-  <!--*********************************************************************-->
-
-  <p>In April 2013, the C++ standard committee approved the draft for the next version of the C++ standard, initially known as "C++1y".</p>
-  <p>The draft standard includes papers and issues that were voted on at the previous three meetings (Kona, Portland, and Bristol)</p>
-  <p>In August 2014, this draft was approved by ISO as C++14</p>
-  <p>This page shows the status of libc++; the status of clang's support of the language features is <a href="https://clang.llvm.org/cxx_status.html#cxx14">here</a>.</p>
-
-  <p>The groups that have contributed papers:
-  <ul>
-    <li>CWG - Core Language Working group</li>
-    <li>LWG - Library working group</li>
-    <li>SG1 - Study group #1 (Concurrency working group)</li>
-  </ul>
-  </p>
-
-  <h3>Paper Status</h3>
-  <table id="papers" border="1">
-  <tr><th>Paper #</th><th>Group</th><th>Paper Name</th><th>Meeting</th><th>Status</th><th>First released version</th></tr>
-
-  <tr><td><a href="https://wg21.link/n3346">3346</a></td><td>LWG</td><td>Terminology for Container Element Requirements - Rev 1</td><td>Kona</td><td>Complete</td><td>3.4</td></tr>
-  <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-
-<!--   <tr><td>3323</td><td>CWG</td><td>A Proposal to Tweak Certain C++ Contextual Conversions, v3</td><td>Portland</td><td></td><td></td></tr> -->
-
-  <tr><td><a href="https://wg21.link/n3421">3421</a></td><td>LWG</td><td>Making Operator Functors greater&lt;&gt;</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
-  <tr><td><a href="https://wg21.link/n3462">3462</a></td><td>LWG</td><td>std::result_of and SFINAE</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
-  <tr><td><a href="https://wg21.link/n3469">3469</a></td><td>LWG</td><td>Constexpr Library Additions: chrono, v3</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
-  <tr><td><a href="https://wg21.link/n3470">3470</a></td><td>LWG</td><td>Constexpr Library Additions: containers, v2</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
-  <tr><td><a href="https://wg21.link/n3471">3471</a></td><td>LWG</td><td>Constexpr Library Additions: utilities, v3</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
-  <tr><td><a href="https://wg21.link/n3302">3302</a></td><td>LWG</td><td>Constexpr Library Additions: complex, v2</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
-  <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-
-<!--   <tr><td>3472</td><td>CWG</td><td>Binary Literals in the C++ Core Language</td><td>Bristol</td><td></td><td></td></tr> -->
-<!--   <tr><td>3624</td><td>CWG</td><td>Core Issue 1512: Pointer comparison vs qualification conversions (revision 3)</td><td>Bristol</td><td></td><td></td></tr> -->
-<!--   <tr><td>3639</td><td>CWG</td><td>Runtime-sized arrays with automatic storage duration (revision 5)</td><td>Bristol</td><td></td><td></td></tr> -->
-<!--   <tr><td>3638</td><td>CWG</td><td>Return type deduction for normal functions</td><td>Bristol</td><td></td><td></td></tr> -->
-<!--   <tr><td>3648</td><td>CWG</td><td>Wording Changes for Generalized Lambda-capture</td><td>Bristol</td><td></td><td></td></tr> -->
-<!--   <tr><td>3653</td><td>CWG</td><td>Member initializers and aggregates</td><td>Bristol</td><td></td><td></td></tr> -->
-<!--   <tr><td>3667</td><td>CWG</td><td>Drafting for Core 1402</td><td>Bristol</td><td></td><td></td></tr> -->
-<!--   <tr><td>3652</td><td>CWG</td><td>Relaxing constraints on constexpr functions" and "constexpr member functions and implicit const</td><td>Bristol</td><td></td><td></td></tr> -->
-<!--   <tr><td>3664</td><td>CWG</td><td>Clarifying Memory Allocation</td><td>Bristol</td><td></td><td></td></tr> -->
-<!--   <tr><td>3651</td><td>CWG</td><td>Variable Templates (Revision 1)</td><td>Bristol</td><td></td><td></td></tr> -->
-<!--   <tr><td>3649</td><td>CWG</td><td>Generic (Polymorphic) Lambda Expressions (Revision 3)</td><td>Bristol</td><td></td><td></td></tr> -->
-
-  <tr><td><a href="https://wg21.link/n3545">3545</a></td><td>LWG</td><td>An Incremental Improvement to integral_constant</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
-  <tr><td><a href="https://wg21.link/n3644">3644</a></td><td>LWG</td><td>Null Forward Iterators</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
-  <tr><td><a href="https://wg21.link/n3668">3668</a></td><td>LWG</td><td>std::exchange()</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
-  <tr><td><a href="https://wg21.link/n3658">3658</a></td><td>LWG</td><td>Compile-time integer sequences</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
-  <tr><td><a href="https://wg21.link/n3670">3670</a></td><td>LWG</td><td>Addressing Tuples by Type</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
-  <tr><td><a href="https://wg21.link/n3671">3671</a></td><td>LWG</td><td>Making non-modifying sequence operations more robust</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
-  <tr><td><a href="https://wg21.link/n3656">3656</a></td><td>LWG</td><td>make_unique</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
-  <tr><td><a href="https://wg21.link/n3654">3654</a></td><td>LWG</td><td>Quoted Strings</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
-  <tr><td><a href="https://wg21.link/n3642">3642</a></td><td>LWG</td><td>User-defined Literals</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
-  <tr><td><a href="https://wg21.link/n3655">3655</a></td><td>LWG</td><td>TransformationTraits Redux (excluding part 4)</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
-  <tr><td><a href="https://wg21.link/n3657">3657</a></td><td>LWG</td><td>Adding heterogeneous comparison lookup to associative containers</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
-  <tr><td><a href="https://wg21.link/n3672">3672</a></td><td>LWG</td><td>A proposal to add a utility class to represent optional objects</td><td>Bristol</td><td><I>Removed from Draft Standard</I></td><td>n/a</td></tr>
-  <tr><td><a href="https://wg21.link/n3669">3669</a></td><td>LWG</td><td>Fixing constexpr member functions without const</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
-  <tr><td><a href="https://wg21.link/n3662">3662</a></td><td>LWG</td><td>C++ Dynamic Arrays (dynarray)</td><td>Bristol</td><td><I>Removed from Draft Standard</I></td><td>n/a</td></tr>
-
-  <tr><td><a href="https://wg21.link/n3659">3659</a></td><td>SG1</td><td>Shared Locking in C++</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
-
-   <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/n3779">3779</a></td><td>LWG</td><td>User-defined Literals for std::complex</td><td>Chicago</td><td>Complete</td><td>3.4</td></tr>
-  <tr><td><a href="https://wg21.link/n3789">3789</a></td><td>LWG</td><td>Constexpr Library Additions: functional</td><td>Chicago</td><td>Complete</td><td>3.4</td></tr>
-   <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-
-  <tr><td><a href="https://wg21.link/n3924">3924</a></td><td>LWG</td><td>Discouraging rand() in C++14</td><td>Issaquah</td><td>Complete</td><td>3.5</td></tr>
-  <tr><td><a href="https://wg21.link/n3887">3887</a></td><td>LWG</td><td>Consistent Metafunction Aliases</td><td>Issaquah</td><td>Complete</td><td>3.5</td></tr>
-  <tr><td><a href="https://wg21.link/n3891">3891</a></td><td>SG1</td><td>A proposal to rename shared_mutex to shared_timed_mutex</td><td>Issaquah</td><td>Complete</td><td>3.5</td></tr>
-
-<!--   <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr> -->
-  </table>
-
-  <h3>Library Working group Issues Status</h3>
-<!--   <I>Note: "NAD" means that the issue was deemed "Not a defect"</I> -->
-  <table id="issues" border="1">
-  <tr><th>Issue #</th><th>Issue Name</th><th>Meeting</th><th>Status</th></tr>
-  <tr><td><a href="https://wg21.link/lwg1214">1214</a></td><td>Insufficient/inconsistent key immutability requirements for associative containers</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2009">2009</a></td><td>Reporting out-of-bound values on numeric string conversions</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2010">2010</a></td><td>is_* traits for binding operations can't be meaningfully specialized</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2015">2015</a></td><td>Incorrect pre-conditions for some type traits</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2021">2021</a></td><td>Further incorrect usages of result_of</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2028">2028</a></td><td>messages_base::catalog overspecified</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2033">2033</a></td><td>Preconditions of reserve, shrink_to_fit, and resize functions</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2039">2039</a></td><td>Issues with std::reverse and std::copy_if</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2044">2044</a></td><td>No definition of "Stable" for copy algorithms</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2045">2045</a></td><td>forward_list::merge and forward_list::splice_after with unequal allocators</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2047">2047</a></td><td>Incorrect "mixed" move-assignment semantics of unique_ptr</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2050">2050</a></td><td>Unordered associative containers do not use allocator_traits to define member types</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2053">2053</a></td><td>Errors in regex bitmask types</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2061">2061</a></td><td>make_move_iterator and arrays</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2064">2064</a></td><td>More noexcept issues in basic_string</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2065">2065</a></td><td>Minimal allocator interface</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2067">2067</a></td><td>packaged_task should have deleted copy c'tor with const parameter</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2069">2069</a></td><td>Inconsistent exception spec for basic_string move constructor</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2096">2096</a></td><td>Incorrect constraints of future::get in regard to MoveAssignable</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2102">2102</a></td><td>Why is std::launch an implementation-defined type?</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/lwg2071">2071</a></td><td>std::valarray move-assignment</td><td>Portland</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2074">2074</a></td><td>Off by one error in std::reverse_copy</td><td>Portland</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2081">2081</a></td><td>Allocator requirements should include CopyConstructible</td><td>Portland</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2083">2083</a></td><td>const-qualification on weak_ptr::owner_before</td><td>Portland</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2086">2086</a></td><td>Overly generic type support for math functions</td><td>Portland</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2099">2099</a></td><td>Unnecessary constraints of va_start() usage</td><td>Portland</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2103">2103</a></td><td>std::allocator_traits&lt;std::allocator&lt;T&gt;&gt;::propagate_on_container_move_assignment</td><td>Portland</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2105">2105</a></td><td>Inconsistent requirements on const_iterator's value_type</td><td>Portland</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2110">2110</a></td><td>remove can't swap but note says it might</td><td>Portland</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2123">2123</a></td><td>merge() allocator requirements for lists versus forward lists</td><td>Portland</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2005">2005</a></td><td>unordered_map::insert(T&&) protection should apply to map too</td><td>Portland</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2011">2011</a></td><td>Unexpected output required of strings</td><td>Portland</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2048">2048</a></td><td>Unnecessary mem_fn overloads</td><td>Portland</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2049">2049</a></td><td>is_destructible is underspecified</td><td>Portland</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2056">2056</a></td><td>future_errc enums start with value 0 (invalid value for broken_promise)</td><td>Portland</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2058">2058</a></td><td>valarray and begin/end</td><td>Portland</td><td>Complete</td></tr>
-  <tr><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/lwg2091">2091</a></td><td>Misplaced effect in m.try_lock_for()</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2092">2092</a></td><td>Vague Wording for condition_variable_any</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2093">2093</a></td><td>Throws clause of condition_variable::wait with predicate</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2094">2094</a></td><td>duration conversion overflow shouldn't participate in overload resolution</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2122">2122</a></td><td>merge() stability for lists versus forward lists</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2128">2128</a></td><td>Absence of global functions cbegin/cend</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2145">2145</a></td><td>error_category default constructor</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2147">2147</a></td><td>Unclear hint type in Allocator's allocate function</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2148">2148</a></td><td>Hashing enums should be supported directly by std::hash</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2149">2149</a></td><td>Concerns about 20.8/5</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2162">2162</a></td><td>allocator_traits::max_size missing noexcept</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2163">2163</a></td><td>nth_element requires inconsistent post-conditions</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2169">2169</a></td><td>Missing reset() requirements in unique_ptr specialization</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2172">2172</a></td><td>Does atomic_compare_exchange_* accept v == nullptr arguments?</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2080">2080</a></td><td>Specify when once_flag becomes invalid</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2098">2098</a></td><td>promise throws clauses</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2109">2109</a></td><td>Incorrect requirements for hash specializations</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2130">2130</a></td><td>missing ordering constraints for fences</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2138">2138</a></td><td>atomic_flag::clear ordering constraints</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2140">2140</a></td><td>notify_all_at_thread_exit synchronization</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2144">2144</a></td><td>Missing noexcept specification in type_index</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2174">2174</a></td><td>wstring_convert::converted() should be noexcept</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2175">2175</a></td><td>string_convert and wbuffer_convert validity</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2176">2176</a></td><td>Special members for wstring_convert and wbuffer_convert</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2177">2177</a></td><td>Requirements on Copy/MoveInsertable</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2185">2185</a></td><td>Missing throws clause for future/shared_future::wait_for/wait_until</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2187">2187</a></td><td>vector&lt;bool&gt; is missing emplace and emplace_back member functions</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2190">2190</a></td><td>ordering of condition variable operations, reflects Posix discussion</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2196">2196</a></td><td>Specification of is_*[copy/move]_[constructible/assignable] unclear for non-referencable types</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2197">2197</a></td><td>Specification of is_[un]signed unclear for non-arithmetic types</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2200">2200</a></td><td>Data race avoidance for all containers, not only for sequences</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2203">2203</a></td><td>scoped_allocator_adaptor uses wrong argument types for piecewise construction</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2207">2207</a></td><td>basic_string::at should not have a Requires clause</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2209">2209</a></td><td>assign() overspecified for sequence containers</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2210">2210</a></td><td>Missing allocator-extended constructor for allocator-aware containers</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2211">2211</a></td><td>Replace ambiguous use of "Allocator" in container requirements</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2222">2222</a></td><td>Inconsistency in description of forward_list::splice_after single-element overload</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2225">2225</a></td><td>Unrealistic header inclusion checks required</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2229">2229</a></td><td>Standard code conversion facets underspecified</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2231">2231</a></td><td>DR 704 removes complexity guarantee for clear()</td><td>Bristol</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2235">2235</a></td><td>Undefined behavior without proper requirements on basic_string constructors</td><td>Bristol</td><td>Complete</td></tr>
-    <tr><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/lwg2141">2141</a></td><td>common_type trait produces reference types</td><td>Chicago</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2246">2246</a></td><td>unique_ptr assignment effects w.r.t. deleter</td><td>Chicago</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2247">2247</a></td><td>Type traits and std::nullptr_t</td><td>Chicago</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2085">2085</a></td><td>Wrong description of effect 1 of basic_istream::ignore</td><td>Chicago</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2087">2087</a></td><td>iostream_category() and noexcept</td><td>Chicago</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2143">2143</a></td><td>ios_base::xalloc should be thread-safe</td><td>Chicago</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2150">2150</a></td><td>Unclear specification of find_end</td><td>Chicago</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2180">2180</a></td><td>Exceptions from std::seed_seq operations</td><td>Chicago</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2194">2194</a></td><td>Impossible container requirements for adaptor types</td><td>Chicago</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2013">2013</a></td><td>Do library implementers have the freedom to add constexpr?</td><td>Chicago</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2018">2018</a></td><td>regex_traits::isctype Returns clause is wrong</td><td>Chicago</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2078">2078</a></td><td>Throw specification of async() incomplete</td><td>Chicago</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2097">2097</a></td><td>packaged_task constructors should be constrained</td><td>Chicago</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2100">2100</a></td><td>Timed waiting functions cannot timeout if launch::async policy used</td><td>Chicago</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2120">2120</a></td><td>What should async do if neither 'async' nor 'deferred' is set in policy?</td><td>Chicago</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2159">2159</a></td><td>atomic_flag initialization</td><td>Chicago</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2275">2275</a></td><td>Why is forward_as_tuple not constexpr?</td><td>Chicago</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2284">2284</a></td><td>Inconsistency in allocator_traits::max_size</td><td>Chicago</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2298">2298</a></td><td>is_nothrow_constructible is always false because of create&lt;&gt;</td><td>Chicago</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2300">2300</a></td><td>Redundant sections for map and multimap members should be removed</td><td>Chicago</td><td>Complete</td></tr>
-  <tr><td>NB comment: GB9</td>                                                                     <td>Remove gets from C++14</td><td>Chicago</td><td>Complete</td></tr>
-    <tr><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/lwg2135">2135</a></td><td>Unclear requirement for exceptions thrown in condition_variable::wait()</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2291">2291</a></td><td>std::hash is vulnerable to collision DoS attack</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2142">2142</a></td><td>packaged_task::operator() synchronization too broad?</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2240">2240</a></td><td>Probable misuse of term "function scope" in [thread.condition]</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2252">2252</a></td><td>Strong guarantee on vector::push_back() still broken with C++11?</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2257">2257</a></td><td>Simplify container requirements with the new algorithms</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2268">2268</a></td><td>Setting a default argument in the declaration of a member function assign of std::basic_string</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2271">2271</a></td><td>regex_traits::lookup_classname specification unclear</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2272">2272</a></td><td>quoted should use char_traits::eq for character comparison</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2278">2278</a></td><td>User-defined literals for Standard Library types</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2280">2280</a></td><td>begin / end for arrays should be constexpr and noexcept</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2285">2285</a></td><td>make_reverse_iterator</td><td>Issaquah</td><td>Complete</td></tr>
-
-  <tr><td><a href="https://wg21.link/lwg2299">2299</a></td><td>Effects of inaccessible key_compare::is_transparent type are not clear</td><td>Issaquah</td><td>Complete</td></tr>
-
-  <tr><td><a href="https://wg21.link/lwg1450">1450</a></td><td>Contradiction in regex_constants</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2003">2003</a></td><td>String exception inconsistency in erase.</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2112">2112</a></td><td>User-defined classes that cannot be derived from</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2132">2132</a></td><td>std::function ambiguity</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2182">2182</a></td><td>Container::[const_]reference types are misleadingly specified</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2188">2188</a></td><td>Reverse iterator does not fully support targets that overload operator&</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2193">2193</a></td><td>Default constructors for standard library containers are explicit</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2205">2205</a></td><td>Problematic postconditions of regex_match and regex_search</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2213">2213</a></td><td>Return value of std::regex_replace</td><td>Issaquah</td><td>Complete</td></tr>
-
-  <tr><td><a href="https://wg21.link/lwg2258">2258</a></td><td>a.erase(q1, q2) unable to directly return q2</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2263">2263</a></td><td>Comparing iterators and allocator pointers with different const-character</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2293">2293</a></td><td>Wrong facet used by num_put::do_put</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2301">2301</a></td><td>Why is std::tie not constexpr?</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2304">2304</a></td><td>Complexity of count in unordered associative containers</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2306">2306</a></td><td>match_results::reference should be value_type&, not const value_type&</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2308">2308</a></td><td>Clarify container destructor requirements w.r.t. std::array</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2313">2313</a></td><td>tuple_size should always derive from integral_constant<size_t, N></td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2314">2314</a></td><td>apply() should return decltype(auto) and use decay_t before tuple_size</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2315">2315</a></td><td>weak_ptr should be movable</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2316">2316</a></td><td>weak_ptr::lock() should be atomic</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2317">2317</a></td><td>The type property queries should be UnaryTypeTraits returning size_t</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2320">2320</a></td><td>select_on_container_copy_construction() takes allocators, not containers</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2322">2322</a></td><td>Associative(initializer_list, stuff) constructors are underspecified</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2323">2323</a></td><td>vector::resize(n, t)'s specification should be simplified</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2324">2324</a></td><td>Insert iterator constructors should use addressof()</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2329">2329</a></td><td>regex_match()/regex_search() with match_results should forbid temporary strings</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2330">2330</a></td><td>regex("meow", regex::icase) is technically forbidden but should be permitted</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2332">2332</a></td><td>regex_iterator/regex_token_iterator should forbid temporary regexes</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2339">2339</a></td><td>Wording issue in nth_element</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2341">2341</a></td><td>Inconsistency between basic_ostream::seekp(pos) and basic_ostream::seekp(off, dir)</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2344">2344</a></td><td>quoted()'s interaction with padding is unclear</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2346">2346</a></td><td>integral_constant's member functions should be marked noexcept</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2350">2350</a></td><td>min, max, and minmax should be constexpr</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2356">2356</a></td><td>Stability of erasure in unordered associative containers</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2357">2357</a></td><td>Remaining "Assignable" requirement</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2359">2359</a></td><td>How does regex_constants::nosubs affect basic_regex::mark_count()?</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2360">2360</a></td><td>reverse_iterator::operator*() is unimplementable</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2104">2104</a></td><td>unique_lock move-assignment should not be noexcept</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2186">2186</a></td><td>Incomplete action on async/launch::deferred</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2075">2075</a></td><td>Progress guarantees, lock-free property, and scheduling assumptions</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/lwg2288">2288</a></td><td>Inconsistent requirements for shared mutexes</td><td>Issaquah</td><td>Complete</td></tr>
-<!--   <tr><td></td><td></td><td></td><td></td></tr> -->
-  </table>
-
-  <p>Last Updated: 25-Mar-2014</p>
-</div>
+    If you are not redirected automatically, follow this <a href='docs/Cxx1yStatus.html'>link to new documentation</a>.
 </body>
 </html>

libcxx/www/cxx1z_status.html

-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
-          "http://www.w3.org/TR/html4/strict.dtd">
-<!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ -->
-<html>
+<!DOCTYPE HTML>
+<html lang="en-US">
 <head>
-  <meta http-equiv="content-type" content="text/html; charset=utf-8">
+    <meta charset="UTF-8">
+    <meta http-equiv="refresh" content="0; url=docs/Cxx1zStatus.html">
+    <script type="text/javascript">
+        window.location.href = "docs/Cxx1zStatus.html"
+    </script>
     <title>libc++ C++17 Status</title>
-  <link type="text/css" rel="stylesheet" href="menu.css">
-  <link type="text/css" rel="stylesheet" href="content.css">
 </head>
-
 <body>
-<div id="menu">
-  <div>
-    <a href="https://llvm.org/">LLVM Home</a>
-  </div>
-
-  <div class="submenu">
-    <label>libc++ Info</label>
-    <a href="/index.html">About</a>
-  </div>
-
-  <div class="submenu">
-    <label>Quick Links</label>
-    <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
-    <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
-    <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
-  </div>
-</div>
-
-<div id="content">
-  <!--*********************************************************************-->
-  <h1>libc++ C++17 Status</h1>
-  <!--*********************************************************************-->
-
-  <p>In November 2014, the C++ standard committee created a draft for the next version of the C++ standard, initially known as "C++1z".</p>
-  <p>In February 2017, the C++ standard committee approved this draft, and sent it to ISO for approval as C++17</p>
-  <p>This page shows the status of libc++; the status of clang's support of the language features is <a href="https://clang.llvm.org/cxx_status.html#cxx17">here</a>.</p>
-
-  <p>Reminder: Features in unreleased drafts of the standard are subject to change.</p>
-
-  <p>The groups that have contributed papers:
-  <ul>
-    <li>LWG - Library working group</li>
-    <li>CWG - Core Language Working group</li>
-    <li>SG1 - Study group #1 (Concurrency working group)</li>
-  </ul>
-  </p>
-
-  <h3>Paper Status</h3>
-  <table id="papers" border="1">
-  <tr><th>Paper #</th><th>Group</th><th>Paper Name</th><th>Meeting</th><th>Status</th><th>First released version</th></tr>
-<!--
-  <tr><td><a href="https://wg21.link/n3346">3346</a></td><td>LWG</td><td>Terminology for Container Element Requirements - Rev 1</td><td>Kona</td><td>Complete</td><td>3.4</td></tr>
--->
-  <tr><td><a href="https://wg21.link/n3911">N3911</a></td><td>LWG</td><td>TransformationTrait Alias <code>void_t</code>.</td><td>Urbana</td><td>Complete</td><td>3.6</td></tr>
-  <tr><td><a href="https://wg21.link/n4089">N4089</a></td><td>LWG</td><td>Safe conversions in <code>unique_ptr&lt;T[]&gt;</code>.</td><td>Urbana</td><td>In progress</td><td>3.9</td></tr>
-  <tr><td><a href="https://wg21.link/n4169">N4169</a></td><td>LWG</td><td>A proposal to add invoke function template</td><td>Urbana</td><td>Complete</td><td>3.7</td></tr>
-  <tr><td><a href="https://wg21.link/n4190">N4190</a></td><td>LWG</td><td>Removing auto_ptr, random_shuffle(), And Old <functional> Stuff.</td><td>Urbana</td><td>In progress</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/n4258">N4258</a></td><td>LWG</td><td>Cleaning-up noexcept in the Library.</td><td>Urbana</td><td>In progress</td><td>3.7</td></tr>
-  <tr><td><a href="https://wg21.link/n4259">N4259</a></td><td>CWG</td><td>Wording for std::uncaught_exceptions</td><td>Urbana</td><td>Complete</td><td>3.7</td></tr>
-  <tr><td><a href="https://wg21.link/n4277">N4277</a></td><td>LWG</td><td>TriviallyCopyable <code>reference_wrapper</code>.</td><td>Urbana</td><td>Complete</td><td>3.2</td></tr>
-  <tr><td><a href="https://wg21.link/n4279">N4279</a></td><td>LWG</td><td>Improved insertion interface for unique-key maps.</td><td>Urbana</td><td>Complete</td><td>3.7</td></tr>
-  <tr><td><a href="https://wg21.link/n4280">N4280</a></td><td>LWG</td><td>Non-member size() and more</td><td>Urbana</td><td>Complete</td><td>3.6</td></tr>
-  <tr><td><a href="https://wg21.link/n4284">N4284</a></td><td>LWG</td><td>Contiguous Iterators.</td><td>Urbana</td><td>Complete</td><td>3.6</td></tr>
-  <tr><td><a href="https://wg21.link/n4285">N4285</a></td><td>CWG</td><td>Cleanup for exception-specification and throw-expression.</td><td>Urbana</td><td>Complete</td><td>4.0</td></tr>
-    <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/n4387">N4387</a></td><td>LWG</td><td>improving pair and tuple</td><td>Lenexa</td><td>Complete</td><td>4.0</td></tr>
-  <tr><td><a href="https://wg21.link/n4389">N4389</a></td><td>LWG</td><td>bool_constant</td><td>Lenexa</td><td>Complete</td><td>3.7</td></tr>
-  <tr><td><a href="https://wg21.link/n4508">N4508</a></td><td>LWG</td><td>shared_mutex for C++17</td><td>Lenexa</td><td>Complete</td><td>3.7</td></tr>
-  <tr><td><a href="https://wg21.link/n4366">N4366</a></td><td>LWG</td><td>LWG 2228 missing SFINAE rule</td><td>Lenexa</td><td>Complete</td><td>3.1</td></tr>
-  <tr><td><a href="https://wg21.link/n4510">N4510</a></td><td>LWG</td><td>Minimal incomplete type support for standard containers, revision 4</td><td>Lenexa</td><td>Complete</td><td>3.6</td></tr>
-    <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/p0004r1">P0004R1</a></td><td>LWG</td><td>Remove Deprecated iostreams aliases.</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
-  <tr><td><a href="https://wg21.link/p0006r0">P0006R0</a></td><td>LWG</td><td>Adopt Type Traits Variable Templates for C++17.</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
-  <tr><td><a href="https://wg21.link/p0092r1">P0092R1</a></td><td>LWG</td><td>Polishing &lt;chrono&gt;</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
-  <tr><td><a href="https://wg21.link/p0007r1">P0007R1</a></td><td>LWG</td><td>Constant View: A proposal for a <tt>std::as_const</tt> helper function template.</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
-  <tr><td><a href="https://wg21.link/p0156r0">P0156R0</a></td><td>LWG</td><td>Variadic lock_guard(rev 3).</td><td>Kona</td><td><I>Reverted in Kona</I></td><td>3.9</td></tr>
-  <tr><td><a href="https://wg21.link/p0074r0">P0074R0</a></td><td>LWG</td><td>Making <tt>std::owner_less</tt> more flexible</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
-  <tr><td><a href="https://wg21.link/p0013r1">P0013R1</a></td><td>LWG</td><td>Logical type traits rev 2</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
-    <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0024R2">P0024R2</a></td><td>LWG</td><td>The Parallelism TS Should be Standardized</td><td>Jacksonville</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0226R1">P0226R1</a></td><td>LWG</td><td>Mathematical Special Functions for C++17</td><td>Jacksonville</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0220R1">P0220R1</a></td><td>LWG</td><td>Adopt Library Fundamentals V1 TS Components for C++17</td><td>Jacksonville</td><td>In Progress</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0218R1">P0218R1</a></td><td>LWG</td><td>Adopt the File System TS for C++17</td><td>Jacksonville</td><td>Complete</td><td>7.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0033R1">P0033R1</a></td><td>LWG</td><td>Re-enabling shared_from_this</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
-  <tr><td><a href="https://wg21.link/P0005R4">P0005R4</a></td><td>LWG</td><td>Adopt not_fn from Library Fundamentals 2 for C++17</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
-  <tr><td><a href="https://wg21.link/P0152R1">P0152R1</a></td><td>LWG</td><td>constexpr atomic::is_always_lock_free</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
-  <tr><td><a href="https://wg21.link/P0185R1">P0185R1</a></td><td>LWG</td><td>Adding [nothrow-]swappable traits</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
-  <tr><td><a href="https://wg21.link/P0253R1">P0253R1</a></td><td>LWG</td><td>Fixing a design mistake in the searchers interface</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
-  <tr><td><a href="https://wg21.link/P0025R0">P0025R0</a></td><td>LWG</td><td>An algorithm to "clamp" a value between a pair of boundary values</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
-  <tr><td><a href="https://wg21.link/P0154R1">P0154R1</a></td><td>LWG</td><td>constexpr std::hardware_{constructive,destructive}_interference_size</td><td>Jacksonville</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0030R1">P0030R1</a></td><td>LWG</td><td>Proposal to Introduce a 3-Argument Overload to std::hypot</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
-  <tr><td><a href="https://wg21.link/P0031R0">P0031R0</a></td><td>LWG</td><td>A Proposal to Add Constexpr Modifiers to reverse_iterator, move_iterator, array and Range Access</td><td>Jacksonville</td><td>Complete</td><td>4.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0272R1">P0272R1</a></td><td>LWG</td><td>Give <tt>std::string</tt> a non-const <tt>.data()</tt> member function</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
-  <tr><td><a href="https://wg21.link/P0077R2">P0077R2</a></td><td>LWG</td><td><tt>is_callable</tt>, the missing INVOKE related trait</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
-    <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/p0032r3">p0032r3</a></td><td>LWG</td><td>Homogeneous interface for variant, any and optional</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
-  <tr><td><a href="https://wg21.link/p0040r3">p0040r3</a></td><td>LWG</td><td>Extending memory management tools</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
-  <tr><td><a href="https://wg21.link/p0063r3">p0063r3</a></td><td>LWG</td><td>C++17 should refer to C11 instead of C99</td><td>Oulu</td><td>Complete</td><td>7.0</td></tr>
-  <tr><td><a href="https://wg21.link/p0067r3">p0067r3</a></td><td>LWG</td><td>Elementary string conversions</td><td>Oulu</td><td>Now <a href="https://wg21.link/P0067R5">P0067R5</a></td><td>n/a</td></tr>
-  <tr><td><a href="https://wg21.link/p0083r3">p0083r3</a></td><td>LWG</td><td>Splicing Maps and Sets</td><td>Oulu</td><td><i>Complete</i></td><td>8.0</td></tr>
-  <tr><td><a href="https://wg21.link/p0084r2">p0084r2</a></td><td>LWG</td><td>Emplace Return Type</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
-  <tr><td><a href="https://wg21.link/p0088r3">p0088r3</a></td><td>LWG</td><td>Variant: a type-safe union for C++17</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
-  <tr><td><a href="https://wg21.link/p0137r1">p0137r1</a></td><td>CWG</td><td>Core Issue 1776: Replacement of class objects containing reference members</td><td>Oulu</td><td>Complete</td><td>6.0</td></tr>
-  <tr><td><a href="https://wg21.link/p0163r0">p0163r0</a></td><td>LWG</td><td>shared_ptr::weak_type</td><td>Oulu</td><td>Complete</td><td>3.9</td></tr>
-  <tr><td><a href="https://wg21.link/p0174r2">p0174r2</a></td><td>LWG</td><td>Deprecating Vestigial Library Parts in C++17</td><td>Oulu</td><td>Partial</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/p0175r1">p0175r1</a></td><td>LWG</td><td>Synopses for the C library</td><td>Oulu</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/p0180r2">p0180r2</a></td><td>LWG</td><td>Reserve a New Library Namespace for Future Standardization</td><td>Oulu</td><td><i>Nothing to do</i></td><td>n/a</td></tr>
-  <tr><td><a href="https://wg21.link/p0181r1">p0181r1</a></td><td>LWG</td><td>Ordered by Default</td><td>Oulu</td><td><i>Removed in Kona</i></td><td>n/a</td></tr>
-  <tr><td><a href="https://wg21.link/p0209r2">p0209r2</a></td><td>LWG</td><td>make_from_tuple: apply for construction</td><td>Oulu</td><td>Complete</td><td>3.9</td></tr>
-  <tr><td><a href="https://wg21.link/p0219r1">p0219r1</a></td><td>LWG</td><td>Relative Paths for Filesystem</td><td>Oulu</td><td>Complete</td><td>7.0</td></tr>
-  <tr><td><a href="https://wg21.link/p0254r2">p0254r2</a></td><td>LWG</td><td>Integrating std::string_view and std::string</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
-  <tr><td><a href="https://wg21.link/p0258r2">p0258r2</a></td><td>LWG</td><td>has_unique_object_representations</td><td>Oulu</td><td>Complete</td><td>6.0</td></tr>
-  <tr><td><a href="https://wg21.link/p0295r0">p0295r0</a></td><td>LWG</td><td>Adopt Selected Library Fundamentals V2 Components for C++17</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
-  <tr><td><a href="https://wg21.link/p0302r1">p0302r1</a></td><td>LWG</td><td>Removing Allocator Support in std::function</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
-  <tr><td><a href="https://wg21.link/p0307r2">p0307r2</a></td><td>LWG</td><td>Making Optional Greater Equal Again</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
-  <tr><td><a href="https://wg21.link/p0336r1">p0336r1</a></td><td>LWG</td><td>Better Names for Parallel Execution Policies in C++17</td><td>Oulu</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/p0337r0">p0337r0</a></td><td>LWG</td><td>Delete operator= for polymorphic_allocator</td><td>Oulu</td><td>Complete</td><td>3.9</td></tr>
-  <tr><td><a href="https://wg21.link/p0346r1">p0346r1</a></td><td>LWG</td><td>A &lt;random&gt; Nomenclature Tweak</td><td>Oulu</td><td>Complete</td><td>3.9</td></tr>
-  <tr><td><a href="https://wg21.link/p0358r1">p0358r1</a></td><td>LWG</td><td>Fixes for not_fn</td><td>Oulu</td><td>Complete</td><td>3.9</td></tr>
-  <tr><td><a href="https://wg21.link/p0371r1">p0371r1</a></td><td>LWG</td><td>Temporarily discourage memory_order_consume</td><td>Oulu</td><td><i>Nothing to do</i></td><td>n/a</td></tr>
-  <tr><td><a href="https://wg21.link/p0392r0">p0392r0</a></td><td>LWG</td><td>Adapting string_view by filesystem paths</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
-  <tr><td><a href="https://wg21.link/p0393r3">p0393r3</a></td><td>LWG</td><td>Making Variant Greater Equal</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0394r4">P0394r4</a></td><td>LWG</td><td>Hotel Parallelifornia: terminate() for Parallel Algorithms Exception Handling</td><td>Oulu</td><td></td><td></td></tr>
-    <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0003R5">P0003R5</a></td><td>LWG</td><td>Removing Deprecated Exception Specifications from C++17</td><td>Issaquah</td><td>Complete</td><td>5.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0067R5">P0067R5</a></td><td>LWG</td><td>Elementary string conversions, revision 5</td><td>Issaquah</td><td><i>Partially done</i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0403R1">P0403R1</a></td><td>LWG</td><td>Literal suffixes for <tt>basic_string_view</tt></td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0414R2">P0414R2</a></td><td>LWG</td><td>Merging shared_ptr changes from Library Fundamentals to C++17</td><td>Issaquah</td><td>Complete</td><td>11.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0418R2">P0418R2</a></td><td>LWG</td><td>Fail or succeed: there is no atomic lattice</td><td>Issaquah</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0426R1">P0426R1</a></td><td>LWG</td><td>Constexpr for <tt>std::char_traits</tt></td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0435R1">P0435R1</a></td><td>LWG</td><td>Resolving LWG Issues re <tt>common_type</tt></td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0502R0">P0502R0</a></td><td>LWG</td><td>Throwing out of a parallel algorithm terminates - but how?</td><td>Issaquah</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0503R0">P0503R0</a></td><td>LWG</td><td>Correcting library usage of "literal type"</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0504R0">P0504R0</a></td><td>LWG</td><td>Revisiting in-place tag types for any/optional/variant</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0505R0">P0505R0</a></td><td>LWG</td><td>Wording for GB 50 - constexpr for chrono</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0508R0">P0508R0</a></td><td>LWG</td><td>Wording for GB 58 - structured bindings for node_handles</td><td>Issaquah</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0509R1">P0509R1</a></td><td>LWG</td><td>Updating "Restrictions on exception handling"</td><td>Issaquah</td><td><i>Nothing to do</i></td><td>n/a</td></tr>
-  <tr><td><a href="https://wg21.link/P0510R0">P0510R0</a></td><td>LWG</td><td>Disallowing references, incomplete types, arrays, and empty variants</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0513R0">P0513R0</a></td><td>LWG</td><td>Poisoning the Hash</td><td>Issaquah</td><td>Complete</td><td>5.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0516R0">P0516R0</a></td><td>LWG</td><td>Clarify That shared_future's Copy Operations have Wide Contracts</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0517R0">P0517R0</a></td><td>LWG</td><td>Make future_error Constructible</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0521R0">P0521R0</a></td><td>LWG</td><td>Proposed Resolution for CA 14 (shared_ptr use_count/unique)</td><td>Issaquah</td><td><i>Nothing to do</i></td><td>n/a</td></tr>
-    <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0156R2">P0156R2</a></td><td>LWG</td><td>Variadic Lock guard(rev 5)</td><td>Kona</td><td>Complete</td><td>5.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0270R3">P0270R3</a></td><td>CWG</td><td>Removing C dependencies from signal handler wording</td><td>Kona</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0298R3">P0298R3</a></td><td>CWG</td><td>A byte type definition</td><td>Kona</td><td>Complete</td><td>5.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0317R1">P0317R1</a></td><td>LWG</td><td>Directory Entry Caching for Filesystem</td><td>Kona</td><td>Complete</td><td>7.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0430R2">P0430R2</a></td><td>LWG</td><td>File system library on non-POSIX-like operating systems</td><td>Kona</td><td>Complete</td><td>7.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0433R2">P0433R2</a></td><td>LWG</td><td>Toward a resolution of US7 and US14: Integrating template deduction for class templates into the standard library</td><td>Kona</td><td><i>In progress</i></td><td>7.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0452R1">P0452R1</a></td><td>LWG</td><td>Unifying &lt;numeric&gt; Parallel Algorithms</td><td>Kona</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0467R2">P0467R2</a></td><td>LWG</td><td>Iterator Concerns for Parallel Algorithms</td><td>Kona</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0492R2">P0492R2</a></td><td>LWG</td><td>Proposed Resolution of C++17 National Body Comments for Filesystems</td><td>Kona</td><td>Complete</td><td>7.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0518R1">P0518R1</a></td><td>LWG</td><td>Allowing copies as arguments to function objects given to parallel algorithms in response to CH11</td><td>Kona</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0523R1">P0523R1</a></td><td>LWG</td><td>Wording for CH 10: Complexity of parallel algorithms</td><td>Kona</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0548R1">P0548R1</a></td><td>LWG</td><td>common_type and duration</td><td>Kona</td><td>Complete</td><td>5.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0558R1">P0558R1</a></td><td>LWG</td><td>Resolving atomic&lt;T&gt; named base class inconsistencies</td><td>Kona</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0574R1">P0574R1</a></td><td>LWG</td><td>Algorithm Complexity Constraints and Parallel Overloads</td><td>Kona</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0599R1">P0599R1</a></td><td>LWG</td><td>noexcept for hash functions</td><td>Kona</td><td>Complete</td><td>5.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0604R0">P0604R0</a></td><td>LWG</td><td>Resolving GB 55, US 84, US 85, US 86</td><td>Kona</td><td>Complete</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0607R0">P0607R0</a></td><td>LWG</td><td>Inline Variables for the Standard Library</td><td>Kona</td><td><i>In Progress</i></td><td>6.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0618R0">P0618R0</a></td><td>LWG</td><td>Deprecating &lt;codecvt&gt;</td><td>Kona</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0623R0">P0623R0</a></td><td>LWG</td><td>Final C++17 Parallel Algorithms Fixes</td><td>Kona</td><td></td><td></td></tr>
-    <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0682R1">P0682R1</a></td><td>LWG</td><td>Repairing elementary string conversions</td><td>Toronto</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0739R0">P0739R0</a></td><td>LWG</td><td>Some improvements to class template argument deduction integration into the standard library</td><td>Toronto</td><td>Complete</td><td>5.0</td></tr>
-
-<!--   <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr> -->
-  </table>
-
-<p><i>The parts of P0607 that are not done are the &lt;regex&gt; bits.</i></p>
-<p><i>So far, only the &lt;string&gt;, sequence containers, container adaptors and &lt;regex&gt; portions of P0433 have been implemented.</i></p>
-
-<p><i>[ Note: "Nothing to do" means that no library changes were needed to implement this change -- end note]</i></p>
-
-  <h3>Library Working group Issues Status</h3>
-<!--   <I>Note: "NAD" means that the issue was deemed "Not a defect"</I> -->
-  <table id="issues" border="1">
-  <tr><th>Issue #</th><th>Issue Name</th><th>Meeting</th><th>Status</th></tr>
-  <tr><td><a href="https://wg21.link/LWG2016">2016</a></td><td>Allocators must be no-throw swappable</td><td>Urbana</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2376">2118</a></td><td><code>unique_ptr</code> for array does not support cv qualification conversion of actual argument</td><td>Urbana</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2170">2170</a></td><td>Aggregates cannot be <code>DefaultConstructible</code></td><td>Urbana</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2308">2308</a></td><td>Clarify container destructor requirements w.r.t. <code>std::array</code></td><td>Urbana</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2340">2340</a></td><td>Replacement allocation functions declared as inline</td><td>Urbana</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2354">2354</a></td><td>Unnecessary copying when inserting into maps with braced-init syntax</td><td>Urbana</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2377">2377</a></td><td><code>std::align</code> requirements overly strict</td><td>Urbana</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2396">2396</a></td><td><code>underlying_type</code> doesn't say what to do for an incomplete enumeration type</td><td>Urbana</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2399">2399</a></td><td><code>shared_ptr</code>'s constructor from <code>unique_ptr</code> should be constrained</td><td>Urbana</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2400">2400</a></td><td><code>shared_ptr</code>'s <code>get_deleter()</code> should use <code>addressof()</code></td><td>Urbana</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2401">2401</a></td><td><code>std::function</code> needs more noexcept</td><td>Urbana</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2404">2404</a></td><td><code>mismatch()</code>'s complexity needs to be updated</td><td>Urbana</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2408">2408</a></td><td>SFINAE-friendly <code>common_type</code> / <code>iterator_traits</code> is missing in C++14</td><td>Urbana</td><td>Complete</td></tr>
-   <tr><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2106">2106</a></td><td><code>move_iterator</code> wrapping iterators returning prvalues</td><td>Urbana</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2129">2129</a></td><td>User specializations of <code>std::initializer_list</code></td><td>Urbana</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2212">2212</a></td><td><code>tuple_size</code> for <code>const pair</code> request <tuple> header</td><td>Urbana</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2217">2217</a></td><td><code>operator==(sub_match, string)</code> slices on embedded '\0's</td><td>Urbana</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2230">2230</a></td><td>"see below" for <code>initializer_list</code> constructors of unordered containers</td><td>Urbana</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2233">2233</a></td><td><code>bad_function_call::what()</code> unhelpful</td><td>Urbana</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2266">2266</a></td><td><code>vector</code> and <code>deque</code> have incorrect insert requirements</td><td>Urbana</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2325">2325</a></td><td><code>minmax_element()</code>'s behavior differing from <code>max_element()</code>'s should be noted</td><td>Urbana</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2361">2361</a></td><td>Apply 2299 resolution throughout library</td><td>Urbana</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2365">2365</a></td><td>Missing noexcept in <code>shared_ptr::shared_ptr(nullptr_t)</code></td><td>Urbana</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2376">2376</a></td><td><code>bad_weak_ptr::what()</code> overspecified</td><td>Urbana</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2387">2387</a></td><td>More nested types that must be accessible and unambiguous</td><td>Urbana</td><td>Complete</td></tr>
-   <tr><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2059">2059</a></td><td>C++0x ambiguity problem with map::erase</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2063">2063</a></td><td>Contradictory requirements for string move assignment</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2076">2076</a></td><td>Bad CopyConstructible requirement in set constructors</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2160">2160</a></td><td>Unintended destruction ordering-specification of resize</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2168">2168</a></td><td>Inconsistent specification of uniform_real_distribution constructor</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2239">2239</a></td><td>min/max/minmax requirements</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2364">2364</a></td><td>deque and vector pop_back don't specify iterator invalidation requirements</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2369">2369</a></td><td>constexpr max(initializer_list) vs max_element</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2378">2378</a></td><td>Behaviour of standard exception types</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2403">2403</a></td><td>stof() should call strtof() and wcstof()</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2406">2406</a></td><td>negative_binomial_distribution should reject p == 1</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2407">2407</a></td><td>packaged_task(allocator_arg_t, const Allocator&, F&&) should neither be constrained nor explicit</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2411">2411</a></td><td>shared_ptr is only contextually convertible to bool</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2415">2415</a></td><td>Inconsistency between unique_ptr and shared_ptr</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2420">2420</a></td><td>function<void(ArgTypes...)> does not discard the return value of the target object</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2425">2425</a></td><td>operator delete(void*, size_t) doesn't invalidate pointers sufficiently</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2427">2427</a></td><td>Container adaptors as sequence containers, redux</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2428">2428</a></td><td>"External declaration" used without being defined</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2433">2433</a></td><td>uninitialized_copy()/etc. should tolerate overloaded operator&</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2434">2434</a></td><td>shared_ptr::use_count() is efficient</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2437">2437</a></td><td>iterator_traits::reference can and can't be void</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2438">2438</a></td><td>std::iterator inheritance shouldn't be mandated</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2439">2439</a></td><td>unique_copy() sometimes can't fall back to reading its output</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2440">2440</a></td><td>seed_seq::size() should be noexcept</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2442">2442</a></td><td>call_once() shouldn't DECAY_COPY()</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2448">2448</a></td><td>Non-normative Container destructor specification</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2454">2454</a></td><td>Add raw_storage_iterator::base() member</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2455">2455</a></td><td>Allocator default construction should be allowed to throw</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2458">2458</a></td><td>N3778 and new library deallocation signatures</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2459">2459</a></td><td>std::polar should require a non-negative rho</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2464">2464</a></td><td>try_emplace and insert_or_assign misspecified</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2467">2467</a></td><td>is_always_equal has slightly inconsistent default</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2470">2470</a></td><td>Allocator's destroy function should be allowed to fail to instantiate</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2482">2482</a></td><td>[c.strings] Table 73 mentions nonexistent functions</td><td>Lenexa</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2488">2488</a></td><td>Placeholders should be allowed and encouraged to be constexpr</td><td>Lenexa</td><td>Complete</td></tr>
-   <tr><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG1169">1169</a></td><td><tt>num_get</tt> not fully compatible with <tt>strto*</tt></td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2072">2072</a></td><td>Unclear wording about capacity of temporary buffers</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2101">2101</a></td><td>Some transformation types can produce impossible types</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2111">2111</a></td><td>Which <tt>unexpected</tt>&#47;<tt>terminate</tt> handler is called from the exception handling runtime?</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2119">2119</a></td><td>Missing <tt>hash</tt> specializations for extended integer types</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2127">2127</a></td><td>Move-construction with <tt>raw_storage_iterator</tt></td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2133">2133</a></td><td>Attitude to overloaded comma for iterators</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2156">2156</a></td><td>Unordered containers' <tt>reserve(n)</tt> reserves for <tt>n-1</tt> elements</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2218">2218</a></td><td>Unclear how containers use <tt>allocator_traits::construct()</tt></td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2219">2219</a></td><td><tt><i>INVOKE</i></tt>-ing a pointer to member with a <tt>reference_wrapper</tt> as the object expression</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2224">2224</a></td><td>Ambiguous status of access to non-live objects</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2234">2234</a></td><td><tt>assert()</tt> should allow usage in constant expressions</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2244">2244</a></td><td>Issue on <tt>basic_istream::seekg</tt></td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2250">2250</a></td><td>Follow-up On Library Issue 2207</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2259">2259</a></td><td>Issues in 17.6.5.5 rules for member functions</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2273">2273</a></td><td><tt>regex_match</tt> ambiguity</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2336">2336</a></td><td><tt>is_trivially_constructible/is_trivially_assignable</tt> traits are always false</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2353">2353</a></td><td><tt>std::next</tt> is over-constrained</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2367">2367</a></td><td><tt>pair</tt> and <tt>tuple</tt> are not correctly implemented for <tt>is_constructible</tt> with no args</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2380">2380</a></td><td>May <tt>&lt;cstdlib&gt;</tt> provide <tt>long ::abs(long)</tt> and <tt>long long ::abs(long long)</tt>?</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2384">2384</a></td><td>Allocator's <tt>deallocate</tt> function needs better specification</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2385">2385</a></td><td><tt>function::assign</tt> allocator argument doesn't make sense</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2435">2435</a></td><td><tt>reference_wrapper::operator()</tt>'s Remark should be deleted</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2447">2447</a></td><td>Allocators and <tt>volatile</tt>-qualified value types</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2462">2462</a></td><td><tt>std::ios_base::failure</tt> is overspecified</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2466">2466</a></td><td><tt>allocator_traits::max_size()</tt> default behavior is incorrect</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2469">2469</a></td><td>Wrong specification of Requires clause of <tt>operator[]</tt> for <tt>map</tt> and <tt>unordered_map</tt></td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2473">2473</a></td><td><tt>basic_filebuf</tt>'s relation to C <tt>FILE</tt> semantics</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2476">2476</a></td><td><tt>scoped_allocator_adaptor</tt> is not assignable</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2477">2477</a></td><td>Inconsistency of wordings in <tt>std::vector::erase()</tt> and <tt>std::deque::erase()</tt></td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2483">2483</a></td><td><tt>throw_with_nested()</tt> should use <tt>is_final</tt></td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2484">2484</a></td><td><tt>rethrow_if_nested()</tt> is doubly unimplementable</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2485">2485</a></td><td><tt>get()</tt> should be overloaded for <tt>const tuple&amp;&amp;</tt></td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2486">2486</a></td><td><tt>mem_fn()</tt> should be required to use perfect forwarding</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2487">2487</a></td><td><tt>bind()</tt> should be <tt>const</tt>-overloaded, not <i>cv</i>-overloaded</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2489">2489</a></td><td><tt>mem_fn()</tt> should be <tt>noexcept</tt></td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2492">2492</a></td><td>Clarify requirements for <tt>comp</tt></td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2495">2495</a></td><td>There is no such thing as an Exception Safety element</td><td>Kona</td><td>Complete</td></tr>
-   <tr><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2192">2192</a></td><td>Validity and return type of <tt>std::abs(0u)</tt> is unclear</td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2276">2276</a></td><td>Missing requirement on <tt>std::promise::set_exception</tt></td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2296">2296</a></td><td><tt>std::addressof</tt> should be <tt>constexpr</tt></td><td>Jacksonville</td><td>Complete (Clang Only)</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2450">2450</a></td><td><tt>(greater|less|greater_equal|less_equal)&lt;void&gt;</tt> do not yield a total order for pointers</td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2520">2520</a></td><td>N4089 broke initializing <tt>unique_ptr&lt;T[]&gt;</tt> from a <tt>nullptr</tt></td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2522">2522</a></td><td>[fund.ts.v2] Contradiction in <tt>set_default_resource</tt> specification</td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2523">2523</a></td><td><tt>std::promise</tt> synopsis shows two <tt>set_value_at_thread_exit()</tt>'s for no apparent reason</td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2537">2537</a></td><td>Constructors for <code>priority_queue</code> taking allocators should call <code>make_heap</code></td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2539">2539</a></td><td>[fund.ts.v2] <tt>invocation_trait</tt> definition definition doesn't work for surrogate call functions</td><td>Jacksonville</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2545">2545</a></td><td>Simplify wording for <tt>bind</tt> without explicitly specified return type</td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2557">2557</a></td><td>Logical operator traits are broken in the zero-argument case</td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2558">2558</a></td><td>[fund.ts.v2] Logical operator traits are broken in the zero-argument case</td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2559">2559</a></td><td>Error in LWG 2234's resolution</td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2560">2560</a></td><td><tt>is_constructible</tt> underspecified when applied to a function type</td><td>Jacksonville</td><td>Broken in 3.6; See r261653.</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2565">2565</a></td><td><tt>std::function</tt>'s move constructor should guarantee nothrow for <tt>reference_wrapper</tt>s and function pointers</td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2566">2566</a></td><td>Requirements on the first template parameter of container adaptors</td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2571">2571</a></td><td>&sect;[map.modifiers]/2 imposes nonsensical requirement on <tt>insert(InputIterator, InputIterator)</tt></td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2572">2572</a></td><td>The remarks for <tt>shared_ptr::operator*</tt> should apply to <i>cv</i>-qualified <tt>void</tt> as well</td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2574">2574</a></td><td>[fund.ts.v2] <tt>std::experimental::function::operator=(F&amp;&amp;)</tt> should be constrained</td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2575">2575</a></td><td>[fund.ts.v2] <tt>experimental::function::assign</tt> should be removed</td><td>Jacksonville</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2576">2576</a></td><td><tt>istream_iterator</tt> and <tt>ostream_iterator</tt> should use <tt>std::addressof</tt></td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2577">2577</a></td><td><tt>{shared,unique}_lock</tt> should use <tt>std::addressof</tt></td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2579">2579</a></td><td>Inconsistency wrt Allocators in <tt>basic_string</tt> assignment vs. <tt>basic_string::assign</tt></td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2581">2581</a></td><td>Specialization of <tt>&lt;type_traits&gt;</tt> variable templates should be prohibited</td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2582">2582</a></td><td>&sect;[res.on.functions]/2's prohibition against incomplete types shouldn't apply to type traits</td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2583">2583</a></td><td>There is no way to supply an allocator for <tt>basic_string(str, pos)</tt></td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2585">2585</a></td><td><tt>forward_list::resize(size_type, const value_type&amp;)</tt> effects incorrect</td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2586">2586</a></td><td>Wrong value category used in <tt>scoped_allocator_adaptor::construct()</tt></td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2590">2590</a></td><td>Aggregate initialization for <tt>std::array</tt></td><td>Jacksonville</td><td>Complete</td></tr>
-   <tr><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2181">2181</a></td><td>Exceptions from seed sequence operations</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2309">2309</a></td><td>mutex::lock() should not throw device_or_resource_busy</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2310">2310</a></td><td>Public exposition only member in std::array</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2312">2312</a></td><td>tuple's constructor constraints need to be phrased more precisely</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2328">2328</a></td><td>Rvalue stream extraction should use perfect forwarding</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2393">2393</a></td><td>std::function's Callable definition is broken</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2422">2422</a></td><td>std::numeric_limits&lt;T&gt;::is_modulo description: "most machines" errata</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2426">2426</a></td><td>Issue about compare_exchange</td><td>Oulu</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2436">2436</a></td><td>Comparators for associative containers should always be CopyConstructible</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2441">2441</a></td><td>Exact-width atomic typedefs should be provided</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2451">2451</a></td><td>[fund.ts.v2] optional should 'forward' T's implicit conversions</td><td>Oulu</td><td>Nothing to do</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2509">2509</a></td><td>[fund.ts.v2] any_cast doesn't work with rvalue reference targets and cannot move with a value target</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2516">2516</a></td><td>[fund.ts.v2] Public "exposition only" members in observer_ptr</td><td>Oulu</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2542">2542</a></td><td>Missing const requirements for associative containers</td><td>Oulu</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2549">2549</a></td><td>Tuple EXPLICIT constructor templates that take tuple parameters end up taking references to temporaries and will create dangling references</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2550">2550</a></td><td>Wording of unordered container's clear() method complexity</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2551">2551</a></td><td>[fund.ts.v2] "Exception safety" cleanup in library fundamentals required</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2555">2555</a></td><td>[fund.ts.v2] No handling for over-aligned types in optional</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2573">2573</a></td><td>[fund.ts.v2] std::hash&lt;std::experimental::shared_ptr&gt; does not work for arrays</td><td>Oulu</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2596">2596</a></td><td>vector::data() should use addressof</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2667">2667</a></td><td>path::root_directory() description is confusing</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2669">2669</a></td><td>recursive_directory_iterator effects refers to non-existent functions</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2670">2670</a></td><td>system_complete refers to undefined variable 'base'</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2671">2671</a></td><td>Errors in Copy</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2673">2673</a></td><td>status() effects cannot be implemented as specified</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2674">2674</a></td><td>Bidirectional iterator requirement on path::iterator is very expensive</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2683">2683</a></td><td>filesystem::copy() says "no effects"</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2684">2684</a></td><td>priority_queue lacking comparator typedef</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2685">2685</a></td><td>shared_ptr deleters must not throw on move construction</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2687">2687</a></td><td>{inclusive,exclusive}_scan misspecified</td><td>Oulu</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2688">2688</a></td><td>clamp misses preconditions and has extraneous condition on result</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2689">2689</a></td><td>Parallel versions of std::copy and std::move shouldn't be in order</td><td>Oulu</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2698">2698</a></td><td>Effect of assign() on iterators/pointers/references</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2704">2704</a></td><td>recursive_directory_iterator's members should require '*this is dereferenceable'</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2706">2706</a></td><td>Error reporting for recursive_directory_iterator::pop() is under-specified</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2707">2707</a></td><td>path construction and assignment should have "string_type&&" overloads</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2709">2709</a></td><td>offsetof is unnecessarily imprecise</td><td>Oulu</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2710">2710</a></td><td>"Effects: Equivalent to ..." doesn't count "Synchronization:" as determined semantics</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2711">2711</a></td><td>path is convertible from approximately everything under the sun</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2716">2716</a></td><td>Specification of shuffle and sample disallows lvalue URNGs</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2718">2718</a></td><td>Parallelism bug in [algorithms.parallel.exec] p2</td><td>Oulu</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2719">2719</a></td><td>permissions function should not be noexcept due to narrow contract</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2720">2720</a></td><td>permissions function incorrectly specified for symlinks</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2721">2721</a></td><td>remove_all has incorrect post conditions</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2723">2723</a></td><td>Do directory_iterator and recursive_directory_iterator become the end iterator upon error?</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2724">2724</a></td><td>The protected virtual member functions of memory_resource should be private</td><td>Oulu</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2725">2725</a></td><td>filesystem::exists(const path&, error_code&) error reporting</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2726">2726</a></td><td>[recursive_]directory_iterator::increment(error_code&) is underspecified</td><td>Oulu</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2727">2727</a></td><td>Parallel algorithms with constexpr specifier</td><td>Oulu</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2728">2728</a></td><td>status(p).permissions() and symlink_status(p).permissions() are not specified</td><td>Oulu</td><td>Complete</td></tr>
-   <tr><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2062">2062</a></td><td>Effect contradictions w/o no-throw guarantee of std::function swaps</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2166">2166</a></td><td>Heap property underspecified?</td><td>Issaquah</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2221">2221</a></td><td>No formatted output operator for nullptr</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2223">2223</a></td><td>shrink_to_fit effect on iterator validity</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2261">2261</a></td><td>Are containers required to use their 'pointer' type internally?</td><td>Issaquah</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2394">2394</a></td><td>locale::name specification unclear - what is implementation-defined?</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2460">2460</a></td><td>LWG issue 2408 and value categories</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2468">2468</a></td><td>Self-move-assignment of library types</td><td>Issaquah</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2475">2475</a></td><td>Allow overwriting of std::basic_string terminator with charT() to allow cleaner interoperation with legacy APIs</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2503">2503</a></td><td>multiline option should be added to syntax_option_type</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2510">2510</a></td><td>Tag types should not be DefaultConstructible</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2514">2514</a></td><td>Type traits must not be final</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2518">2518</a></td><td>[fund.ts.v2] Non-member swap for propagate_const should call member swap</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2519">2519</a></td><td>Iterator operator-= has gratuitous undefined behaviour</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2521">2521</a></td><td>[fund.ts.v2] weak_ptr's converting move constructor should be modified as well for array support</td><td>Issaquah</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2525">2525</a></td><td>[fund.ts.v2] get_memory_resource should be const and noexcept</td><td>Issaquah</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2527">2527</a></td><td>[fund.ts.v2] ALLOCATOR_OF for function::operator= has incorrect default</td><td>Issaquah</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2531">2531</a></td><td>future::get should explicitly state that the shared state is released</td><td>Issaquah</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2534">2534</a></td><td>Constrain rvalue stream operators</td><td>Issaquah</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2536">2536</a></td><td>What should &lt;complex.h&gt; do?</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2540">2540</a></td><td>unordered_multimap::insert hint iterator</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2543">2543</a></td><td>LWG 2148 (hash support for enum types) seems under-specified</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2544">2544</a></td><td>istreambuf_iterator(basic_streambuf<charT, traits>* s) effects unclear when s is 0</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2556">2556</a></td><td>Wide contract for future::share()</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2562">2562</a></td><td>Consistent total ordering of pointers by comparison functors</td><td>Issaquah</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2567">2567</a></td><td>Specification of logical operator traits uses BaseCharacteristic, which is defined only for UnaryTypeTraits and BinaryTypeTraits</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2568">2568</a></td><td>[fund.ts.v2] Specification of logical operator traits uses BaseCharacteristic, which is defined only for UnaryTypeTraits and BinaryTypeTraits</td><td>Issaquah</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2569">2569</a></td><td>conjunction and disjunction requirements are too strict</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2570">2570</a></td><td>[fund.ts.v2] conjunction and disjunction requirements are too strict</td><td>Issaquah</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2578">2578</a></td><td>Iterator requirements should reference iterator traits</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2584">2584</a></td><td><regex> ECMAScript IdentityEscape is ambiguous</td><td>Issaquah</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2587">2587</a></td><td>"Convertible to bool" requirement in conjunction and disjunction</td><td>Issaquah</td><td>Resolved by 2567</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2588">2588</a></td><td>[fund.ts.v2] "Convertible to bool" requirement in conjunction and disjunction</td><td>Issaquah</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2589">2589</a></td><td>match_results can't satisfy the requirements of a container</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2591">2591</a></td><td>std::function's member template target() should not lead to undefined behaviour</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2598">2598</a></td><td>addressof works on temporaries</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2664">2664</a></td><td>operator/ (and other append) semantics not useful if argument has root</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2665">2665</a></td><td>remove_filename() post condition is incorrect</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2672">2672</a></td><td>Should is_empty use error_code in its specification?</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2678">2678</a></td><td>std::filesystem enum classes overspecified</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2679">2679</a></td><td>Inconsistent Use of Effects and Equivalent To</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2680">2680</a></td><td>Add "Equivalent to" to filesystem</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2681">2681</a></td><td>filesystem::copy() cannot copy symlinks</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2682">2682</a></td><td>filesystem::copy() won't create a symlink to a directory</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2686">2686</a></td><td>Why is std::hash specialized for error_code, but not error_condition?</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2694">2694</a></td><td>Application of LWG 436 accidentally deleted definition of "facet"</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2696">2696</a></td><td>Interaction between make_shared and enable_shared_from_this is underspecified</td><td>Issaquah</td><td>Nothing to do</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2699">2699</a></td><td>Missing restriction in [numeric.requirements]</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2712">2712</a></td><td>copy_file(from, to, ...) has a number of unspecified error conditions</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2722">2722</a></td><td>equivalent incorrectly specifies throws clause</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2729">2729</a></td><td>Missing SFINAE on std::pair::operator=</td><td>Issaquah</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2732">2732</a></td><td>Questionable specification of path::operator/= and path::append</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2733">2733</a></td><td>[fund.ts.v2] gcd / lcm and bool</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2735">2735</a></td><td>std::abs(short), std::abs(signed char) and others should return int instead of double in order to be compatible with C++98 and C</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2736">2736</a></td><td>nullopt_t insufficiently constrained</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2738">2738</a></td><td>is_constructible with void types</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2739">2739</a></td><td>Issue with time_point non-member subtraction with an unsigned duration</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2740">2740</a></td><td>constexpr optional<T>::operator-></td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2742">2742</a></td><td>Inconsistent string interface taking string_view</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2744">2744</a></td><td>any's in_place constructors</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2745">2745</a></td><td>[fund.ts.v2] Implementability of LWG 2451</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2747">2747</a></td><td>Possibly redundant std::move in [alg.foreach]</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2748">2748</a></td><td>swappable traits for optionals</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2749">2749</a></td><td>swappable traits for variants</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2750">2750</a></td><td>[fund.ts.v2] LWG 2451 conversion constructor constraint</td><td>Issaquah</td><td>Nothing to do</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2752">2752</a></td><td>"Throws:" clauses of async and packaged_task are unimplementable</td><td>Issaquah</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2755">2755</a></td><td>[string.view.io] uses non-existent basic_string_view::to_string function</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2756">2756</a></td><td>C++ WP optional<T> should 'forward' T's implicit conversions</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2758">2758</a></td><td>std::string{}.assign("ABCDE", 0, 1) is ambiguous</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2759">2759</a></td><td>gcd / lcm and bool for the WP</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2760">2760</a></td><td>non-const basic_string::data should not invalidate iterators</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2765">2765</a></td><td>Did LWG 1123 go too far?</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2767">2767</a></td><td>not_fn call_wrapper can form invalid types</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2769">2769</a></td><td>Redundant const in the return type of any_cast(const any&)</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2771">2771</a></td><td>Broken Effects of some basic_string::compare functions in terms of basic_string_view</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2773">2773</a></td><td>Making std::ignore constexpr</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2777">2777</a></td><td>basic_string_view::copy should use char_traits::copy</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2778">2778</a></td><td>basic_string_view is missing constexpr</td><td>Issaquah</td><td>Complete</td></tr>
-   <tr><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2260">2260</a></td><td>Missing requirement for Allocator::pointer</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2676">2676</a></td><td>Provide filesystem::path overloads for File-based streams</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2768">2768</a></td><td>any_cast and move semantics</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2769">2769</a></td><td>Redundant const in the return type of any_cast(const any&amp;)</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2781">2781</a></td><td>Contradictory requirements for std::function and std::reference_wrapper</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2782">2782</a></td><td>scoped_allocator_adaptor constructors must be constrained</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2784">2784</a></td><td>Resolution to LWG 2484 is missing "otherwise, no effects" and is hard to parse</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2785">2785</a></td><td>quoted should work with basic_string_view</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2786">2786</a></td><td>Annex C should mention shared_ptr changes for array support</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2787">2787</a></td><td>&sect;[file_status.cons] doesn't match class definition</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2788">2788</a></td><td>basic_string range mutators unintentionally require a default constructible allocator</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2789">2789</a></td><td>Equivalence of contained objects</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2790">2790</a></td><td>Missing specification of istreambuf_iterator::operator-&gt;</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2794">2794</a></td><td>Missing requirements for allocator pointers</td><td>Kona</td><td><I>Nothing to do</I></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2795">2795</a></td><td>&sect;[global.functions] provides incorrect example of ADL use</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2796">2796</a></td><td>tuple should be a literal type</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2801">2801</a></td><td>Default-constructibility of unique_ptr</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2802">2802</a></td><td>shared_ptr constructor requirements for a deleter</td><td>Kona</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2804">2804</a></td><td>Unconditional constexpr default constructor for istream_iterator</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2806">2806</a></td><td>Base class of bad_optional_access</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2807">2807</a></td><td>std::invoke should use std::is_nothrow_callable</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2812">2812</a></td><td>Range access is available with &lt;string_view&gt;</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2824">2824</a></td><td>list::sort should say that the order of elements is unspecified if an exception is thrown</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2826">2826</a></td><td>string_view iterators use old wording</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2834">2834</a></td><td>Resolution LWG 2223 is missing wording about end iterators</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2835">2835</a></td><td>LWG 2536 seems to misspecify &lt;tgmath.h&gt;</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2837">2837</a></td><td>gcd and lcm should support a wider range of input values</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2838">2838</a></td><td>is_literal_type specification needs a little cleanup</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2842">2842</a></td><td>in_place_t check for optional::optional(U&amp;&amp;) should decay U</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2850">2850</a></td><td>std::function move constructor does unnecessary work</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2853">2853</a></td><td>Possible inconsistency in specification of erase in [vector.modifiers]</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2855">2855</a></td><td>std::throw_with_nested("string_literal")</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2857">2857</a></td><td>{variant,optional,any}::emplace should return the constructed value</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2861">2861</a></td><td>basic_string should require that charT match traits::char_type</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2866">2866</a></td><td>Incorrect derived classes constraints</td><td>Kona</td><td><I>Nothing to do</I></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2868">2868</a></td><td>Missing specification of bad_any_cast::what()</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2872">2872</a></td><td>Add definition for direct-non-list-initialization</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2873">2873</a></td><td>Add noexcept to several shared_ptr related functions</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2874">2874</a></td><td>Constructor shared_ptr::shared_ptr(Y*) should be constrained</td><td>Kona</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2875">2875</a></td><td>shared_ptr::shared_ptr(Y*, D, [&hellip;]) constructors should be constrained</td><td>Kona</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2876">2876</a></td><td>shared_ptr::shared_ptr(const weak_ptr&lt;Y&gt;&amp;) constructor should be constrained</td><td>Kona</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2878">2878</a></td><td>Missing DefaultConstructible requirement for istream_iterator default constructor</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2890">2890</a></td><td>The definition of 'object state' applies only to class types</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2900">2900</a></td><td>The copy and move constructors of optional are not constexpr</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2903">2903</a></td><td>The form of initialization for the emplace-constructors is not specified</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2904">2904</a></td><td>Make variant move-assignment more exception safe</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2905">2905</a></td><td>is_constructible_v&lt;unique_ptr&lt;P, D&gt;, P, D const &amp;&gt; should be false when D is not copy constructible</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2908">2908</a></td><td>The less-than operator for shared pointers could do more</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2911">2911</a></td><td>An is_aggregate type trait is needed</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2921">2921</a></td><td>packaged_task and type-erased allocators</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2934">2934</a></td><td>optional&lt;const T&gt; doesn't compare with T</td><td>Kona</td><td>Complete</td></tr>
-   <tr><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2901">2901</a></td><td>Variants cannot properly support allocators</td><td>Toronto</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2955">2955</a></td><td><tt>to_chars / from_chars</tt> depend on <tt>std::string</tt></td><td>Toronto</td><td>Resolved by <a href="https://wg21.link/P0682R1">P0682R1</a></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2956">2956</a></td><td><tt>filesystem::canonical()</tt> still defined in terms of <tt>absolute(p, base)</tt></td><td>Toronto</td><td>Complete</td></tr>
-
-<!--
-  <tr><td><a href="https://wg21.link/LWG1214">1214</a></td><td>Insufficient/inconsistent key immutability requirements for associative containers</td><td>Urbana</td><td></td></tr>
--->
-<!--   <tr><td></td><td></td><td></td><td></td></tr> -->
-  </table>
-
-  <p>Last Updated: 17-Nov-2020</p>
-</div>
+    If you are not redirected automatically, follow this <a href='docs/Cxx1zStatus.html'>link to new documentation</a>.
 </body>
 </html>

libcxx/www/cxx2a_status.html

-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
-          "http://www.w3.org/TR/html4/strict.dtd">
-<!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ -->
-<html>
+<!DOCTYPE HTML>
+<html lang="en-US">
 <head>
-  <meta http-equiv="content-type" content="text/html; charset=utf-8">
-  <title>libc++ C++2a Status</title>
-  <link type="text/css" rel="stylesheet" href="menu.css">
-  <link type="text/css" rel="stylesheet" href="content.css">
+    <meta charset="UTF-8">
+    <meta http-equiv="refresh" content="0; url=docs/Cxx2aStatus.html">
+    <script type="text/javascript">
+        window.location.href = "docs/Cxx2aStatus.html"
+    </script>
+    <title>libc++ C++20 Status</title>
 </head>
-
 <body>
-<div id="menu">
-  <div>
-    <a href="https://llvm.org/">LLVM Home</a>
-  </div>
-
-  <div class="submenu">
-    <label>libc++ Info</label>
-    <a href="/index.html">About</a>
-  </div>
-
-  <div class="submenu">
-    <label>Quick Links</label>
-    <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
-    <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
-    <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
-  </div>
-</div>
-
-<div id="content">
-  <!--*********************************************************************-->
-  <h1>libc++ C++2a Status</h1>
-  <!--*********************************************************************-->
-
-  <p>In July 2017, the C++ standard committee created a draft for the next version of the C++ standard, known here as "C++2a" (probably to be C++20).</p>
-  <p>This page shows the status of libc++; the status of clang's support of the language features is <a href="https://clang.llvm.org/cxx_status.html#cxx2a">here</a>.</p>
-
-  <p>Reminder: Features in unreleased drafts of the standard are subject to change.</p>
-
-  <p>The groups that have contributed papers:
-  <ul>
-    <li>LWG - Library working group</li>
-    <li>CWG - Core Language Working group</li>
-    <li>SG1 - Study group #1 (Concurrency working group)</li>
-  </ul>
-  </p>
-
-  <h3>Paper Status</h3>
-  <table id="papers" border="1">
-  <tr><th>Paper #</th><th>Group</th><th>Paper Name</th><th>Meeting</th><th>Status</th><th>First released version</th></tr>
-<!--
-  <tr><td><a href="https://wg21.link/n3346">3346</a></td><td>LWG</td><td>Terminology for Container Element Requirements - Rev 1</td><td>Kona</td><td>Complete</td><td>3.4</td></tr>
--->
-  <tr><td><a href="https://wg21.link/P0463R1">P0463R1</a></td><td>LWG</td><td>Endian just Endian</td><td>Toronto</td><td>Complete</td><td>7.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0674R1">P0674R1</a></td><td>LWG</td><td>Extending make_shared to Support Arrays</td><td>Toronto</td><td></td><td></td></tr>
-
-    <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0020R6">P0020R6</a></td><td>LWG</td><td>Floating Point Atomic</td><td>Albuquerque</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0053R7">P0053R7</a></td><td>LWG</td><td>C++ Synchronized Buffered Ostream</td><td>Albuquerque</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0202R3">P0202R3</a></td><td>LWG</td><td>Add constexpr modifiers to functions in &lt;algorithm&gt; and &lt;utility&gt; Headers</td><td>Albuquerque</td><td><I>In Progress</I></td><td>7.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0415R1">P0415R1</a></td><td>LWG</td><td>Constexpr for <tt>std::complex</tt></td><td>Albuquerque</td><td><I>In Progress</I></td><td>7.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0439R0">P0439R0</a></td><td>LWG</td><td>Make <tt>std::memory_order</tt> a scoped enumeration</td><td>Albuquerque</td><td>Complete</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0457R2">P0457R2</a></td><td>LWG</td><td>String Prefix and Suffix Checking</td><td>Albuquerque</td><td>Complete</td><td>6.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0550R2">P0550R2</a></td><td>LWG</td><td>Transformation Trait <tt>remove_cvref</tt></td><td>Albuquerque</td><td>Complete</td><td>6.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0600R1">P0600R1</a></td><td>LWG</td><td>nodiscard in the Library</td><td>Albuquerque</td><td><I>In Progress</I></td><td>7.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0616R0">P0616R0</a></td><td>LWG</td><td>de-pessimize legacy <numeric> algorithms with std::move</td><td>Albuquerque</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0653R2">P0653R2</a></td><td>LWG</td><td>Utility to convert a pointer to a raw pointer</td><td>Albuquerque</td><td>Complete</td><td>6.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0718R2">P0718R2</a></td><td>LWG</td><td>Atomic shared_ptr</td><td>Albuquerque</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0767R1">P0767R1</a></td><td>CWG</td><td>Deprecate POD</td><td>Albuquerque</td><td>Complete</td><td>7.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0768R1">P0768R1</a></td><td>CWG</td><td>Library Support for the Spaceship (Comparison) Operator</td><td>Albuquerque</td><td>Complete</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0777R1">P0777R1</a></td><td>LWG</td><td>Treating Unnecessary <tt>decay</tt></td><td>Albuquerque</td><td>Complete</td><td>7.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0122R7">P0122R7</a></td><td>LWG</td><td>&lt;span&gt;</td><td>Jacksonville</td><td>Complete</td><td>7.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0355R7">P0355R7</a></td><td>LWG</td><td>Extending chrono to Calendars and Time Zones</td><td>Jacksonville</td><td><i>In Progress</i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0551R3">P0551R3</a></td><td>LWG</td><td>Thou Shalt Not Specialize <tt>std</tt> Function Templates!</td><td>Jacksonville</td><td>Complete</td><td>11.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0753R2">P0753R2</a></td><td>LWG</td><td>Manipulators for C++ Synchronized Buffered Ostream</td><td>Jacksonville</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0754R2">P0754R2</a></td><td>LWG</td><td>&lt;version&gt;</td><td>Jacksonville</td><td>Complete</td><td>7.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0809R0">P0809R0</a></td><td>LWG</td><td>Comparing Unordered Containers</td><td>Jacksonville</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0858R0">P0858R0</a></td><td>LWG</td><td>Constexpr iterator requirements</td><td>Jacksonville</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0905R1">P0905R1</a></td><td>CWG</td><td>Symmetry for spaceship</td><td>Jacksonville</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0966R1">P0966R1</a></td><td>LWG</td><td><tt>string::reserve</tt> Should Not Shrink</td><td>Jacksonville</td><td>Complete</td><td>8.0</td></tr>
-
-    <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0019R8">P0019R8</a></td><td>LWG</td><td>Atomic Ref</td><td>Rapperswil</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0458R2">P0458R2</a></td><td>LWG</td><td>Checking for Existence of an Element in Associative Containers</td><td>Rapperswil</td><td>Complete</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0475R1">P0475R1</a></td><td>LWG</td><td>LWG 2511: guaranteed copy elision for piecewise construction</td><td>Rapperswil</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0476R2">P0476R2</a></td><td>LWG</td><td>Bit-casting object representations</td><td>Rapperswil</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0528R3">P0528R3</a></td><td>CWG</td><td>The Curious Case of Padding Bits, Featuring Atomic Compare-and-Exchange</td><td>Rapperswil</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0542R5">P0542R5</a></td><td>CWG</td><td>Support for contract based programming in C++</td><td>Rapperswil</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0556R3">P0556R3</a></td><td>LWG</td><td>Integral power-of-2 operations</td><td>Rapperswil</td><td>Complete</td><td>9.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0619R4">P0619R4</a></td><td>LWG</td><td>Reviewing Deprecated Facilities of C++17 for C++20</td><td>Rapperswil</td><td>Partial<br>(only std::allocator part is implemented)</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0646R1">P0646R1</a></td><td>LWG</td><td>Improving the Return Value of Erase-Like Algorithms</td><td>Rapperswil</td><td>Complete</td><td>10.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0722R3">P0722R3</a></td><td>CWG</td><td>Efficient sized delete for variable sized classes</td><td>Rapperswil</td><td>Complete</td><td>9.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0758R1">P0758R1</a></td><td>LWG</td><td>Implicit conversion traits and utility functions</td><td>Rapperswil</td><td>Complete</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0759R1">P0759R1</a></td><td>LWG</td><td>fpos Requirements</td><td>Rapperswil</td><td>Complete</td><td>11.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0769R2">P0769R2</a></td><td>LWG</td><td>Add shift to &lt;algorithm&gt;</td><td>Rapperswil</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0788R3">P0788R3</a></td><td>LWG</td><td>Standard Library Specification in a Concepts and Contracts World</td><td>Rapperswil</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0879R0">P0879R0</a></td><td>LWG</td><td>Constexpr for swap and swap related functions Also resolves LWG issue 2800.</td><td>Rapperswil</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0887R1">P0887R1</a></td><td>LWG</td><td>The identity metafunction</td><td>Rapperswil</td><td>Complete</td><td>8.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0892R2">P0892R2</a></td><td>CWG</td><td>explicit(bool)</td><td>Rapperswil</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0898R3">P0898R3</a></td><td>LWG</td><td>Standard Library Concepts</td><td>Rapperswil</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0935R0">P0935R0</a></td><td>LWG</td><td>Eradicating unnecessarily explicit default constructors from the standard library</td><td>Rapperswil</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0941R2">P0941R2</a></td><td>CWG</td><td>Integrating feature-test macros into the C++ WD</td><td>Rapperswil</td><td><i>In Progress</i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1023R0">P1023R0</a></td><td>LWG</td><td>constexpr comparison operators for std::array</td><td>Rapperswil</td><td>Complete</td><td>8.0</td></tr>
-  <tr><td><a href="https://wg21.link/P1025R1">P1025R1</a></td><td>CWG</td><td>Update The Reference To The Unicode Standard</td><td>Rapperswil</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1120R0">P1120R0</a></td><td>CWG</td><td>Consistency improvements for &lt;=&gt; and other comparison operators</td><td>Rapperswil</td><td></td><td></td></tr>
-
-   <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0318R1">P0318R1</a></td><td>LWG</td><td>unwrap_ref_decay and unwrap_reference</td><td>San Diego</td><td>Complete</td><td>8.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0356R5">P0356R5</a></td><td>LWG</td><td>Simplified partial function application</td><td>San Diego</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0357R3">P0357R3</a></td><td>LWG</td><td>reference_wrapper for incomplete types</td><td>San Diego</td><td>Complete</td><td>8.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0482R6">P0482R6</a></td><td>CWG</td><td>char8_t: A type for UTF-8 characters and strings</td><td>San Diego</td><td><i>In Progress</i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0487R1">P0487R1</a></td><td>LWG</td><td>Fixing operator&gt;&gt;(basic_istream&amp;, CharT*) (LWG 2499)</td><td>San Diego</td><td>Complete</td><td>8.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0591R4">P0591R4</a></td><td>LWG</td><td>Utility functions to implement uses-allocator construction</td><td>San Diego</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0595R2">P0595R2</a></td><td>CWG</td><td>P0595R2 std::is_constant_evaluated()</td><td>San Diego</td><td>Complete</td><td>9.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0602R4">P0602R4</a></td><td>LWG</td><td>variant and optional should propagate copy/move triviality</td><td>San Diego</td><td>Complete</td><td>8.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0608R3">P0608R3</a></td><td>LWG</td><td>A sane variant converting constructor</td><td>San Diego</td><td>Complete</td><td>9.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0655R1">P0655R1</a></td><td>LWG</td><td>visit&lt;R&gt;: Explicit Return Type for visit</td><td>San Diego</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0771R1">P0771R1</a></td><td>LWG</td><td>std::function move constructor should be noexcept</td><td>San Diego</td><td>Complete</td><td>6.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0896R4">P0896R4</a></td><td>LWG</td><td>The One Ranges Proposal</td><td>San Diego</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0899R1">P0899R1</a></td><td>LWG</td><td>P0899R1 - LWG 3016 is not a defect</td><td>San Diego</td><td><i>Nothing to do</i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0919R3">P0919R3</a></td><td>LWG</td><td>Heterogeneous lookup for unordered containers</td><td>San Diego</td><td>Complete</td><td>12.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0972R0">P0972R0</a></td><td>LWG</td><td>&lt;chrono&gt; <tt>zero()</tt>, <tt>min()</tt>, and <tt>max()</tt> should be noexcept</td><td>San Diego</td><td>Complete</td><td>8.0</td></tr>
-  <tr><td><a href="https://wg21.link/P1006R1">P1006R1</a></td><td>LWG</td><td>Constexpr in std::pointer_traits</td><td>San Diego</td><td>Complete</td><td>8.0</td></tr>
-  <tr><td><a href="https://wg21.link/P1007R3">P1007R3</a></td><td>LWG</td><td><tt>std::assume_aligned</tt></td><td>San Diego</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1020R1">P1020R1</a></td><td>LWG</td><td>Smart pointer creation with default initialization</td><td>San Diego</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1032R1">P1032R1</a></td><td>LWG</td><td>Misc constexpr bits</td><td>San Diego</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1085R2">P1085R2</a></td><td>LWG</td><td>Should Span be Regular?</td><td>San Diego</td><td>Complete</td><td>8.0</td></tr>
-  <tr><td><a href="https://wg21.link/P1123R0">P1123R0</a></td><td>LWG</td><td>Editorial Guidance for merging P0019r8 and P0528r3</td><td>San Diego</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1148R0">P1148R0</a></td><td>LWG</td><td>Cleaning up Clause 20</td><td>San Diego</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1165R1">P1165R1</a></td><td>LWG</td><td>Make stateful allocator propagation more consistent for <tt>operator+(basic_string)</tt></td><td>San Diego</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1209R0">P1209R0</a></td><td>LWG</td><td>Adopt Consistent Container Erasure from Library Fundamentals 2 for C++20</td><td>San Diego</td><td>Complete</td><td>8.0</td></tr>
-  <tr><td><a href="https://wg21.link/P1210R0">P1210R0</a></td><td>LWG</td><td>Completing the Rebase of Library Fundamentals, Version 3, Working Draft</td><td>San Diego</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1236R1">P1236R1</a></td><td>CWG</td><td>Alternative Wording for P0907R4 Signed Integers are Two's Complement</td><td>San Diego</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1248R1">P1248R1</a></td><td>LWG</td><td>Remove CommonReference requirement from StrictWeakOrdering (a.k.a Fixing Relations)</td><td>San Diego</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1285R0">P1285R0</a></td><td>LWG</td><td>Improving Completeness Requirements for Type Traits</td><td>San Diego</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1353R0">P1353R0</a></td><td>CWG</td><td>Missing feature test macros</td><td>San Diego</td><td><i> </i></td><td></td></tr>
-
-   <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0339R6">P0339R6</a></td><td>LWG</td><td>polymorphic_allocator<> as a vocabulary type</td><td>Kona</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0340R3">P0340R3</a></td><td>LWG</td><td>Making std::underlying_type SFINAE-friendly</td><td>Kona</td><td>Complete</td><td>9.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0738R2">P0738R2</a></td><td>LWG</td><td>I Stream, You Stream, We All Stream for istream_iterator</td><td>Kona</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0811R3">P0811R3</a></td><td>LWG</td><td>Well-behaved interpolation for numbers and pointers</td><td>Kona</td><td>Complete</td><td>9.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0920R2">P0920R2</a></td><td>LWG</td><td>Precalculated hash values in lookup</td><td>Kona</td><td>Reverted by <a href="https://wg21.link/P1661">P1661</a></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1001R2">P1001R2</a></td><td>LWG</td><td>Target Vectorization Policies from Parallelism V2 TS to C++20</td><td>Kona</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1024R3">P1024R3</a></td><td>LWG</td><td>Usability Enhancements for std::span</td><td>Kona</td><td>Complete</td><td>9.0</td></tr>
-  <tr><td><a href="https://wg21.link/P1164R1">P1164R1</a></td><td>LWG</td><td>Make create_directory() Intuitive</td><td>Kona</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1227R2">P1227R2</a></td><td>LWG</td><td>Signed ssize() functions, unsigned size() functions </td><td>Kona</td><td>Complete</td><td>9.0</td></tr>
-  <tr><td><a href="https://wg21.link/P1252R2">P1252R2</a></td><td>LWG</td><td>Ranges Design Cleanup</td><td>Kona</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1286R2">P1286R2</a></td><td>CWG</td><td>Contra CWG DR1778</td><td>Kona</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1357R1">P1357R1</a></td><td>LWG</td><td>Traits for [Un]bounded Arrays</td><td>Kona</td><td>Complete</td><td>9.0</td></tr>
-  <tr><td><a href="https://wg21.link/P1458R1">P1458R1</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 16 - Language support library</td><td>Kona</td><td>Complete</td><td>9.0</td></tr>
-  <tr><td><a href="https://wg21.link/P1459R1">P1459R1</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 18 - Diagnostics library</td><td>Kona</td><td>Complete</td><td>9.0</td></tr>
-  <tr><td><a href="https://wg21.link/P1462R1">P1462R1</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 20 - Strings library</td><td>Kona</td><td>Complete</td><td>9.0</td></tr>
-  <tr><td><a href="https://wg21.link/P1463R1">P1463R1</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 21 - Containers library</td><td>Kona</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1464R1">P1464R1</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 22 - Iterators library</td><td>Kona</td><td>Complete</td><td>9.0</td></tr>
-
-   <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0325">P0325</a></td><td>LWG</td><td>to_array from LFTS with updates</td><td>Cologne</td><td>Complete</td><td>10.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0408">P0408</a></td><td>LWG</td><td>Efficient Access to basic_stringbuf's Buffer</td><td>Cologne</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0466">P0466</a></td><td>LWG</td><td>Layout-compatibility and Pointer-interconvertibility Traits</td><td>Cologne</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0553">P0553</a></td><td>LWG</td><td>Bit operations</td><td>Cologne</td><td>Complete</td><td>9.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0631">P0631</a></td><td>LWG</td><td>Math Constants</td><td>Cologne</td><td>Complete</td><td>11.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0645">P0645</a></td><td>LWG</td><td>Text Formatting</td><td>Cologne</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0660">P0660</a></td><td>LWG</td><td>Stop Token and Joining Thread, Rev 10</td><td>Cologne</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0784">P0784</a></td><td>CWG</td><td>More constexpr containers</td><td>Cologne</td><td>Complete</td><td>12.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0980">P0980</a></td><td>LWG</td><td>Making std::string constexpr</td><td>Cologne</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1004">P1004</a></td><td>LWG</td><td>Making std::vector constexpr</td><td>Cologne</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1035">P1035</a></td><td>LWG</td><td>Input Range Adaptors</td><td>Cologne</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1065">P1065</a></td><td>LWG</td><td>Constexpr INVOKE</td><td>Cologne</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1135">P1135</a></td><td>LWG</td><td>The C++20 Synchronization Library</td><td>Cologne</td><td>Complete</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1207">P1207</a></td><td>LWG</td><td>Movability of Single-pass Iterators</td><td>Cologne</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1208">P1208</a></td><td>LWG</td><td>Adopt source_location for C++20</td><td>Cologne</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1355">P1355</a></td><td>LWG</td><td>Exposing a narrow contract for ceil2</td><td>Cologne</td><td>Complete</td><td>9.0</td></tr>
-  <tr><td><a href="https://wg21.link/P1361">P1361</a></td><td>LWG</td><td>Integration of chrono with text formatting</td><td>Cologne</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1423">P1423</a></td><td>LWG</td><td>char8_t backward compatibility remediation</td><td>Cologne</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1424">P1424</a></td><td>LWG</td><td>'constexpr' feature macro concerns</td><td>Cologne</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1466">P1466</a></td><td>LWG</td><td>Miscellaneous minor fixes for chrono</td><td>Cologne</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1474">P1474</a></td><td>LWG</td><td>Helpful pointers for ContiguousIterator</td><td>Cologne</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1502">P1502</a></td><td>LWG</td><td>Standard library header units for C++20</td><td>Cologne</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1522">P1522</a></td><td>LWG</td><td>Iterator Difference Type and Integer Overflow</td><td>Cologne</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1523">P1523</a></td><td>LWG</td><td>Views and Size Types</td><td>Cologne</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1612">P1612</a></td><td>LWG</td><td>Relocate Endian's Specification</td><td>Cologne</td><td>Complete</td><td>10.0</td></tr>
-  <tr><td><a href="https://wg21.link/P1614">P1614</a></td><td>LWG</td><td>The Mothership has Landed</td><td>Cologne</td><td><i>In Progress</i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1638">P1638</a></td><td>LWG</td><td>basic_istream_view::iterator should not be copyable</td><td>Cologne</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1643">P1643</a></td><td>LWG</td><td>Add wait/notify to atomic_ref</td><td>Cologne</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1644">P1644</a></td><td>LWG</td><td>Add wait/notify to atomic<shared_ptr></td><td>Cologne</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1650">P1650</a></td><td>LWG</td><td>Output std::chrono::days with 'd' suffix</td><td>Cologne</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1651">P1651</a></td><td>LWG</td><td>bind_front should not unwrap reference_wrapper</td><td>Cologne</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1652">P1652</a></td><td>LWG</td><td>Printf corner cases in std::format</td><td>Cologne</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1661">P1661</a></td><td>LWG</td><td>Remove dedicated precalculated hash lookup interface</td><td>Cologne</td><td><i>Nothing to do</i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1754">P1754</a></td><td>LWG</td><td>Rename concepts to standard_case for C++20, while we still can</td><td>Cologne</td><td></td><td></td></tr>
-
-   <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0883">P0883</a></td><td>LWG</td><td>Fixing Atomic Initialization </td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1391">P1391</a></td><td>LWG</td><td>Range constructor for std::string_view </td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1394">P1394</a></td><td>LWG</td><td>Range constructor for std::span </td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1456">P1456</a></td><td>LWG</td><td>Move-only views </td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1622">P1622</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 32 - Thread support library </td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1645">P1645</a></td><td>LWG</td><td>constexpr for numeric algorithms </td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1664">P1664</a></td><td>LWG</td><td>reconstructible_range - a concept for putting ranges back together </td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1686">P1686</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 27 - Time library </td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1690">P1690</a></td><td>LWG</td><td>Refinement Proposal for P0919 Heterogeneous lookup for unordered containers </td><td>Belfast</td><td>Complete</td><td>12.0</td></tr>
-  <tr><td><a href="https://wg21.link/P1716">P1716</a></td><td>LWG</td><td>ranges compare algorithm are over-constrained </td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1718">P1718</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 25 - Algorithms library </td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1719">P1719</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 26 - Numerics library </td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1720">P1720</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 28 - Localization library </td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1721">P1721</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 29 - Input/Output library </td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1722">P1722</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 30 - Regular Expression library </td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1723">P1723</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 31 - Atomics library </td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1855">P1855</a></td><td>LWG</td><td>Make <tt>&lt;compare&gt;</tt> freestanding</td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1862">P1862</a></td><td>LWG</td><td>Ranges adaptors for non-copyable iterators </td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1865">P1865</a></td><td>LWG</td><td>Add max() to latch and barrier </td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1869">P1869</a></td><td>LWG</td><td>Rename 'condition_variable_any' interruptible wait methods </td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1870">P1870</a></td><td>LWG</td><td>forwarding-range is too subtle </td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1871">P1871</a></td><td>LWG</td><td>Should concepts be enabled or disabled? </td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1872">P1872</a></td><td>LWG</td><td>span should have size_type, not index_type </td><td>Belfast</td><td>Complete</td><td>10.0</td></tr>
-  <tr><td><a href="https://wg21.link/P1878">P1878</a></td><td>LWG</td><td>Constraining Readable Types </td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1892">P1892</a></td><td>LWG</td><td>Extended locale-specific presentation specifiers for std::format </td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1902">P1902</a></td><td>LWG</td><td>Missing feature-test macros 2018-2019 </td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1959">P1959</a></td><td>LWG</td><td>Remove std::weak_equality and std::strong_equality</td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1960">P1960</a></td><td>LWG</td><td>NB Comment Changes Reviewed by SG1</td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1961">P1961</a></td><td>LWG</td><td>Harmonizing the definitions of total order for pointers</td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1965">P1965</a></td><td>LWG</td><td>Blanket Wording for Specifying "Hidden Friends"</td><td>Belfast</td><td><i> </i></td><td></td></tr>
-
-    <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0586">P0586</a></td><td>LWG</td><td>Safe integral comparisons</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0593">P0593</a></td><td>CWG</td><td>Implicit creation of objects for low-level object manipulation</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1115">P1115</a></td><td>LWG</td><td>Improving the Return Value of Erase-Like Algorithms II: Free erase/erase if</td><td>Prague</td><td>Complete</td><td>11.0</td></tr>
-  <tr><td><a href="https://wg21.link/P1243">P1243</a></td><td>LWG</td><td>Rangify New Algorithms</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1460">P1460</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 20 - Utilities library</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1739">P1739</a></td><td>LWG</td><td>Avoid template bloat for safe_ranges in combination with "subrange-y" view adaptors</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1831">P1831</a></td><td>LWG</td><td>Deprecating volatile: library</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1868">P1868</a></td><td>LWG</td><td>width: clarifying units of width and precision in std::format</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1908">P1908</a></td><td>CWG</td><td>Reserving Attribute Namespaces for Future Use</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1937">P1937</a></td><td>CWG</td><td>Fixing inconsistencies between constexpr and consteval functions</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1956">P1956</a></td><td>LWG</td><td>On the names of low-level bit manipulation functions</td><td>Prague</td><td>Complete</td><td>12.0</td></tr>
-  <tr><td><a href="https://wg21.link/P1957">P1957</a></td><td>CWG</td><td>Converting from T* to bool should be considered narrowing (re: US 212)</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1963">P1963</a></td><td>LWG</td><td>Fixing US 313</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1964">P1964</a></td><td>LWG</td><td>Wording for boolean-testable</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1970">P1970</a></td><td>LWG</td><td>Consistency for size() functions: Add ranges::ssize</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1973">P1973</a></td><td>LWG</td><td>Rename "_default_init" Functions, Rev1</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1976">P1976</a></td><td>LWG</td><td>Fixed-size span construction from dynamic range</td><td>Prague</td><td>Complete</td><td>11.0</td></tr>
-  <tr><td><a href="https://wg21.link/P1981">P1981</a></td><td>LWG</td><td>Rename leap to leap_second</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1982">P1982</a></td><td>LWG</td><td>Rename link to time_zone_link</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1983">P1983</a></td><td>LWG</td><td>Wording for GB301, US296, US292, US291, and US283</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1994">P1994</a></td><td>LWG</td><td>elements_view needs its own sentinel</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P2002">P2002</a></td><td>CWG</td><td>Defaulted comparison specification cleanups</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P2045">P2045</a></td><td>LWG</td><td>Missing Mandates for the standard library</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P2085">P2085</a></td><td>CWG</td><td>Consistent defaulted comparisons</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P2091">P2091</a></td><td>LWG</td><td>Issues with range access CPOs</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P2101">P2101</a></td><td>LWG</td><td>'Models' subsumes 'satisfies' (Wording for US298 and US300)</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P2102">P2102</a></td><td>LWG</td><td>Make 'implicit expression variations' more explicit (Wording for US185)</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P2106">P2106</a></td><td>LWG</td><td>Alternative wording for GB315 and GB316</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P2116">P2116</a></td><td>LWG</td><td>Remove tuple-like protocol support from fixed-extent span</td><td>Prague</td><td>Complete</td><td>11.0</td></tr>
-<!--   <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr> -->
-  </table>
-
-<p><i>[ Note: "Nothing to do" means that no library changes were needed to implement this change -- end note]</i></p>
-
-<p>The missing bits in P0600 are in [mem.res.class], [mem.poly.allocator.class], and [container.node.overview]</p>
-
-<p>The missing bits in P0202 are in <tt>copy</tt> and <tt>copy_backwards</tt> (and the ones that call them: <tt>copy_n</tt>, <tt>set_union</tt>, <tt>set_difference</tt>, and <tt>set_symmetric_difference</tt>). This is because the first two algorithms have specializations that call <tt>memmove</tt> which is not constexpr. See <a href="https://bugs.llvm.org/show_bug.cgi?id=25165">Bug 25165</a></p>
-
-
-  <h3>Library Working group Issues Status</h3>
-<!--   <I>Note: "NAD" means that the issue was deemed "Not a defect"</I> -->
-  <table id="issues" border="1">
-  <tr><th>Issue #</th><th>Issue Name</th><th>Meeting</th><th>Status</th></tr>
-<!--
-  <tr><td><a href="https://wg21.link/LWG1214">1214</a></td><td>Insufficient/inconsistent key immutability requirements for associative containers</td><td>Urbana</td><td></td></tr>
--->
-  <tr><td><a href="https://wg21.link/LWG2070">2070</a></td><td><tt>allocate_shared</tt> should use <tt>allocator_traits&lt;A&gt;::construct</tt></td><td>Toronto</td><td>Resolved by <a href="https://wg21.link/P0674R1">P0674R1</a></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2444">2444</a></td><td>Inconsistent complexity for <tt>std::sort_heap</tt></td><td>Toronto</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2593">2593</a></td><td>Moved-from state of Allocators</td><td>Toronto</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2597">2597</a></td><td><tt>std::log</tt> misspecified for complex numbers</td><td>Toronto</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2783">2783</a></td><td><tt>stack::emplace()</tt> and <tt>queue::emplace()</tt> should return <tt>decltype(auto)</tt></td><td>Toronto</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2932">2932</a></td><td>Constraints on parallel algorithm implementations are underspecified</td><td>Toronto</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2937">2937</a></td><td>Is <tt>equivalent("existing_thing", "not_existing_thing")</tt> an error</td><td>Toronto</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2940">2940</a></td><td><tt>result_of</tt> specification also needs a little cleanup</td><td>Toronto</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2942">2942</a></td><td>LWG 2873's resolution missed <tt>weak_ptr::owner_before</tt></td><td>Toronto</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2954">2954</a></td><td>Specialization of the convenience variable templates should be prohibited</td><td>Toronto</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2961">2961</a></td><td>Bad postcondition for <tt>set_default_resource</tt></td><td>Toronto</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2966">2966</a></td><td>Incomplete resolution of US 74</td><td>Toronto</td><td><i>Nothing to do</i></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2974">2974</a></td><td>Diagnose out of bounds <tt>tuple_element/variant_alternative</tt></td><td>Toronto</td><td>Complete</td></tr>
-
-   <tr><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2779">2779</a></td><td>[networking.ts] Relax requirements on buffer sequence iterators</td><td>Albuquerque</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2870">2870</a></td><td>Default value of parameter theta of polar should be dependent</td><td>Albuquerque</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2935">2935</a></td><td>What should create_directories do when p already exists but is not a directory?</td><td>Albuquerque</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2941">2941</a></td><td>[thread.req.timing] wording should apply to both member and namespace-level functions</td><td>Albuquerque</td><td><i>Nothing to do</i></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2944">2944</a></td><td>LWG 2905 accidentally removed requirement that construction of the deleter doesn't throw an exception</td><td>Albuquerque</td><td><i>Nothing to do</i></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2945">2945</a></td><td>Order of template parameters in optional comparisons</td><td>Albuquerque</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2948">2948</a></td><td>unique_ptr does not define operator<< for stream output</td><td>Albuquerque</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2950">2950</a></td><td>std::byte operations are misspecified</td><td>Albuquerque</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2952">2952</a></td><td>iterator_traits should work for pointers to cv T</td><td>Albuquerque</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2953">2953</a></td><td>LWG 2853 should apply to deque::erase too</td><td>Albuquerque</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2958">2958</a></td><td>Moves improperly defined as deleted</td><td>Albuquerque</td><td><I>We already do this</I></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2964">2964</a></td><td>Apparently redundant requirement for dynamic_pointer_cast</td><td>Albuquerque</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2965">2965</a></td><td>Non-existing path::native_string() in filesystem_error::what() specification</td><td>Albuquerque</td><td>Nothing to do</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2972">2972</a></td><td>What is is_trivially_destructible_v&lt;int&gt;?</td><td>Albuquerque</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2976">2976</a></td><td>Dangling uses_allocator specialization for packaged_task</td><td>Albuquerque</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2977">2977</a></td><td>unordered_meow::merge() has incorrect Throws: clause</td><td>Albuquerque</td><td><i>Nothing to do</i></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2978">2978</a></td><td>Hash support for pmr::string and friends</td><td>Albuquerque</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2979">2979</a></td><td>aligned_union should require complete object types</td><td>Albuquerque</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2980">2980</a></td><td>Cannot compare_exchange empty pointers</td><td>Albuquerque</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2981">2981</a></td><td>Remove redundant deduction guides from standard library</td><td>Albuquerque</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2982">2982</a></td><td>Making size_type consistent in associative container deduction guides</td><td>Albuquerque</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2988">2988</a></td><td>Clause 32 cleanup missed one typename</td><td>Albuquerque</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2993">2993</a></td><td>reference_wrapper<T> conversion from T&&</td><td>Albuquerque</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2998">2998</a></td><td>Requirements on function objects passed to {forward_,}list-specific algorithms</td><td>Albuquerque</td><td><i>Nothing to do</i></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3001">3001</a></td><td>weak_ptr::element_type needs remove_extent_t</td><td>Albuquerque</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3024">3024</a></td><td>variant's copies must be deleted instead of disabled via SFINAE</td><td>Albuquerque</td><td>Complete</td></tr>
-
-   <tr><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2164">2164</a></td><td>What are the semantics of <tt>vector.emplace(vector.begin(), vector.back())</tt>?</td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2243">2243</a></td><td><tt>istream::putback</tt> problem</td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2816">2816</a></td><td><tt>resize_file</tt> has impossible postcondition</td><td>Jacksonville</td><td><i>Nothing to do</i></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2843">2843</a></td><td>Unclear behavior of <tt>std::pmr::memory_resource::do_allocate()</tt></td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2849">2849</a></td><td>Why does <tt>!is_regular_file(from)</tt> cause <tt>copy_file</tt> to report a "file already exists" error?</td><td>Jacksonville</td><td><i>Nothing to do</i></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2851">2851</a></td><td><tt>std::filesystem</tt> enum classes are now underspecified</td><td>Jacksonville</td><td><i>Nothing to do</i></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2946">2946</a></td><td>LWG 2758's resolution missed further corrections</td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2969">2969</a></td><td><tt>polymorphic_allocator::construct()</tt> shouldn't pass <tt>resource()</tt></td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2975">2975</a></td><td>Missing case for <tt>pair</tt> construction in scoped and polymorphic allocators</td><td>Jacksonville</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2989">2989</a></td><td><tt>path</tt>'s stream insertion operator lets you insert everything under the sun</td><td>Jacksonville</td><td>Completed</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3000">3000</a></td><td><tt>monotonic_memory_resource::do_is_equal</tt> uses <tt>dynamic_cast</tt> unnecessarily</td><td>Jacksonville</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3002">3002</a></td><td>[networking.ts] <tt>basic_socket_acceptor::is_open()</tt> isn't <tt>noexcept</tt></td><td>Jacksonville</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3004">3004</a></td><td>&sect;[string.capacity] and &sect;[vector.capacity] should specify time complexity for <tt>capacity()</tt></td><td>Jacksonville</td><td><i>Nothing to do</i></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3005">3005</a></td><td>Destruction order of arrays by <tt>make_shared/allocate_shared</tt> only recommended?</td><td>Jacksonville</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3007">3007</a></td><td><tt>allocate_shared</tt> should rebind allocator to <i>cv</i>-unqualified <tt>value_type</tt> for construction</td><td>Jacksonville</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3009">3009</a></td><td>Including <tt>&lt;string_view&gt;</tt> doesn't provide <tt>std::size/empty/data</tt></td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3010">3010</a></td><td>[networking.ts] <tt>uses_executor</tt> says "if a type <tt>T::executor_type</tt> exists"</td><td>Jacksonville</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3013">3013</a></td><td><tt>(recursive_)directory_iterator</tt> construction and traversal should not be <tt>noexcept</tt></td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3014">3014</a></td><td>More <tt>noexcept</tt> issues with filesystem operations</td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3015">3015</a></td><td><tt>copy_options::<i>unspecified</i></tt> underspecified</td><td>Jacksonville</td><td><i>Nothing to do</i></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3017">3017</a></td><td><tt>list splice</tt> functions should use <tt>addressof</tt></td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3020">3020</a></td><td>[networking.ts] Remove spurious nested <tt>value_type</tt> buffer sequence requirement</td><td>Jacksonville</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3026">3026</a></td><td><tt>filesystem::weakly_canonical</tt> still defined in terms of <tt>canonical(p, base)</tt></td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3030">3030</a></td><td>Who shall meet the requirements of <tt>try_lock</tt>?</td><td>Jacksonville</td><td><i>Nothing to do</i></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3034">3034</a></td><td>P0767R1 breaks previously-standard-layout types</td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3035">3035</a></td><td><tt>std::allocator</tt>'s constructors should be <tt>constexpr</tt></td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3039">3039</a></td><td>Unnecessary <tt>decay</tt> in <tt>thread</tt> and <tt>packaged_task</tt></td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3041">3041</a></td><td>Unnecessary <tt>decay</tt> in <tt>reference_wrapper</tt></td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3042">3042</a></td><td><tt>is_literal_type_v</tt> should be inline</td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3043">3043</a></td><td>Bogus postcondition for <tt>filesystem_error</tt> constructor</td><td>Jacksonville</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3045">3045</a></td><td><tt>atomic&lt;<i>floating-point</i>&gt;</tt> doesn't have <tt>value_type</tt> or <tt>difference_type</tt></td><td>Jacksonville</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3048">3048</a></td><td><tt>transform_reduce(exec, first1, last1, first2, init)</tt> discards execution policy</td><td>Jacksonville</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3051">3051</a></td><td>Floating point classifications were inadvertently changed in P0175</td><td>Jacksonville</td><td><i>Nothing to do</i></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3075">3075</a></td><td><tt>basic_string</tt> needs deduction guides from <tt>basic_string_view</tt></td><td>Jacksonville</td><td>Complete</td></tr>
-
-   <tr><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2139">2139</a></td><td>What is a user-defined type?</td><td>Rapperswil</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2970">2970</a></td><td>Return type of std::visit misspecified</td><td>Rapperswil</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3058">3058</a></td><td>Parallel adjacent_difference shouldn't require creating temporaries</td><td>Rapperswil</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3062">3062</a></td><td>Unnecessary decay_t in is_execution_policy_v should be remove_cvref_t</td><td>Rapperswil</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3067">3067</a></td><td>recursive_directory_iterator::pop must invalidate</td><td>Rapperswil</td><td><i>Nothing to do</i></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3071">3071</a></td><td>[networking.ts] read_until still refers to "input sequence"</td><td>Rapperswil</td><td><i>Nothing to do</i></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3074">3074</a></td><td>Non-member functions for valarray should only deduce from the valarray</td><td>Rapperswil</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3076">3076</a></td><td>basic_string CTAD ambiguity</td><td>Rapperswil</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3079">3079</a></td><td>LWG 2935 forgot to fix the existing_p overloads of create_directory</td><td>Rapperswil</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3080">3080</a></td><td>Floating point from_chars pattern specification breaks round-tripping</td><td>Rapperswil</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3083">3083</a></td><td>What should ios::iword(-1) do?</td><td>Rapperswil</td><td><i>Nothing to do</i></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3094">3094</a></td><td>[time.duration.io]p4 makes surprising claims about encoding</td><td>Rapperswil</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3100">3100</a></td><td>Unnecessary and confusing "empty span" wording</td><td>Rapperswil</td><td><i>Nothing to do</i></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3102">3102</a></td><td>Clarify span iterator and const_iterator behavior</td><td>Rapperswil</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3104">3104</a></td><td>Fixing duration division</td><td>Rapperswil</td><td>Complete</td></tr>
-
-  <tr><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2183">2183</a></td><td>Muddled allocator requirements for <tt>match_results</tt> constructors</td><td>San Diego</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2184">2184</a></td><td>Muddled allocator requirements for <tt>match_results</tt> assignments</td><td>San Diego</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2412">2412</a></td><td><tt>promise::set_value()</tt> and <tt>promise::get_future()</tt> should not race</td><td>San Diego</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2499">2499</a></td><td><tt>operator&gt;&gt;(basic_istream&amp;, CharT*)</tt> makes it hard to avoid buffer overflows</td><td>San Diego</td><td>Resolved by P0487R1</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2682">2682</a></td><td><code>filesystem::copy()</code> won't create a symlink to a directory</td><td>San Diego</td><td>Nothing to do</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2697">2697</a></td><td>[concurr.ts] Behavior of <tt>future/shared_future</tt> unwrapping constructor when given an invalid <tt>future</tt></td><td>San Diego</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2797">2797</a></td><td>Trait precondition violations</td><td>San Diego</td><td>Resolved by 1285R0</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2936">2936</a></td><td>Path comparison is defined in terms of the generic format</td><td>San Diego</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2943">2943</a></td><td>Problematic specification of the wide version of <tt>basic_filebuf::open</tt></td><td>San Diego</td><td>Nothing to do</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2960">2960</a></td><td>[fund.ts.v3] <tt>nonesuch</tt> is insufficiently useless</td><td>San Diego</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2995">2995</a></td><td><tt>basic_stringbuf</tt> default constructor forbids it from using SSO capacity</td><td>San Diego</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2996">2996</a></td><td>Missing rvalue overloads for <tt>shared_ptr</tt> operations</td><td>San Diego</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3008">3008</a></td><td><tt>make_shared</tt> (sub)object destruction semantics are not specified</td><td>San Diego</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3022">3022</a></td><td><tt>is_convertible&lt;derived*, base*&gt;</tt> may lead to ODR</td><td>San Diego</td><td>Resolved by 1285R0</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3025">3025</a></td><td>Map-like container deduction guides should use <tt>pair&lt;Key, T&gt;</tt>, not <tt>pair&lt;const Key, T&gt;</tt></td><td>San Diego</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3031">3031</a></td><td>Algorithms and predicates with non-const reference arguments</td><td>San Diego</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3037">3037</a></td><td><tt>polymorphic_allocator</tt> and incomplete types</td><td>San Diego</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3038">3038</a></td><td><tt>polymorphic_allocator::allocate</tt> should not allow integer overflow to create vulnerabilities</td><td>San Diego</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3054">3054</a></td><td><tt>uninitialized_copy</tt> appears to not be able to meet its exception-safety guarantee</td><td>San Diego</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3065">3065</a></td><td>LWG 2989 missed that all <tt>path</tt>'s other operators should be hidden friends as well</td><td>San Diego</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3096">3096</a></td><td><tt>path::lexically_relative</tt> is confused by trailing slashes</td><td>San Diego</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3116">3116</a></td><td><tt><i>OUTERMOST_ALLOC_TRAITS</i></tt> needs <tt>remove_reference_t</tt></td><td>San Diego</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3122">3122</a></td><td><tt>__cpp_lib_chrono_udls</tt> was accidentally dropped</td><td>San Diego</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3127">3127</a></td><td><tt>basic_osyncstream::rdbuf</tt> needs a <tt>const_cast</tt></td><td>San Diego</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3128">3128</a></td><td><tt>strstream::rdbuf</tt> needs a <tt>const_cast</tt></td><td>San Diego</td><td><i>Nothing to do</i></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3129">3129</a></td><td><tt>regex_token_iterator</tt> constructor uses wrong pointer arithmetic</td><td>San Diego</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3130">3130</a></td><td>&sect;[input.output] needs many <tt>addressof</tt></td><td>San Diego</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3131">3131</a></td><td><tt>addressof</tt> all the things</td><td>San Diego</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3132">3132</a></td><td>Library needs to ban macros named <tt>expects</tt> or <tt>ensures</tt></td><td>San Diego</td><td><i>Nothing to do</i></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3134">3134</a></td><td>[fund.ts.v3] LFTSv3 contains extraneous [meta] variable templates that should have been deleted by P09961</td><td>San Diego</td><td>Resolved by P1210R0</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3137">3137</a></td><td>Header for <tt>__cpp_lib_to_chars</tt></td><td>San Diego</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3145">3145</a></td><td><tt>file_clock</tt> breaks ABI for C++17 implementations</td><td>San Diego</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3147">3147</a></td><td>Definitions of "likely" and "unlikely" are likely to cause problems</td><td>San Diego</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3148">3148</a></td><td><tt>&lt;concepts&gt;</tt> should be freestanding</td><td>San Diego</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3153">3153</a></td><td><tt>Common</tt> and <tt>common_type</tt> have too little in common</td><td>San Diego</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3154">3154</a></td><td><tt>Common</tt> and <tt>CommonReference</tt> have a common defect</td><td>San Diego</td><td></td></tr>
-
-  <tr><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3012">3012</a></td><td><tt>atomic&lt;T&gt;</tt> is unimplementable for non-<tt>is_trivially_copy_constructible T</tt></td><td>Kona</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3040">3040</a></td><td><tt>basic_string_view::starts_with</tt> <i>Effects</i> are incorrect</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3077">3077</a></td><td><tt>(push|emplace)_back</tt> should invalidate the <tt>end</tt> iterator</td><td>Kona</td><td><i>Nothing to do</i></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3087">3087</a></td><td>One final <tt>&amp;x</tt> in &sect;[list.ops]</td><td>Kona</td><td><i>Nothing to do</i></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3101">3101</a></td><td><tt>span</tt>'s <tt>Container</tt> constructors need another constraint</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3112">3112</a></td><td><tt>system_error</tt> and <tt>filesystem_error</tt> constructors taking a <tt>string</tt> may not be able to meet their postconditions</td><td>Kona</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3119">3119</a></td><td>Program-definedness of closure types</td><td>Kona</td><td><i>Nothing to do</i></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3133">3133</a></td><td>Modernizing numeric type requirements</td><td>Kona</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3144">3144</a></td><td><tt>span</tt> does not have a <tt>const_pointer</tt> typedef</td><td>Kona</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3173">3173</a></td><td>Enable CTAD for <i><tt>ref-view</tt></i></td><td>Kona</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3179">3179</a></td><td><tt>subrange</tt> should always model <tt>Range</tt></td><td>Kona</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3180">3180</a></td><td>Inconsistently named return type for <tt>ranges::minmax_element</tt></td><td>Kona</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3182">3182</a></td><td>Specification of <tt>Same</tt> could be clearer</td><td>Kona</td><td></td></tr>
-
-  <tr><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG2899">2899</a></td><td><tt>is_(nothrow_)move_constructible</tt> and <tt>tuple</tt>, <tt>optional</tt> and <tt>unique_ptr</tt></td><td>Cologne</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3055">3055</a></td><td><tt>path::operator+=(<i>single-character</i>)</tt> misspecified</td><td>Cologne</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3158">3158</a></td><td><tt>tuple(allocator_arg_t, const Alloc&amp;)</tt> should be conditionally explicit</td><td>Cologne</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3169">3169</a></td><td><tt>ranges</tt> permutation generators discard useful information</td><td>Cologne</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3183">3183</a></td><td>Normative permission to specialize Ranges variable templates</td><td>Cologne</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3184">3184</a></td><td>Inconsistencies in <tt>bind_front</tt> wording</td><td>Cologne</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3185">3185</a></td><td>Uses-allocator construction functions missing <tt>constexpr</tt> and <tt>noexcept</tt></td><td>Cologne</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3186">3186</a></td><td><tt>ranges</tt> removal, partition, and <tt>partial_sort_copy</tt> algorithms discard useful information</td><td>Cologne</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3187">3187</a></td><td><a href="https://wg21.link/p0591r4">P0591R4</a> reverted DR 2586 fixes to <tt>scoped_allocator_adaptor::construct()</tt></td><td>Cologne</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3191">3191</a></td><td><tt>std::ranges::shuffle</tt> synopsis does not match algorithm definition</td><td>Cologne</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3196">3196</a></td><td><tt>std::optional&lt;T&gt;</tt> is ill-formed is <tt>T</tt> is an array</td><td>Cologne</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3198">3198</a></td><td>Bad constraint on <tt>std::span::span()</tt></td><td>Cologne</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3199">3199</a></td><td><tt>istream &gt;&gt; bitset&lt;0&gt;</tt> fails</td><td>Cologne</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3202">3202</a></td><td>P0318R1 was supposed to be revised</td><td>Cologne</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3206">3206</a></td><td><tt>year_month_day</tt> conversion to <tt>sys_days</tt> uses not-existing member function</td><td>Cologne</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3208">3208</a></td><td><tt>Boolean</tt>'s expression requirements are ordered inconsistently</td><td>Cologne</td><td><i>Nothing to do</i></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3209">3209</a></td><td>Expression in <tt>year::ok()</tt> returns clause is ill-formed</td><td>Cologne</td><td>Complete</td></tr>
-
-  <tr><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3231">3231</a></td><td><tt>year_month_day_last::day</tt> specification does not cover <tt>!ok()</tt> values</td><td>Belfast</td><td><i>Nothing to do</i></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3225">3225</a></td><td><tt>zoned_time</tt> converting constructor shall not be <tt>noexcept</tt></td><td>Belfast</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3190">3190</a></td><td><tt>std::allocator::allocate</tt> sometimes returns too little storage</td><td>Belfast</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3218">3218</a></td><td>Modifier for <tt>%d</tt> parse flag does not match POSIX and <tt>format</tt> specification</td><td>Belfast</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3224">3224</a></td><td><tt>zoned_time</tt> constructor from <tt>TimeZonePtr</tt> does not specify initialization of <tt>tp_</tt></td><td>Belfast</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3230">3230</a></td><td>Format specifier <tt>%y/%Y</tt> is missing locale alternative versions</td><td>Belfast</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3232">3232</a></td><td>Inconsistency in <tt>zoned_time</tt> deduction guides</td><td>Belfast</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3222">3222</a></td><td>P0574R1 introduced preconditions on non-existent parameters</td><td>Belfast</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3221">3221</a></td><td>Result of <tt>year_month</tt> arithmetic with <tt>months</tt> is ambiguous</td><td>Belfast</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3235">3235</a></td><td><code>parse</code> manipulator without abbreviation is not callable</td><td>Belfast</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3246">3246</a></td><td>What are the constraints on the template parameter of <tt>basic_format_arg</tt>?</td><td>Belfast</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3253">3253</a></td><td><tt>basic_syncbuf::basic_syncbuf()</tt> should not be explicit</td><td>Belfast</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3245">3245</a></td><td>Unnecessary restriction on <tt>'%p'</tt> parse specifier</td><td>Belfast</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3244">3244</a></td><td>Constraints for <tt>Source</tt> in &sect;[fs.path.req] insufficiently constrainty</td><td>Belfast</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3241">3241</a></td><td><tt>chrono-spec</tt> grammar ambiguity in &sect;[time.format]</td><td>Belfast</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3257">3257</a></td><td>Missing feature testing macro update from P0858</td><td>Belfast</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3256">3256</a></td><td>Feature testing macro for <tt>constexpr</tt> algorithms</td><td>Belfast</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3273">3273</a></td><td>Specify <tt>weekday_indexed</tt> to range of <tt>[0, 7]</tt></td><td>Belfast</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3070">3070</a></td><td><tt>path::lexically_relative</tt> causes surprising results if a filename can also be a  <i>root-name</i></td><td>Belfast</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3266">3266</a></td><td><tt>to_chars(bool)</tt> should be deleted</td><td>Belfast</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3272">3272</a></td><td><tt>%I%p</tt> should parse/format <tt>duration</tt> since midnight</td><td>Belfast</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3259">3259</a></td><td>The definition of <i>constexpr iterators</i> should be adjusted</td><td>Belfast</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3103">3103</a></td><td>Errors in taking subview of <tt>span</tt> should be ill-formed where possible</td><td>Belfast</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3274">3274</a></td><td>Missing feature test macro for <tt>&lt;span&gt;</tt></td><td>Belfast</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3276">3276</a></td><td>Class <tt>split_view::outer_iterator::value_type</tt> should inherit from <tt>view_interface</tt></td><td>Belfast</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3277">3277</a></td><td>Pre-increment on prvalues is not a requirement of <tt>weakly_incrementable</tt></td><td>Belfast</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3149">3149</a></td><td><tt>DefaultConstructible</tt> should require default initialization</td><td>Belfast</td><td></td></tr>
-
-   <tr><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG1203">1203</a></td><td>More useful rvalue stream insertion</td><td>Prague</td><td>12.0</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2859">2859</a></td><td>Definition of <em>reachable</em> in [ptr.launder] misses pointer arithmetic from pointer-interconvertible object</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3018">3018</a></td><td><tt>shared_ptr</tt> of function type</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3050">3050</a></td><td>Conversion specification problem in <tt>chrono::duration</tt> constructor</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3141">3141</a></td><td><tt>CopyConstructible</tt> doesn't preserve source values</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3150">3150</a></td><td><tt>UniformRandomBitGenerator</tt> should validate <tt>min</tt> and <tt>max</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3175">3175</a></td><td>The <tt>CommonReference</tt> requirement of concept <tt>SwappableWith</tt> is not satisfied in the example</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3194">3194</a></td><td><tt>ConvertibleTo</tt> prose does not match code</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3200">3200</a></td><td><tt>midpoint</tt> should not constrain <tt>T</tt> is complete</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3201">3201</a></td><td><tt>lerp</tt> should be marked as <tt>noexcept</tt></td><td>Prague</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3226">3226</a></td><td><tt>zoned_time</tt> constructor from <tt>string_view</tt> should accept <tt>zoned_time&lt;Duration2, TimeZonePtr2&gt;</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3233">3233</a></td><td>Broken requirements for <tt>shared_ptr</tt> converting constructors</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3237">3237</a></td><td>LWG 3038 and 3190 have inconsistent PRs</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3238">3238</a></td><td>Insufficiently-defined behavior of <tt>std::function</tt> deduction guides</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3242">3242</a></td><td><tt>std::format</tt>: missing rules for <tt>arg-id</tt> in <tt>width</tt> and <tt>precision</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3243">3243</a></td><td><tt>std::format</tt> and negative zeroes</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3247">3247</a></td><td><tt>ranges::iter_move</tt> should perform ADL-only lookup of <tt>iter_move</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3248">3248</a></td><td><tt>std::format</tt> <tt>#b</tt>, <tt>#B</tt>, <tt>#o</tt>, <tt>#x</tt>, and <tt>#X</tt>  presentation types misformat negative numbers</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3250">3250</a></td><td><tt>std::format</tt>: <tt>#</tt> (alternate form) for NaN and inf</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3251">3251</a></td><td>Are <tt>std::format</tt> alignment specifiers applied to string arguments?</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3252">3252</a></td><td>Parse locale's aware modifiers for commands are not consistent with POSIX spec</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3254">3254</a></td><td>Strike <tt>stop_token</tt>'s <tt>operator!=</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3255">3255</a></td><td><tt>span</tt>'s <tt>array</tt> constructor is too strict</td><td>Prague</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3260">3260</a></td><td><tt>year_month*</tt> arithmetic rejects durations convertible to years</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3262">3262</a></td><td>Formatting of negative durations is not specified</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3264">3264</a></td><td><tt>sized_range</tt> and <tt>ranges::size</tt> redundantly use <tt>disable_sized_range</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3269">3269</a></td><td>Parse manipulators do not specify the result of the extraction from stream</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3270">3270</a></td><td>Parsing and formatting <tt>%j</tt> with <tt>duration</tt>s</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3280">3280</a></td><td>View converting constructors can cause constraint recursion and are unneeded</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3281">3281</a></td><td>Conversion from <tt><i>pair-like</i></tt> types to <tt>subrange</tt> is a silent semantic promotion</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3282">3282</a></td><td><tt>subrange</tt> converting constructor should disallow derived to base conversions</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3284">3284</a></td><td><tt>random_access_iterator</tt> semantic constraints accidentally promote difference type  using unary negate</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3285">3285</a></td><td>The type of a customization point object shall satisfy <tt>semiregular</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3286">3286</a></td><td><tt>ranges::size</tt> is not required to be valid after a call to <tt>ranges::begin</tt> on an input range</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3291">3291</a></td><td><tt>iota_view::iterator</tt> has the wrong <tt>iterator_category</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3292">3292</a></td><td><tt>iota_view</tt> is under-constrained</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3294">3294</a></td><td><tt>zoned_time</tt> deduction guides misinterprets <tt>string</tt>/<tt>char*</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3296">3296</a></td><td>Inconsistent default argument for <tt>basic_regex&lt;&gt;::assign</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3299">3299</a></td><td>Pointers don't need customized iterator behavior</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3300">3300</a></td><td>Non-array <tt>ssize</tt> overload is underconstrained</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3301">3301</a></td><td><tt>transform_view::iterator</tt> has incorrect <tt>iterator_category</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3302">3302</a></td><td>Range adaptor objects <tt>keys</tt> and <tt>values</tt> are unspecified</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3303">3303</a></td><td>Bad "<tt>constexpr</tt>" marker for <tt>destroy/destroy_n</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3304">3304</a></td><td>Allocate functions of <tt>std::polymorphic_allocator</tt> should require <tt>[[nodiscard]]</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3307">3307</a></td><td><tt>std::allocator&lt;void&gt;().allocate(n)</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3310">3310</a></td><td>Replace <tt>SIZE_MAX</tt> with <tt>numeric_limits&lt;size_t&gt;::max()</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3313">3313</a></td><td><tt>join_view::iterator::operator--</tt> is incorrectly constrained</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3314">3314</a></td><td>Is stream insertion behavior locale dependent when <tt>Period::type</tt> is <tt>micro</tt>?</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3315">3315</a></td><td>Correct Allocator Default Behavior</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3316">3316</a></td><td>Correctly define epoch for <tt>utc_clock</tt> / <tt>utc_timepoint</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3317">3317</a></td><td>Incorrect <tt>operator&lt;&lt;</tt> for floating-point durations</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3318">3318</a></td><td>Clarify whether clocks can represent time before their epoch</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3319">3319</a></td><td>Properly reference specification of IANA time zone database</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3320">3320</a></td><td><tt>span::cbegin/cend</tt> methods produce different results than <tt>std::[ranges::]cbegin/cend</tt></td><td>Prague</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG3321">3321</a></td><td><tt>uninitialized_construct_using_allocator</tt> should use <tt>construct_at</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3323">3323</a></td><td><tt><i>has-tuple-element</i></tt> helper concept needs <tt>convertible_to</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3324">3324</a></td><td>Special-case <tt>std::strong/weak/partial_order</tt> for pointers</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3325">3325</a></td><td>Constrain return type of transformation function for <tt>transform_view</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3326">3326</a></td><td><tt>enable_view</tt> has false positives</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3327">3327</a></td><td>Format alignment specifiers vs. text direction</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3328">3328</a></td><td>Clarify that <tt>std::string</tt> is not good for UTF-8</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3329">3329</a></td><td><tt>totally_ordered_with</tt> both directly and indirectly requires <tt>common_reference_with</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3330">3330</a></td><td>Include <tt>&lt;compare&gt;</tt> from most library headers</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3331">3331</a></td><td>Define <tt>totally_ordered/_with</tt> in terms of <tt><i>partially-ordered-with</i></tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3332">3332</a></td><td>Issue in &sect;[time.format]</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3334">3334</a></td><td><tt>basic_osyncstream</tt> move assignment and destruction calls <tt>basic_syncbuf::emit()</tt> twice</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3335">3335</a></td><td>Resolve C++20 NB comments US 273 and GB 274</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3338">3338</a></td><td>Rename <tt>default_constructible</tt> to <tt>default_initializable</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3340">3340</a></td><td>Formatting functions should throw on argument/format string mismatch in &sect;[format.functions]</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3346">3346</a></td><td><tt>pair</tt> and <tt>tuple</tt> copy and move constructor have backwards specification</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3347">3347</a></td><td><tt>std::pair&lt;T, U&gt;</tt> now requires <tt>T</tt> and <tt>U</tt> to be less-than-comparable</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3348">3348</a></td><td><tt>__cpp_lib_unwrap_ref</tt> in wrong header</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3349">3349</a></td><td>Missing <tt>__cpp_lib_constexpr_complex</tt> for P0415R1</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3350">3350</a></td><td>Simplify return type of <tt>lexicographical_compare_three_way</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3351">3351</a></td><td><tt>ranges::enable_safe_range</tt> should not be constrained</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3352">3352</a></td><td><tt>strong_equality</tt> isn't a thing</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3354">3354</a></td><td><tt>has_strong_structural_equality</tt> has a meaningless definition</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3355">3355</a></td><td>The memory algorithms should support move-only input iterators introduced by P1207</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3356">3356</a></td><td><tt>__cpp_lib_nothrow_convertible</tt> should be <tt>__cpp_lib_<em>is_</em>nothrow_convertible</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3358">3358</a></td><td>&sect;[span.cons] is mistaken that <tt>to_address</tt> can throw</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3359">3359</a></td><td><tt>&lt;chrono&gt;</tt> leap second support should allow for negative leap seconds</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3360">3360</a></td><td><tt>three_way_comparable_with</tt> is inconsistent with similar concepts</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3362">3362</a></td><td>Strike <tt>stop_source</tt>'s <tt>operator!=</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3363">3363</a></td><td><tt>drop_while_view</tt> should opt-out of <tt>sized_range</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3364">3364</a></td><td>Initialize data members of ranges and their iterators</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3367">3367</a></td><td>Integer-class conversions should not throw</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3369">3369</a></td><td><tt>span</tt>'s deduction-guide for built-in arrays doesn't work</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3371">3371</a></td><td><tt>visit_format_arg</tt> and <tt>make_format_args</tt> are not hidden friends</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3372">3372</a></td><td><tt>vformat_to</tt> should not try to deduce <tt>Out</tt> twice</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3373">3373</a></td><td><tt>{to,from}_chars_result</tt> and <tt>format_to_n_result</tt> need the  "we really mean what we say" wording</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3374">3374</a></td><td>P0653 + P1006 should have made the other <tt>std::to_address</tt> overload <tt>constexpr</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3375">3375</a></td><td><tt>decay</tt> in <tt>viewable_range</tt> should be <tt>remove_cvref</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3377">3377</a></td><td><tt>elements_view::iterator</tt> befriends a specialization of itself</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3379">3379</a></td><td>"<tt>safe</tt>" in several library names is misleading</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3380">3380</a></td><td><tt>common_type</tt> and comparison categories</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3381">3381</a></td><td><tt>begin</tt> and <tt>data</tt> must agree for <tt>contiguous_range</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3382">3382</a></td><td>NTTP for <tt>pair</tt> and <tt>array</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3383">3383</a></td><td>&sect;[time.zone.leap.nonmembers] <tt>sys_seconds</tt> should be replaced with <tt>seconds</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3384">3384</a></td><td><tt>transform_view::<i>sentinel</i></tt> has an incorrect <tt>operator-</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3385">3385</a></td><td><tt>common_iterator</tt> is not sufficiently constrained for non-copyable iterators</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3387">3387</a></td><td>&sect;[range.reverse.view] <tt>reverse_view&lt;V&gt;</tt> unintentionally requires <tt>range&lt;const V&gt;</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3388">3388</a></td><td><tt>view</tt> iterator types have ill-formed <tt>&lt;=&gt;</tt> operators</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3389">3389</a></td><td>A move-only iterator still does not have a <tt>counted_iterator</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3390">3390</a></td><td><tt>make_move_iterator()</tt> cannot be used to construct a <tt>move_iterator</tt> for a move-only iterator</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3393">3393</a></td><td>Missing/incorrect feature test macro for coroutines</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3395">3395</a></td><td>Definition for three-way comparison needs to be updated (US 152)</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3396">3396</a></td><td>Clarify point of reference for <tt>source_location::current()</tt> (DE 169)</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3397">3397</a></td><td><tt>ranges::basic_istream_view::iterator</tt> should not provide <tt>iterator_category</tt></td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3398">3398</a></td><td><tt>tuple_element_t</tt> is also wrong for <tt>const subrange</tt></td><td>Prague</td><td></td></tr>
-<!--   <tr><td></td><td></td><td></td><td></td></tr> -->
-  </table>
-
-  <p>Last Updated: 16-Feb-2020</p>
-</div>
+    If you are not redirected automatically, follow this <a href='docs/Cxx2aStatus.html'>link to new documentation</a>.
 </body>
 </html>