SD-6: SG10 Feature Test Recommendations

Document #: SD-6
Date: 2019-08-29
Project: Programming Language C++
C++ Community
Reply-to: Barry Revzin
<barry.revzin@gmail.com>

1 Explanation and rationale for the approach

The pace of innovation in the standardization of C++ makes long-term stability of implementations unlikely. Features are added to the language because programmers want to use those features. Features are added to (the working draft of) the standard as the features become well-specified. In many cases a feature is added to an implementation well before or well after the standard officially introducing it is approved.

This process makes it difficult for programmers who want to use a feature to know whether it is available in any given implementation. Implementations rarely leap from one formal revision of the standard directly to the next; the implementation process generally proceeds by smaller steps. As a result, testing for a specific revision of the standard (e.g. by examining the value of the __cplusplus macro) often gives the wrong answer. Implementers generally don’t want to appear to be claiming full conformance to a standard revision until all of its features are implemented. That leaves programmers with no portable way to determine which features are actually available to them.

It is often possible for a program to determine, in a manner specific to a single implementation, what features are supported by that implementation; but the means are often poorly documented and ad hoc, and sometimes complex – especially when the availability of a feature is controlled by an invocation option. To make this determination for a variety of implementations in a single source base is complex and error-prone.

1.1 Status quo before feature-test macros

Here is some code that attempts to determine whether rvalue references are available in the implementation in use:

#ifndef __USE_RVALUE_REFERENCES
  #if (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 3) || \
      _MSC_VER >= 1600
    #if __EDG_VERSION__ > 0
      #define __USE_RVALUE_REFERENCES (__EDG_VERSION__ >= 410)
    #else
      #define __USE_RVALUE_REFERENCES 1
    #endif
  #elif __clang__
    #define __USE_RVALUE_REFERENCES __has_feature(cxx_rvalue_references)
  #else
    #define __USE_RVALUE_REFERENCES 0
  #endif
#endif

First, the GNU and Microsoft version numbers are checked to see if they are high enough. But then a check is made of the EDG version number, since that front end also has compatibility modes for both those compilers, and defines macros indicating (claimed) compatibility with them. If the feature wasn’t implemented in the indicated EDG version, it is assumed that the feature is not available – even though it is possible for a customer of EDG to implement a feature before EDG does.

Fortunately Clang has ways to test specifically for the presence of specific features. But unfortunately, the function-call-like syntax used for such tests won’t work with a standard preprocessor, so this fine new feature winds up adding its own flavor of complexity to the mix.

Also note that this code is only the beginning of a real-world solution. A complete solution would need to take into account more compilers, and also command-line option settings specific to various compilers.

1.2 Characteristics of the proposed solution

To preserve implementers’ freedom to add features in the order that makes the most sense for themselves and their customers, implementers should indicate the availability of each separate feature by adding a definition of a macro with the name corresponding to that feature.

Important note: By recommending the use of these macros, WG21 is not making any feature optional; the absence of a definition for the relevant feature-test macro does not make an implementation that lacks a feature conform to a standard that requires the feature. However, if implementers and programmers follow these recommendations, portability of code between real-world implementations should be improved.

To a first approximation, a feature is identified by the WG21 paper in which it is specified, and by which it is introduced into the working draft of the standard. Not every paper introduces a new feature worth a feature-test macro, but every paper that is not just a collection of issue resolutions is considered a candidate; exceptions are explicitly justified.

For C++14, the feature-test macro name generally consists of some combination of words from the title of the paper. In the future, it is hoped that every paper will include its own recommendations concerning feature-test macro names.

The value specified for a feature-test macro is based on the year and month in which the feature is voted into the working draft. In a case where a feature is subsequently changed in a significant way, but arguably remains the same feature, the value of the macro is changed to indicate the “revision level” of the specification of the feature. However, in most cases it is expected that the presence of a feature can be determined by the presence of any non-zero macro value; for example:

template<typename T>
struct use_empty_base_opt :
    std::integral_constant<bool,
        std::is_empty<T>::value
#if __cpp_lib_is_final
        && !std::is_final<T>::value
#endif
    >
{ };

To avoid the user’s namespace, names of macros for language features are prefixed by __cpp_; for library features, by __cpp_lib_. A library feature that doesn’t introduce a new header is expected to be defined by the header(s) that implement the feature.

1.3 Examples

Selecting a more efficient compile-time implementation based on the availability of a feature:

#if __cpp_variadic_using
// can use the compile-time efficient, flat inheritance
template<typename ...T> struct Callable : T... {
  using T::operator() ...;
};
#else
// fall-back to linear recursion for older compilers
template<typename ...T> struct Callable;
template<typename T, typename ...U>
struct Callable<T, U...> : T, Callable<U...> {
  using T::operator();
  using Callable<U...>::operator();
};
template<typename T> struct Callable<T> : T {
  using T::operator();
};
template<> struct Callable<> {};
#endif

Likewise

#if __cpp_fold_expressions
template<typename... T>
  auto sum(T... args)  { return (args + ...); }
#else
auto sum() { return 0; }
template<typename T>
  auto sum(T t) { return t; }
template(typename T, typename... Ts)
  auto sum(T t, Ts... ts) { return t + sum(ts...); }
#endif

Selecting a more efficient run-time implementation based on the availability of a feature:

void update(std::set<X>& set, const X& elem, int val)
{
    auto pos = set.find(elem);
    if (pos == set.end())
        return;
#if __cpp_lib_node_extract
    auto next = std::next(pos);
    auto x = set.extract(pos);
    x.value().update(val);
    set.insert(next, std::move(x));
#else
    X tmp = *pos;
    pos = set.erase(pos);
    tmp.update(val);
    set.insert(pos, std::move(tmp));
#endif
}

In some cases, the value of a feature-test macro can change over time as the underlying feature changes. To make it easier to follow the evolution of each feature, the tables in this document are grouped by macro name - with a row for each possible value and the proposal(s) associated with it.

Conditionally implementing a feature, based on __cpp_static_assert.

#if __cpp_static_assert
#  if __cpp_static_assert > 201400
#    define Static_Assert(cond) static_assert(cond)
#  else
#    define Static_Assert(cond) static_assert(cond, #cond)
#  endif
#  define Static_Assert_Msg(cond, msg) static_assert(cond, msg)
#else
#  define Static_Assert(cond)
#  define Static_Assert_Msg(cond, msg)
#endif

Attributes can also change semantics over time, which is why the __has_cpp_attribute facility described below evaluates to a value rather than simply 1 or 0. This allows a user to conditionally provide a version of nodiscard based on __has_cpp_attribute(nodiscard):

#if __has_cpp_attribute(nodiscard) >= 201907
   // nodiscard has a reason and can
   // be applied to constructors
#  define NODISCARD(msg)      [[nodiscard(msg)]]
#  define NODISCARD_CTOR(msg) [[nodiscard(msg)]]
#elif __has_cpp_attribute(nodiscard) >= 201603
   // nodiscard doesn't have a reason, nor can
#  define NODISCARD(msg)      [[nodiscard]]
#  define NODISCARD_CTOR(msg)
#else
   // nodiscard doesn't exist at all yet
#  define NODISCARD(msg)
#  define NODISCARD_CTOR(msg)
#endif

2 Recommendations

2.1 Introduction

For the sake of improved portability between partial implementations of various C++ standards, WG21 (the ISO technical committee for the C++ programming language) recommends that implementers and programmers follow the guidelines in this document concerning feature-test macros.

Implementers who provide a new standard feature should define a macro with the recommended name and value, in the same circumstances under which the feature is available (for example, taking into account relevant command-line options), to indicate the presence of support for that feature.

Programmers who wish to determine whether a feature is available in an implementation should base that determination on the state of the macro with the recommended name. (The absence of a tested feature may result in a program with decreased functionality, or the relevant functionality may be provided in a different way. A program that strictly depends on support for a feature can just try to use the feature unconditionally; presumably, on an implementation lacking necessary support, translation will fail. Therefore, if the most useful purpose for a feature-test macro would be to control the inclusion of a #error directive if the feature is unavailable, that is considered inadequate justification for the macro. Note that the usefulness of a test macro for a feature is completely independent of the usefulness of the feature itself.)

2.2 Testing for the presence of a header: __has_include

It is impossible for a C++ program to directly, reliably, and portably determine whether or not a library header is available for inclusion. Conditionally including a header requires the use of a configuration macro, whose setting can be determined by a configuration-test process at build time (reliable, but less portable), or by some other means (often not reliable or portable).

To solve this general problem, WG21 recommends that programmers use the __has_include feature.

2.2.1 Syntax

h-preprocessing-token:
    any preprocessing-token other than >

h-pp-tokens:
    h-preprocessing-token
    h-pp-tokens h-preprocessing-token



has-include-expression:
    __has_include ( header-name )
    __has_include ( string-literal )
    __has_include ( < h-pp-tokens > )

2.2.2 Semantics

In the first form of the has-include-expression, the parenthesized header-name token is not subject to macro expansion. The second and third forms are considered only if the first form does not match, and the preprocessing tokens are processed just as in normal text.

A has-include-expression shall appear only in the controlling constant expression of a #if or #elif directive ([cpp.cond] 16.1). Prior to the evaluation of such an expression, the source file identified by the parenthesized preprocessing token sequence in each contained has-include-expression is searched for as if that preprocessing token sequence were the pp-tokens in a #include directive, except that no further macro expansion is performed. If such a directive would not satisfy the syntactic requirements of a #include directive, the program is ill-formed. The has-include-expression is replaced by the pp-number 1 if the search for the source file succeeds, and by the pp-number 0 if the search fails.

The #ifdef and #ifndef directives, and the defined conditional inclusion operator, shall treat __has_include as if it were the name of a defined macro. The identifier __has_include shall not appear in any context not mentioned in this section.

2.2.3 Example

This demonstrates a way to use a library optional facility only if it is available. Note that having __has_include(<optional>) succeed is insufficient since on many toolchains, headers may exist in installations but have their contents guarded based on compile flags. For example, the following:

#ifdef __has_include
#if __has_include(<optional>)
#include <optional>
std::optional<int> o;
#endif
#endif
int main(){ }

will still fail to compile with g++ -std=c++14 (using libstdc++).

Hence, we need to do:

#ifdef __has_include
#  if __has_include(<optional>)
#    include <optional>
#    if __cpp_lib_optional >= 201606
#      define have_optional 1
#    endif
#  elif __has_include(<experimental/optional>)
#    include <experimental/optional>
#    if __cpp_lib_experimental_optional >= 201400
#      define have_optional 1
#      define experimental_optional 1
#    endif
#endif

#ifndef have_optional
#    define have_optional 0
#endif

Additionally, the <version> header [P0754R2] is a light-weight header that defines all the standard library feature-test macros. An alternate implementation could be:

#ifndef __has_include
#  define __has_include(x) 0
#endif

#if __has_include(<version>)
#  include <version>
#elif __has_include(<optional>)
#  include <optional>
#endif
#if __cpp_lib_optional >= 201606
#  define have_optional 1
#else
#  define have_optional 0
#endif

2.3 Testing for the presence of an attribute: __has_cpp_attribute

A C++ program cannot directly, reliably, and portably determine whether or not a standard or vendor-specific attribute is available for use. Testing for attribute support generally requires complex macro logic, as illustrated above for language features in general.

To solve this general problem, WG21 recommends that programmers use the __has_cpp_attribute feature.

2.3.1 Syntax

has-attribute-expression:
    __has_cpp_attribute ( attribute-token )

2.3.2 Semantics

A has-attribute-expression shall appear only in the controlling constant expression of a #if or #elif directive ([cpp.cond] 16.1). The has-attribute-expression is replaced by a non-zero pp-number if the implementation supports an attribute with the specified name, and by the pp-number 0 otherwise.

For a standard attribute, the value of the __has_cpp_attribute macro is based on the year and month in which the attribute was voted into the working draft. In the case where the attribute is vendor-specific, the value is implementation-defined. However, in most cases it is expected that the availability of an attribute can be detected by any non-zero result.

The #ifdef and #ifndef directives, and the defined conditional inclusion operator, shall treat __has_cpp_attribute as if it were the name of a defined macro. The identifier __has_cpp_attribute shall not appear in any context not mentioned in this section.

2.3.3 Example

This demonstrates a way to use the attribute [[deprecated]] only if it is available.

#ifndef __has_cpp_attribute
# define __has_cpp_attribute(x) 0
#endif
#if __has_cpp_attribute(deprecated)
# define ATTR_DEPRECATED(msg) [[deprecated(msg)]]
#else
# define ATTR_DEPRECATED(msg)
#endif

3 Table of Feature-Test Macros

The following are all the feature-test macros in the standard, broken up by language macros, attribute macros, and library macros, then sorted by name. Each macro will contain its list of possible values and the papers necessary to be implemented before an implementation should define that macro with that particular value.

Note that a given paper may introduce or update multiple feature-test macros. A given value may require multiple papers. A paper may also remove a feature-test macro, in which case its value will be specified as deleted.

3.1 Language Feature-Test Macros

All of the language macros are predefined (i.e. no header needs to be included before doing checks).

In some cases, a feature requires two macros: one for the language and one for the library. For example, the library does not want to define its three-way comparison operators unless the compiler supports the feature. In these cases, it is suggested for end-users that they only test the library macro. Those core language feature test macros that are intended to be checked by the library are spelled __cpp_impl_*.

Macro Value Paper(s)
__cpp_aggregate_bases 201603 [P0017R1] Extension to aggregate initialization
__cpp_aggregate_nsdmi 201304 [N3653] Member initializers and aggregates
__cpp_aggregate_paren_init 201902 [P0960R3] Allow initializing aggregates from a parenthesized list of values
__cpp_alias_templates 200704 [N2258] Templates Aliases
__cpp_aligned_new 201606 [P0035R4] Dynamic memory allocation for over-aligned data
__cpp_attributes 200809 [N2761] Towards support for attributes in C++ (Revision 6)
__cpp_binary_literals 201304 [N3472] Binary Literals in the C++ Core Language
__cpp_capture_star_this 201603 [P0018R3] Lambda Capture of *this by Value as [=,*this]
__cpp_char8_t 201811 [P0482R6] char8_t: A type for UTF-8 characters and strings (Revision 6)
__cpp_conditional_explicit 201806 [P0892R2] explicit(bool)
__cpp_constexpr 200704 [N2235] Generalized Constant Expressions—Revision 5
201304 [N3652] Relaxing constraints on constexpr functions / constexpr member functions and implicit const
201603 [P0170R1] Wording for Constexpr Lambda
201907 [P1331R2] Permitting trivial default initialization in constexpr contexts
__cpp_constexpr_dynamic_alloc 201907 [P0784R7] More constexpr containers
__cpp_constinit 201907 [P1143R2] Adding the constinit keyword
__cpp_coroutines 201902 [P0912R5] Merge Coroutines TS into C++20 working draft
__cpp_decltype 200707 [N2343] Decltype (revision 7): proposed wording
__cpp_decltype_auto 201304 [N3638] Return type deduction for normal functions
__cpp_deduction_guides 201606 [P0091R3] Template argument deduction for class templates (Rev. 6)
201611 [P0512R0] Class Template Argument Deduction Assorted NB resolution and issues
201703 [P0620R0] Drafting for class template argument deduction issues
201907 [P1814R0] Wording for Class Template Argument Deduction for Alias Templates
[P1816R0] Wording for class template argument deduction for aggregates
__cpp_delegating_constructors 200604 [N1986] Delegating Constructors (revision 3)
__cpp_enumerator_attributes 201411 [N4266] Attributes for namespaces and enumerators
__cpp_exceptions 199711 Exception handling
__cpp_fold_expressions 201411 [N4295] Folding Expressions
201603 [P0036R0] Unary Folds and Empty Parameter Packs (Revision 1)
__cpp_generic_lambdas 201304 [N3649] Generic (Polymorphic) Lambda Expressions (Revision 3)
__cpp_guaranteed_copy_elision 201606 [P0135R1] Wording for guaranteed copy elision through simplified value categories
__cpp_hex_float 201603 [P0245R1] Hexadecimal float literals for C++
__cpp_if_constexpr 201606 [P0292R2] constexpr if: A slightly different syntax
__cpp_impl_destroying_delete 201806 [P0722R3] Efficient sized delete for variable sized classes
__cpp_impl_three_way_comparison 201711 [P0515R3] Consistent comparison
[P0768R1] Library Support for the Spaceship (Comparison) Operator
201907 [P1185R2] <=> != ==
[P1186R3] When do you actually use <=>?
[P1630R1] Spaceship needs a tune-up
__cpp_inheriting_constructors 200802 [N2540] Inheriting Constructors (revision 5)
201511 [P0136R1] Rewording inheriting constructors (core issue 1941 et al)
__cpp_init_captures 201304 [N3648] Wording Changes for Generalized Lambda-capture
__cpp_initializer_lists 200806 [N2672] Initializer List proposed wording
__cpp_inline_variables 201606 [P0386R2] Inline Variables
__cpp_lambdas 200907 [N2927] New wording for C++0x Lambdas (rev. 2)
__cpp_modules 201907 [P1103R3] Merging Modules
[P1811R0] Relaxing redefinition restrictions for re-exportation robustness
__cpp_namespace_attributes 201411 [N4266] Attributes for namespaces and enumerators
__cpp_noexcept_function_type 201510 [P0012R1] Make exception specifications be part of the type system, version 5
__cpp_nontype_template_args 201411 [N4268] Allow constant evaluation for all non-type template arguments
__cpp_nontype_template_parameter_auto 201606 [P0127R2] Declaring non-type template arguments with auto
__cpp_nontype_template_parameter_class 201806 [P0732R2] Class Types in Non-Type Template Parameters
__cpp_nsdmi 200809 [N2756] Non-static data member initializers
__cpp_range_based_for 200907 [N2930] Range-Based For Loop Wording (Without Concepts)
201603 [P0184R0] Generalizing the Range-Based For Loop
__cpp_raw_strings 200710 [N2442] Raw and Unicode String Literals; Unified Proposal (Rev. 2)
__cpp_ref_qualifiers 200710 [N2439] Extending move semantics to *this (revised wording)
__cpp_return_type_deduction 201304 [N3638] Return type deduction for normal functions
__cpp_rtti 199711 Run-time type identification
__cpp_rvalue_references 200610 [N2118] A Proposal to Add an Rvalue Reference to the C++ Language: Proposed Wording: Revision 3
__cpp_sized_deallocation 201309 [N3778] C++ Sized Deallocation
__cpp_static_assert 200410 [N1720] Proposal to Add Static Assertions to the Core Language (Revision 3)
201411 [N3928] Extending static_assert, v2
__cpp_structured_bindings 201606 [P0217R3] Proposed wording for structured bindings
__cpp_template_template_args 201611 [P0522R0] DR: Matching of template template-arguments excludes compatible templates
__cpp_threadsafe_static_init 200806 [N2660] Dynamic Initialization and Destruction with Concurrency
__cpp_unicode_characters 200704 [N2249] New Character Types in C++
__cpp_unicode_literals 200710 [N2442] Raw and Unicode String Literals; Unified Proposal (Rev. 2)
__cpp_user_defined_literals 200809 [N2765] User-defined Literals (aka. Extensible Literals (revision 5))
__cpp_using_enum 201907 [P1099R5] Using Enum
__cpp_variable_templates 201304 [N3651] Variable Templates (Revision 1)
__cpp_variadic_templates 200704 [N2242] Proposed Wording for Variadic Templates (Revision 2)
__cpp_variadic_using 201611 [P0195R2] Pack expansions in using-declarations

3.2 Attribute Feature-Test Macros

All of the following macros are predefined.

Macro Value Paper(s)
__has_cpp_attribute(carries_dependency) 200809 [N2761] Towards support for attributes in C++ (Revision 6)
__has_cpp_attribute(deprecated) 201309 [N3760] [[deprecated]] attribute
__has_cpp_attribute(fallthrough) 201603 [P0188R1] Wording for [[fallthrough]] attribute
__has_cpp_attribute(likely) 201803 [P0479R5] Proposed wording for likely and unlikely attributes
__has_cpp_attribute(maybe_unused) 201603 [P0212R1] Wording for [[maybe_unused]] attribute
__has_cpp_attribute(no_unique_address) 201803 [P0840R2] Language support for empty objects
__has_cpp_attribute(nodiscard) 201603 [P0189R1] Wording for [[nodiscard]] attribute
201907 [P1301R4] [[nodiscard("should have a reason")]]
[P1771R1] [[nodiscard]] for constructors
__has_cpp_attribute(noreturn) 200809 [N2761] Towards support for attributes in C++ (Revision 6)
__has_cpp_attribute(unlikely) 201803 [P0479R5] Proposed wording for likely and unlikely attributes

3.3 Library Feature-Test Macros

All of the following macros are defined after inclusion of the header <version> or one of the corresponding headers specified below.

Macro Header(s) Value Paper(s)
__cpp_lib_addressof_constexpr <memory> 201603 [LWG2296] std::addressof should be constexpr
__cpp_lib_allocator_traits_is_always_equal <deque> <forward_list> <list> <map> <memory> <scoped_allocator> <set> <string> <unordered_map> <unordered_set> <vector> 201411 [N4258] Cleaning up noexcept in the Library (Rev 3)
__cpp_lib_any <any> 201603 [P0220R1] Adopt Library Fundamentals V1 TS Components for C++17 (R1)
201606 [P0032R3] Homogeneous interface for variant, any and optional (Revision 3)
__cpp_lib_apply <tuple> 201603 [P0220R1] Adopt Library Fundamentals V1 TS Components for C++17 (R1)
__cpp_lib_array_constexpr <array> <iterator> 201603 [P0031R0] A Proposal to Add Constexpr Modifiers to reverse_iterator, move_iterator, array and Range Access
201803 [P0858R0] Constexpr iterator requirements
__cpp_lib_as_const <utility> 201510 [P0007R1] Constant View: A proposal for a std::as_const helper function template
__cpp_lib_atomic_flag_test <atomic> 201907 [P1135R6] The C++20 Synchronization Library
__cpp_lib_atomic_is_always_lock_free <atomic> 201603 [P0152R1] constexpr atomic<T>::is_always_lock_free
__cpp_lib_atomic_lock_free_type_aliases <atomic> 201907 [P1135R6] The C++20 Synchronization Library
__cpp_lib_atomic_ref <atomic> 201806 [P0019R8] Atomic Ref
__cpp_lib_atomic_wait <atomic> 201907 [P1135R6] The C++20 Synchronization Library
__cpp_lib_barrier <barrier> 201907 [P1135R6] The C++20 Synchronization Library
__cpp_lib_bind_front <functional> 201811 [P0356R5] Simplified partial function application
201907 [P1651R0] bind_front should not unwrap reference_wrapper
__cpp_lib_bit_cast <bit> 201806 [P0476R2] Bit-casting object representations
__cpp_lib_bitops <bit> 201907 [P0553R4] Bit operations
__cpp_lib_bool_constant <type_traits> 201505 [N4389] Wording for bool_constant, revision 1
__cpp_lib_bounded_array_traits <type_traits> 201902 [P1357R1] Traits for [Un]bounded Arrays
__cpp_lib_boyer_moore_searcher <functional> 201603 [P0220R1] Adopt Library Fundamentals V1 TS Components for C++17 (R1)
__cpp_lib_byte <cstddef> 201603 [P0298R3] A byte type definition
__cpp_lib_char8_t <atomic> <filesystem> <istream> <limits> <locale> <ostream> <string> <string_view> 201811 [P0482R6] char8_t: A type for UTF-8 characters and strings (Revision 6)
201907 [P1423R3] char8_t backward compatibility remediation
__cpp_lib_chrono <chrono> 201510 [P0092R1] Polishing <chrono>
201611 [P0505R0] Wording for GB 50
201907 [P1466R3] Miscellaneous minor fixes for chrono
__cpp_lib_chrono_udls <chrono> 201304 [N3642] User-defined Literals for Standard Library Types (part 1 - version 4)
__cpp_lib_clamp <algorithm> 201603 [P0025R0] An algorithm to “clamp” a value between a pair of boundary values
__cpp_lib_complex_udls <complex> 201309 [N3779] User-defined Literals for std::complex
__cpp_lib_concepts <concepts> 201806 [P0898R3] Standard Library Concepts
__cpp_lib_constexpr any C++ library header from Table 19 or any C++ header for C library facilities from Table 20 201811 [P1032R1] Misc constexpr bits
__cpp_lib_constexpr_algorithms <algorithm> 201703 [P0202R3] Add Constexpr Modifiers to Functions in <algorithm> and <utility> Headers
201806 [P0879R0] Constexpr for swap and swap related functions
__cpp_lib_constexpr_dynamic_alloc <memory> 201907 [P0784R7] More constexpr containers
__cpp_lib_constexpr_invoke <functional> 201907 [P1065R2] constexpr INVOKE
__cpp_lib_constexpr_string <string> 201907 [P0980R1] Making std::string constexpr
__cpp_lib_constexpr_vector <vector> 201907 [P1004R2] Making std::vector constexpr
__cpp_lib_destroying_delete <new> 201806 [P0722R3] Efficient sized delete for variable sized classes
__cpp_lib_enable_shared_from_this <memory> 201603 [P0074R0] Making std::owner_less more flexible
__cpp_lib_endian <bit> 201907 [P0463R1] endian, Just endian
[P1612R1] Relocate Endian’s Specification
__cpp_lib_erase_if <deque> <forward_list> <list> <map> <set> <string> <unordered_map> <unordered_set> <vector> 201811 [P1209R0] Adopt Consistent Container Erasure from Library Fundamentals 2 for C++20
__cpp_lib_exchange_function <utility> 201304 [N3668] exchange() utility function, revision 3
__cpp_lib_execution <execution> 201603 [P0024R2] The Parallelism TS Should be Standardized
201902 [P1001R2] Target Vectorization Policies from Parallelism V2 TS to C++20
__cpp_lib_filesystem <filesystem> 201603 [P0218R1] Adopt File System TS for C++17
201606 [P0219R1] Relative Paths for Filesystem
[P0392R0] Adapting string_view by filesystem paths
201703 [P0317R1] Directory Entry Caching for Filesystem
__cpp_lib_format <format> 201907 [P0645R10] Text Formatting
[P1361R2] Integration of chrono with text formatting
[P1652R1] Printf corner cases in std::format
__cpp_lib_gcd_lcm <numeric> 201606 [P0295R0] Adopt Selected Library Fundamentals V2 Components for C++17
__cpp_lib_generic_associative_lookup <map> <set> 201304 [N3657] Adding heterogeneous comparison lookup to associative containers (rev 4)
__cpp_lib_generic_unordered_hash_lookup <unordered_map> <unordered_set> 201902 [P0920R2] Precalculated hash values in lookup
deleted [P1661R1] Remove dedicated precalculated hash lookup interface
__cpp_lib_generic_unordered_lookup <unordered_map> <unordered_set> 201811 [P0919R3] Heterogeneous lookup for unordered containers
__cpp_lib_hardware_interference_size <new> 201703 [P0154R1] constexpr std::thread::hardware_{true,false}_sharing_size
__cpp_lib_has_unique_object_representations <type_traits> 201606 [P0258R2] has_unique_object_representations - wording
__cpp_lib_hypot <cmath> 201603 [P0030R1] Proposal to Introduce a 3-Argument Overload to std::hypot
__cpp_lib_incomplete_container_elements <forward_list> <list> <vector> 201505 [N4510] Minimal incomplete type support for standard containers, revision 4
__cpp_lib_integer_sequence <utility> 201304 [N3658] Compile-time integer sequences
__cpp_lib_integral_constant_callable <type_traits> 201304 [N3545] An Incremental Improvement to integral_constant
__cpp_lib_interpolate <cmath> <numeric> 201902 [P0811R3] Well-behaved interpolation for numbers and pointers
__cpp_lib_invoke <functional> 201411 [N4169] A proposal to add invoke function template (Revision 1)
__cpp_lib_is_aggregate <type_traits> 201703 [LWG2911] An is_aggregate type trait is needed
__cpp_lib_is_constant_evaluated <type_traits> 201811 [P0595R2] std::is_constant_evaluated
__cpp_lib_is_final <type_traits> 201402 [LWG2112] User-defined classes that cannot be derived from
__cpp_lib_is_invocable <type_traits> 201703 [P0604R0] Resolving GB 55, US 84, US 85, US 86
__cpp_lib_is_layout_compatible <type_traits> 201907 [P0466R5] Layout-compatibility and Pointer-interconvertibility Traits
__cpp_lib_is_null_pointer <type_traits> 201309 [LWG2247] Type traits and std::nullptr_t
__cpp_lib_is_pointer_interconvertible <type_traits> 201907 [P0466R5] Layout-compatibility and Pointer-interconvertibility Traits
__cpp_lib_is_swappable <type_traits> 201603 [P0185R1] Adding [nothrow-]swappable traits, revision 3
__cpp_lib_jthread <stop_token> <thread> 201907 [P0660R10] Stop Token and Joining Thread
__cpp_lib_latch <latch> 201907 [P1135R6] The C++20 Synchronization Library
__cpp_lib_launder <new> 201606 [P0137R1] Core Issue 1776: Replacement of class objects containing reference members
__cpp_lib_list_remove_return_type <forward_list> <list> 201806 [P0646R1] Improving the Return Value of Erase-Like Algorithms I: list/forward list
__cpp_lib_logical_traits <type_traits> 201510 [P0013R1] Logical Operator Type Traits (revison 1)
__cpp_lib_make_from_tuple <tuple> 201606 [P0209R2] make_from_tuple: apply for construction
__cpp_lib_make_reverse_iterator <iterator> 201402 [LWG2285] make_reverse_iterator
__cpp_lib_make_unique <memory> 201304 [N3656] make_unique (Revision 1)
__cpp_lib_map_try_emplace <map> 201411 [N4279] Improved insertion interface for unique-key maps (Revision 2.3)
__cpp_lib_math_constants <numbers> 201907 [P0631R8] Math Constants
__cpp_lib_math_special_functions <cmath> 201603 [P0226R1] Mathematical Special Functions for C++17, v5
__cpp_lib_memory_resource <memory_resource> 201603 [P0220R1] Adopt Library Fundamentals V1 TS Components for C++17 (R1)
__cpp_lib_node_extract <map> <set> <unordered_map> <unordered_set> 201606 [P0083R3] Splicing Maps and Sets (Revision 5)
__cpp_lib_nonmember_container_access <array> <deque> <forward_list> <iterator> <list> <map> <regex> <set> <string> <unordered_map> <unordered_set> <vector> 201411 [N4280] Non-member size() and more (Revison 2)
__cpp_lib_not_fn <functional> 201603 [P0005R4] Adopt not_fn from Library Fundamentals 2 for C++17
__cpp_lib_null_iterators <iterator> 201304 [N3644] Null Forward Iterators
__cpp_lib_optional <optional> 201603 [P0220R1] Adopt Library Fundamentals V1 TS Components for C++17 (R1)
201606 [P0032R3] Homogeneous interface for variant, any and optional (Revision 3)
[P0307R2] Making Optional Greater Equal Again
__cpp_lib_parallel_algorithm <algorithm> <numeric> 201603 [P0024R2] The Parallelism TS Should be Standardized
__cpp_lib_quoted_string_io <iomanip> 201304 [N3654] Quoted Strings Library Proposal (Revision 2)
__cpp_lib_ranges <algorithm> <functional> <iterator> <memory> <ranges> 201811 [P0896R4] The One Ranges Proposal
__cpp_lib_raw_memory_algorithms <memory> 201606 [P0040R3] Extending memory management tools
__cpp_lib_result_of_sfinae <functional> <type_traits> 201210 [N3462] std::result_of and SFINAE
__cpp_lib_robust_nonmodifying_seq_ops <algorithm> 201304 [N3671] Making non-modifying sequence operations more robust: Revision 2
__cpp_lib_sample <algorithm> 201603 [P0220R1] Adopt Library Fundamentals V1 TS Components for C++17 (R1)
__cpp_lib_scoped_lock <mutex> 201703 [P0156R2] Variadic lock_guard (Rev. 4)
__cpp_lib_semaphore <semaphore> 201907 [P1135R6] The C++20 Synchronization Library
__cpp_lib_shared_mutex <shared_mutex> 201505 [N4508] A proposal to add shared_mutex (untimed) (Revision 4)
__cpp_lib_shared_ptr_arrays <memory> 201611 [P0497R0] Fixes to shared_ptr support for arrays
__cpp_lib_shared_ptr_weak_type <memory> 201606 [P0163R0] shared_ptr::weak_type
__cpp_lib_shared_timed_mutex <shared_mutex> 201402 [N3891] A proposal to rename shared_mutex to shared_timed_mutex
__cpp_lib_source_location <source_location> 201907 [P1208R6] Adopt source location from Library Fundamentals V3 for C++20
__cpp_lib_spaceship <compare> 201907 [P1614R2] The Mothership Has Landed: Adding <=> to the Library
__cpp_lib_string_udls <string> 201304 [N3642] User-defined Literals for Standard Library Types (part 1 - version 4)
__cpp_lib_string_view <string> <string_view> 201603 [P0220R1] Adopt Library Fundamentals V1 TS Components for C++17 (R1)
201606 [P0254R2] Integrating std::string_view and std::string
201803 [P0858R0] Constexpr iterator requirements
__cpp_lib_three_way_comparison <compare> 201711 [P0768R1] Library Support for the Spaceship (Comparison) Operator
__cpp_lib_to_array <array> 201907 [P0325R4] to_array from LFTS with updates
__cpp_lib_to_chars <charconv> 201611 [P0067R5] Elementary string conversions, revision 5
[P0682R1] Repairing elementary string conversions
[LWG3137] Header for __cpp_lib_to_chars
__cpp_lib_transformation_trait_aliases <type_traits> 201304 [N3655] TransformationTraits Redux, v2
__cpp_lib_transparent_operators <functional> <memory> 201210 [N3421] Making Operator Functors greater<>
201510 [P0074R0] Making std::owner_less more flexible
__cpp_lib_tuple_element_t <tuple> 201402 [N3887] Consistent Metafunction Aliases
__cpp_lib_tuples_by_type <tuple> <utility> 201304 [N3670] Wording for Addressing Tuples by Type: Revision 2
__cpp_lib_type_trait_variable_templates <type_traits> 201510 [P0006R0] Adopt Type Traits Variable Templates from Library Fundamentals TS for C++17
__cpp_lib_uncaught_exceptions <exception> 201411 [N4259] Wording for std::uncaught_exceptions
__cpp_lib_unordered_map_try_emplace <unordered_map> 201411 [N4279] Improved insertion interface for unique-key maps (Revision 2.3)
__cpp_lib_variant <variant> 201606 [P0088R3] Variant: a type-safe union for C++17 (v8)
[P0393R3] Making Variant Greater Equal
[P0032R3] Homogeneous interface for variant, any and optional (Revision 3)
__cpp_lib_void_t <type_traits> 201411 [N3911] TransformationTrait Alias void_t

4 References

[LWG2112] Daniel Krügler. User-defined classes that cannot be derived from.
https://wg21.link/lwg2112

[LWG2247] Joe Gottman. Type traits and std::nullptr_t.
https://wg21.link/lwg2247

[LWG2285] Zhihao Yuan. make_reverse_iterator.
https://wg21.link/lwg2285

[LWG2296] Daryle Walker. std::addressof should be constexpr.
https://wg21.link/lwg2296

[LWG2911] United States. An is_aggregate type trait is needed.
https://wg21.link/lwg2911

[LWG3137] S. B.Tam. Header for __cpp_lib_to_chars.
https://wg21.link/lwg3137

[N1720] R. Klarer, J. Maddock, B. Dawes, H. Hinnant. 2004. Proposal to Add Static Assertions to the Core Language (Revision 3).
https://wg21.link/n1720

[N1986] H. Sutter, F. Glassborow. 2006. Delegating Constructors (revision 3).
https://wg21.link/n1986

[N2118] Howard E. Hinnant. 2006. A Proposal to Add an Rvalue Reference to the C++ Language: Proposed Wording: Revision 3.
https://wg21.link/n2118

[N2235] G. Dos Reis, B. Stroustrup, J. Maurer. 2007. Generalized Constant Expressions—Revision 5.
https://wg21.link/n2235

[N2242] D. Gregor, J. Järvi, J. Maurer, J. Merrill. 2007. Proposed Wording for Variadic Templates (Revision 2).
https://wg21.link/n2242

[N2249] Lawrence Crowl. 2007. New Character Types in C++.
https://wg21.link/n2249

[N2258] G. Dos Reis, B. Stroustrup. 2007. Templates Aliases.
https://wg21.link/n2258

[N2343] J. Järvi, B. Stroustrup, G. Dos Reis. 2007. Decltype (revision 7): proposed wording.
https://wg21.link/n2343

[N2439] Bronek Kozicki. 2007. Extending move semantics to *this (revised wording).
https://wg21.link/n2439

[N2442] L. Crowl, B. Dawes. 2007. Raw and Unicode String Literals; Unified Proposal (Rev. 2).
https://wg21.link/n2442

[N2540] A. Meredith, M. Wong, J. Maurer. 2008. Inheriting Constructors (revision 5).
https://wg21.link/n2540

[N2660] Lawrence Crowl. 2008. Dynamic Initialization and Destruction with Concurrency.
https://wg21.link/n2660

[N2672] J. Merrill, D. Vandevoorde. 2008. Initializer List proposed wording.
https://wg21.link/n2672

[N2756] M. Spertus, B. Seymour. 2008. Non-static data member initializers.
https://wg21.link/n2756

[N2761] J. Maurer, M. Wong. 2008. Towards support for attributes in C++ (Revision 6).
https://wg21.link/n2761

[N2765] I. McIntosh, M. Wong, R. Mak, R. Klarer, et al. 2008. User-defined Literals (aka. Extensible Literals (revision 5)).
https://wg21.link/n2765

[N2927] Daveed Vandevoorde. 2009. New wording for C++0x Lambdas (rev. 2).
https://wg21.link/n2927

[N2930] D. Gregor, B. Dawes. 2009. Range-Based For Loop Wording (Without Concepts).
https://wg21.link/n2930

[N3421] Stephan T. Lavavej. 2012. Making Operator Functors greater<>.
https://wg21.link/n3421

[N3462] E. Niebler, D. Walker, J. de Guzman. 2012. std::result_of and SFINAE.
https://wg21.link/n3462

[N3472] James Dennett. 2012. Binary Literals in the C++ Core Language.
https://wg21.link/n3472

[N3545] Walter E. Brown. 2013. An Incremental Improvement to integral_constant.
https://wg21.link/n3545

[N3638] Jason Merrill. 2013. Return type deduction for normal functions.
https://wg21.link/n3638

[N3642] Peter Sommerlad. 2013. User-defined Literals for Standard Library Types (part 1 - version 4).
https://wg21.link/n3642

[N3644] Alan Talbot. 2013. Null Forward Iterators.
https://wg21.link/n3644

[N3648] D. Vandevoorde, V. Voutilainen. 2013. Wording Changes for Generalized Lambda-capture.
https://wg21.link/n3648

[N3649] F. Vali, H. Sutter, D. Abrahams. 2013. Generic (Polymorphic) Lambda Expressions (Revision 3).
https://wg21.link/n3649

[N3651] Gabriel Dos Reis. 2013. Variable Templates (Revision 1).
https://wg21.link/n3651

[N3652] Richard Smith. 2013. Relaxing constraints on constexpr functions / constexpr member functions and implicit const.
https://wg21.link/n3652

[N3653] V. Voutilainen, R. Smith. 2013. Member initializers and aggregates.
https://wg21.link/n3653

[N3654] Beman Dawes. 2013. Quoted Strings Library Proposal (Revision 2).
https://wg21.link/n3654

[N3655] Walter E. Brown. 2013. TransformationTraits Redux, v2.
https://wg21.link/n3655

[N3656] Stephan T. Lavavej. 2013. make_unique (Revision 1).
https://wg21.link/n3656

[N3657] J. Wakely, S. Lavavej, J. Muñoz. 2013. Adding heterogeneous comparison lookup to associative containers (rev 4).
https://wg21.link/n3657

[N3658] Jonathan Wakely. 2013. Compile-time integer sequences.
https://wg21.link/n3658

[N3668] Jeffrey Yasskin. 2013. exchange() utility function, revision 3.
https://wg21.link/n3668

[N3670] Mike Spertus. 2013. Wording for Addressing Tuples by Type: Revision 2.
https://wg21.link/n3670

[N3671] M. Spertus, A. Pall. 2013. Making non-modifying sequence operations more robust: Revision 2.
https://wg21.link/n3671

[N3760] Alberto Ganesh Barbati. 2013. [[deprecated]] attribute.
https://wg21.link/n3760

[N3778] Lawrence Crowl. 2013. C++ Sized Deallocation.
https://wg21.link/n3778

[N3779] Peter Sommerlad. 2013. User-defined Literals for std::complex.
https://wg21.link/n3779

[N3887] Michael Park. 2013. Consistent Metafunction Aliases.
https://wg21.link/n3887

[N3891] G. Nishanov, H. Sutter. 2014. A proposal to rename shared_mutex to shared_timed_mutex.
https://wg21.link/n3891

[N3911] Walter E. Brown. 2014. TransformationTrait Alias void_t.
https://wg21.link/n3911

[N3928] Walter E. Brown. 2014. Extending static_assert, v2.
https://wg21.link/n3928

[N4169] Tomasz Kamiński. 2014. A proposal to add invoke function template (Revision 1).
https://wg21.link/n4169

[N4258] Nicolai Josuttis. 2014. Cleaning up noexcept in the Library (Rev 3).
https://wg21.link/n4258

[N4259] Herb Sutter. 2014. Wording for std::uncaught_exceptions.
https://wg21.link/n4259

[N4266] Richard Smith. 2014. Attributes for namespaces and enumerators.
https://wg21.link/n4266

[N4268] Richard Smith. 2014. Allow constant evaluation for all non-type template arguments.
https://wg21.link/n4268

[N4279] Thomas Köpp. 2014. Improved insertion interface for unique-key maps (Revision 2.3).
https://wg21.link/n4279

[N4280] Riccardo Marcangelo. 2014. Non-member size() and more (Revison 2).
https://wg21.link/n4280

[N4295] Andrew Sutton, Richard Smith. 2014. Folding Expressions.
https://wg21.link/n4295

[N4389] Zhihao Yuan. 2015. Wording for bool_constant, revision 1.
https://wg21.link/n4389

[N4508] Gor Nishanov. 2015. A proposal to add shared_mutex (untimed) (Revision 4).
https://wg21.link/n4508

[N4510] Zhihao Yuan. 2015. Minimal incomplete type support for standard containers, revision 4.
https://wg21.link/n4510

[P0005R4] Alisdair Meredith. 2016. Adopt not_fn from Library Fundamentals 2 for C++17.
https://wg21.link/p0005r4

[P0006R0] Alisdair Meredith. 2015. Adopt Type Traits Variable Templates from Library Fundamentals TS for C++17.
https://wg21.link/p0006r0

[P0007R1] ADAM David Alan Martin, Alisdair Meredith. 2015. Constant View: A proposal for a std::as_const helper function template.
https://wg21.link/p0007r1

[P0012R1] Jens Maurer. 2015. Make exception specifications be part of the type system, version 5.
https://wg21.link/p0012r1

[P0013R1] Jonathan Wakely. 2015. Logical Operator Type Traits (revison 1).
https://wg21.link/p0013r1

[P0017R1] Oleg Smolsky. 2015. Extension to aggregate initialization.
https://wg21.link/p0017r1

[P0018R3] H. Carter Edwards, Daveed Vandevoorde, Christian Trott, Hal Finkel, Jim Reus, Robin Maffeo, Ben Sander. 2016. Lambda Capture of *this by Value as [=,*this].
https://wg21.link/p0018r3

[P0019R8] Daniel Sunderland, H. Carter Edwards, Hans Boehm, Olivier Giroux, Mark Hoemmen, David Hollman, Bryce Adelstein Lelbach, Jens Maurer. 2018. Atomic Ref.
https://wg21.link/p0019r8

[P0024R2] Jared Hoberock. 2016. The Parallelism TS Should be Standardized.
https://wg21.link/p0024r2

[P0025R0] Martin Moene, Niels Dekker. 2015. An algorithm to “clamp” a value between a pair of boundary values.
https://wg21.link/p0025r0

[P0030R1] Benson Ma. 2015. Proposal to Introduce a 3-Argument Overload to std::hypot.
https://wg21.link/p0030r1

[P0031R0] Antony Polukhin. 2015. A Proposal to Add Constexpr Modifiers to reverse_iterator, move_iterator, array and Range Access.
https://wg21.link/p0031r0

[P0032R3] Vicente J. Botet Escriba. 2016. Homogeneous interface for variant, any and optional (Revision 3).
https://wg21.link/p0032r3

[P0035R4] Clark Nelson. 2016. Dynamic memory allocation for over-aligned data.
https://wg21.link/p0035r4

[P0036R0] Thibaut Le Jehan. 2015. Unary Folds and Empty Parameter Packs (Revision 1).
https://wg21.link/p0036r0

[P0040R3] Brent Friedman. 2016. Extending memory management tools.
https://wg21.link/p0040r3

[P0067R5] Jens Maurer. 2016. Elementary string conversions, revision 5.
https://wg21.link/p0067r5

[P0074R0] Jonathan Wakely. 2015. Making std::owner_less more flexible.
https://wg21.link/p0074r0

[P0083R3] Alan Talbot, Jonathan Wakely, Howard Hinnant, James Dennett. 2016. Splicing Maps and Sets (Revision 5).
https://wg21.link/p0083r3

[P0088R3] Axel Naumann. 2016. Variant: a type-safe union for C++17 (v8).
https://wg21.link/p0088r3

[P0091R3] Mike Spertus, Faisal Vali, Richard Smith. 2016. Template argument deduction for class templates (Rev. 6).
https://wg21.link/p0091r3

[P0092R1] Howard Hinnant. 2015. Polishing <chrono>.
https://wg21.link/p0092r1

[P0127R2] James Touton, Mike Spertus. 2016. Declaring non-type template arguments with auto.
https://wg21.link/p0127r2

[P0135R1] Richard Smith. 2016. Wording for guaranteed copy elision through simplified value categories.
https://wg21.link/p0135r1

[P0136R1] Richard Smith. 2015. Rewording inheriting constructors (core issue 1941 et al).
https://wg21.link/p0136r1

[P0137R1] Richard Smith. 2016. Core Issue 1776: Replacement of class objects containing reference members.
https://wg21.link/p0137r1

[P0152R1] Olivier Giroux, JF Bastien, Jeff Snyder. 2016. constexpr atomic<T>::is_always_lock_free.
https://wg21.link/p0152r1

[P0154R1] JF Bastien, Olivier Giroux. 2016. constexpr std::thread::hardware_{true,false}_sharing_size.
https://wg21.link/p0154r1

[P0156R2] Mike Spertus. 2017. Variadic lock_guard (Rev. 4).
https://wg21.link/p0156r2

[P0163R0] Arthur O’Dwyer. 2015. shared_ptr::weak_type.
https://wg21.link/p0163r0

[P0170R1] Faisal Vali. 2016. Wording for Constexpr Lambda.
https://wg21.link/p0170r1

[P0184R0] Eric Niebler. 2016. Generalizing the Range-Based For Loop.
https://wg21.link/p0184r0

[P0185R1] Daniel Krugler. 2016. Adding [nothrow-]swappable traits, revision 3.
https://wg21.link/p0185r1

[P0188R1] Andrew Tomazos. 2016. Wording for [[fallthrough]] attribute.
https://wg21.link/p0188r1

[P0189R1] Andrew Tomazos. 2016. Wording for [[nodiscard]] attribute.
https://wg21.link/p0189r1

[P0195R2] Robert Haberlach, Richard Smith. 2016. Pack expansions in using-declarations.
https://wg21.link/p0195r2

[P0202R3] Antony Polukhin. 2017. Add Constexpr Modifiers to Functions in <algorithm> and <utility> Headers.
https://wg21.link/p0202r3

[P0209R2] Pablo Halpern. 2016. make_from_tuple: apply for construction.
https://wg21.link/p0209r2

[P0212R1] Andrew Tomazos. 2016. Wording for [[maybe_unused]] attribute.
https://wg21.link/p0212r1

[P0217R3] Jens Maurer. 2016. Proposed wording for structured bindings.
https://wg21.link/p0217r3

[P0218R1] Beman Dawes. 2016. Adopt File System TS for C++17.
https://wg21.link/p0218r1

[P0219R1] Beman Dawes. 2016. Relative Paths for Filesystem.
https://wg21.link/p0219r1

[P0220R1] Beman Dawes. 2016. Adopt Library Fundamentals V1 TS Components for C++17 (R1).
https://wg21.link/p0220r1

[P0226R1] Walter E. Brown, Axel Naumann, Edward Smith-Rowland. 2016. Mathematical Special Functions for C++17, v5.
https://wg21.link/p0226r1

[P0245R1] Thomas Koeppe. 2016. Hexadecimal float literals for C++.
https://wg21.link/p0245r1

[P0254R2] Marshall Clow. 2016. Integrating std::string_view and std::string.
https://wg21.link/p0254r2

[P0258R2] Michael Spencer. 2016. has_unique_object_representations - wording.
https://wg21.link/p0258r2

[P0292R2] Jens Maurer. 2016. constexpr if: A slightly different syntax.
https://wg21.link/p0292r2

[P0295R0] Walter E. Brown. 2016. Adopt Selected Library Fundamentals V2 Components for C++17.
https://wg21.link/p0295r0

[P0298R3] Neil MacIntosh. 2017. A byte type definition.
https://wg21.link/p0298r3

[P0307R2] Tony Van Eerd. 2016. Making Optional Greater Equal Again.
https://wg21.link/p0307r2

[P0317R1] Beman Dawes. 2016. Directory Entry Caching for Filesystem.
https://wg21.link/p0317r1

[P0325R4] Zhihao Yuan. 2019. to_array from LFTS with updates.
https://wg21.link/p0325r4

[P0356R5] Tomasz Kamiński. 2018. Simplified partial function application.
https://wg21.link/p0356r5

[P0386R2] Hal Finkel, Richard Smith. 2016. Inline Variables.
https://wg21.link/p0386r2

[P0392R0] Nicolai Josuttis. 2016. Adapting string_view by filesystem paths.
https://wg21.link/p0392r0

[P0393R3] Tony Van Eerd. 2016. Making Variant Greater Equal.
https://wg21.link/p0393r3

[P0463R1] Howard Hinnant. 2017. endian, Just endian.
https://wg21.link/p0463r1

[P0466R5] Lisa Lippincott. 2019. Layout-compatibility and Pointer-interconvertibility Traits.
https://wg21.link/p0466r5

[P0476R2] JF Bastien. 2017. Bit-casting object representations.
https://wg21.link/p0476r2

[P0479R5] Clay Trychta. 2018. Proposed wording for likely and unlikely attributes.
https://wg21.link/p0479r5

[P0482R6] Tom Honermann. 2018. char8_t: A type for UTF-8 characters and strings (Revision 6).
https://wg21.link/p0482r6

[P0497R0] Jonathan Wakely. 2016. Fixes to shared_ptr support for arrays.
https://wg21.link/p0497r0

[P0505R0] Howard Hinnant. 2016. Wording for GB 50.
https://wg21.link/p0505r0

[P0512R0] Mike Spertus, Richard Smith, Faisal Vali. 2016. Class Template Argument Deduction Assorted NB resolution and issues.
https://wg21.link/p0512r0

[P0515R3] Herb Sutter, Jens Maurer, Walter E. Brown. 2017. Consistent comparison.
https://wg21.link/p0515r3

[P0522R0] James Touton, Hubert Tong. 2016. DR: Matching of template template-arguments excludes compatible templates.
https://wg21.link/p0522r0

[P0553R4] Jens Maurer. 2019. Bit operations.
https://wg21.link/p0553r4

[P0595R2] Richard Smith, Andrew Sutton, Daveed Vandevoorde. 2018. std::is_constant_evaluated.
https://wg21.link/p0595r2

[P0604R0] Daniel Krugler, Pablo Halpern, Jonathan Wakely. 2017. Resolving GB 55, US 84, US 85, US 86.
https://wg21.link/p0604r0

[P0620R0] Jason Merrill. 2017. Drafting for class template argument deduction issues.
https://wg21.link/p0620r0

[P0631R8] Lev Minkovsky, John McFarlane. 2019. Math Constants.
https://wg21.link/p0631r8

[P0645R10] Victor Zverovich. 2019. Text Formatting.
https://wg21.link/p0645r10

[P0646R1] Marc Mutz. 2018. Improving the Return Value of Erase-Like Algorithms I: list/forward list.
https://wg21.link/p0646r1

[P0660R10] Nicolai Josuttis, Lewis Baker, Billy O’Neal, Herb Sutter, Anthony Williams. 2019. Stop Token and Joining Thread.
https://wg21.link/p0660r10

[P0682R1] Jens Maurer. 2017. Repairing elementary string conversions.
https://wg21.link/p0682r1

[P0722R3] Richard Smith, Andrew Hunter. 2018. Efficient sized delete for variable sized classes.
https://wg21.link/p0722r3

[P0732R2] Jeff Snyder, Louis Dionne. 2018. Class Types in Non-Type Template Parameters.
https://wg21.link/p0732r2

[P0754R2] Alan Talbot. 2018. <version>.
https://wg21.link/p0754r2

[P0768R1] Walter E. Brown. 2017. Library Support for the Spaceship (Comparison) Operator.
https://wg21.link/p0768r1

[P0784R7] Daveed Vandevoorde, Peter Dimov,Louis Dionne, Nina Ranns, Richard Smith, Daveed Vandevoorde. 2019. More constexpr containers.
https://wg21.link/p0784r7

[P0811R3] S. Davis Herring. 2019. Well-behaved interpolation for numbers and pointers.
https://wg21.link/p0811r3

[P0840R2] Richard Smith. 2018. Language support for empty objects.
https://wg21.link/p0840r2

[P0858R0] Antony Polukhin. 2017. Constexpr iterator requirements.
https://wg21.link/p0858r0

[P0879R0] Antony Polukhin. 2017. Constexpr for swap and swap related functions.
https://wg21.link/p0879r0

[P0892R2] Barry Revzin, Stephan T. Lavavej. 2018. explicit(bool).
https://wg21.link/p0892r2

[P0896R4] Eric Niebler, Casey Carter, Christopher Di Bella. 2018. The One Ranges Proposal.
https://wg21.link/p0896r4

[P0898R3] Casey Carter, Eric Niebler. 2018. Standard Library Concepts.
https://wg21.link/p0898r3

[P0912R5] Gor Nishanov. 2019. Merge Coroutines TS into C++20 working draft.
https://wg21.link/p0912r5

[P0919R3] Mateusz Pusz. 2018. Heterogeneous lookup for unordered containers.
https://wg21.link/p0919r3

[P0920R2] Mateusz Pusz. 2019. Precalculated hash values in lookup.
https://wg21.link/p0920r2

[P0960R3] Ville Voutilainen, Thomas Köppe. 2019. Allow initializing aggregates from a parenthesized list of values.
https://wg21.link/p0960r3

[P0980R1] Louis Dionne. 2019. Making std::string constexpr.
https://wg21.link/p0980r1

[P1001R2] Alisdair Meredith, Pablo Halpern. 2019. Target Vectorization Policies from Parallelism V2 TS to C++20.
https://wg21.link/p1001r2

[P1004R2] Louis Dionne. 2019. Making std::vector constexpr.
https://wg21.link/p1004r2

[P1032R1] Antony Polukhin. 2018. Misc constexpr bits.
https://wg21.link/p1032r1

[P1065R2] Tomasz Kamiński, Barry Revzin. 2019. constexpr INVOKE.
https://wg21.link/p1065r2

[P1099R5] Gašper Ažman, Jonathan Mueller. 2019. Using Enum.
https://wg21.link/p1099r5

[P1103R3] Richard Smith. 2019. Merging Modules.
https://wg21.link/p1103r3

[P1135R6] David Olsen, Olivier Giroux, JF Bastien, Detlef Vollmann, Bryce Lelbach. 2019. The C++20 Synchronization Library.
https://wg21.link/p1135r6

[P1143R2] Eric Fiselier. 2019. Adding the constinit keyword.
https://wg21.link/p1143r2

[P1185R2] Barry Revzin. 2019. <=> != ==.
https://wg21.link/p1185r2

[P1186R3] Barry Revzin. 2019. When do you actually use <=>?
https://wg21.link/p1186r3

[P1208R6] Corentin Jabot, Robert Douglas, Daniel Krugler, Peter Sommerlad. 2019. Adopt source location from Library Fundamentals V3 for C++20.
https://wg21.link/p1208r6

[P1209R0] Alisdair Meredith, Stephan T. Lavavej. 2018. Adopt Consistent Container Erasure from Library Fundamentals 2 for C++20.
https://wg21.link/p1209r0

[P1301R4] JeanHeyd Meneide, Isabella Muerte. 2019. [[nodiscard("should have a reason")]].
https://wg21.link/p1301r4

[P1331R2] CJ Johnson. 2019. Permitting trivial default initialization in constexpr contexts.
https://wg21.link/p1331r2

[P1357R1] Walter E. Brown, Glen J. Fernandes. 2019. Traits for [Un]bounded Arrays.
https://wg21.link/p1357r1

[P1361R2] Victor Zverovich, Daniela Engert, Howard E. Hinnant. 2019. Integration of chrono with text formatting.
https://wg21.link/p1361r2

[P1423R3] Tom Honermann. 2019. char8_t backward compatibility remediation.
https://wg21.link/p1423r2

[P1466R3] Howard E. Hinnant. 2019. Miscellaneous minor fixes for chrono.
https://wg21.link/p1466r3

[P1612R1] Arthur O’Dwyer. 2019. Relocate Endian’s Specification.
https://wg21.link/p1612r1

[P1614R2] Barry Revzin. 2019. The Mothership Has Landed: Adding <=> to the Library.
https://wg21.link/p1614r2

[P1630R1] Barry Revzin. 2019. Spaceship needs a tune-up.
https://wg21.link/p1630r1

[P1651R0] Tomasz Kamiński. 2019. bind_front should not unwrap reference_wrapper.
https://wg21.link/p1651r0

[P1652R1] Zhihao Yuan, Victor Zverovich. 2019. Printf corner cases in std::format.
https://wg21.link/p1652r1

[P1661R1] Tomasz Kamiński. 2019. Remove dedicated precalculated hash lookup interface.
https://wg21.link/p1661r1

[P1771R1] Peter Sommerlad. 2019. [[nodiscard]] for constructors.
https://wg21.link/p1771r1

[P1811R0] Richard Smith, Gabriel Dos Reis. 2019. Relaxing redefinition restrictions for re-exportation robustness.
https://wg21.link/p1811r0

[P1814R0] Mike Spertus. 2019. Wording for Class Template Argument Deduction for Alias Templates.
https://wg21.link/p1814r0

[P1816R0] Timur Doumler. 2019. Wording for class template argument deduction for aggregates.
https://wg21.link/p1816r0