[libc++] [P0935] [C++20] Eradicating unnecessarily explicit default constructors from the standard library.

[curdeius]

Summary

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0935r0.html

[curdeius]

libcxx/include/random

101–104

Please disregard modifications to stuff other than linear_congruential_engine.

[curdeius]

• Clean up. Test default seed.

[ldionne]

This is the same as D60422, which hasn't been updated in a while. I left some comments regarding how I suggest we create shared code to check for implicit default constructibility in that review. But I like the make_implicit<E>() trick.

@zoecarver I think you two should coordinate.

[curdeius]

• Implement: [rand.device] [rand.eng] [rand.dist.uni.int] [rand.dist.uni.real]

[curdeius]

@ldionne, 've discussed it with @zoecarver, and we decided that I'll take it over. It might take some time as there are many things to change (and test), but I'll appreciate your feedback.

My doubts:

• is using make_implicit really necessary or just test_convertible is enough? Using make_implicit tests as well that the default parameter is the correct one. It's not always possible (as in random_device for instance).
• name and location of make_implicit?
• I added as well test for ctors being explicit, and that was not tested before.

[curdeius]

One more question, lots of stuff in <random> tests are also run in c++03. Is it expected? Should I add guards to my additions (#if TEST_STD_VER >= 11)?

[curdeius]

• Use typedef for C++03 compatibility.
• [rand.dist.bern]
• [rand.dist.pois]
• [rand.dist.norm]
• [stringbuf]
• [istringstream]
• [stringbuf]
• [ostringstream]
• [stringstream]
• [re.results]
• [depr.strstreambuf]
• [depr.conversions.string]
• [depr.conversions.buffer]
• [queue] [priority.queue]
• [stack]

[curdeius]

• Fix [rand] in C++03 mode.

[ldionne]

In D91292#2424853, @curdeius wrote:

@ldionne, 've discussed it with @zoecarver, and we decided that I'll take it over. It might take some time as there are many things to change (and test), but I'll appreciate your feedback.

My doubts:

• is using make_implicit really necessary or just test_convertible is enough? Using make_implicit tests as well that the default parameter is the correct one. It's not always possible (as in random_device for instance).

I think we should test the value of the default argument when we can, as you did.

• name and location of make_implicit?

What you have looks OK to me.

• I added as well test for ctors being explicit, and that was not tested before.

Thank you!

In D91292#2425285, @curdeius wrote:

One more question, lots of stuff in <random> tests are also run in c++03. Is it expected? Should I add guards to my additions (#if TEST_STD_VER >= 11)?

We support <random> in C++03. It's one of those great things :-).

libcxx/test/support/make_implicit.h

25

C++11 is required only because you're using a brace initializer, right? Clang supports variadics and rvalue references even in C++03 mode, so I'm just checking.

[curdeius]

libcxx/test/support/make_implicit.h

25

Brace initializer, rvalue references and variadics, also std::forward but that could be just a static_cast. I can make it work for C++03 then.

[curdeius]

• Update status page.
• Generalize tests. Clean up.
• Remove requirement for > C++11 in make_implicit.h.

[curdeius]

I removed the unnecessary check for > C++11 in make_implicit, but that doesn't change a lot as it's used anyway only in C++20.
Anyway, I've just seen that P0935 has been adopted as a DR applied retroactively to previous standards down to C++11. My only source tho is https://en.cppreference.com/w/cpp/numeric/random/uniform_real_distribution/uniform_real_distribution.
Should I apply it to pre-C++20 then?

[curdeius]

• Fix status page.

[ldionne]

In D91292#2427945, @curdeius wrote:

I removed the unnecessary check for > C++11 in make_implicit, but that doesn't change a lot as it's used anyway only in C++20.
Anyway, I've just seen that P0935 has been adopted as a DR applied retroactively to previous standards down to C++11. My only source tho is https://en.cppreference.com/w/cpp/numeric/random/uniform_real_distribution/uniform_real_distribution.
Should I apply it to pre-C++20 then?

It was adopted as a paper, and it does *not* appear to have been voted as a DR. I found on the Rapperswill (2018) wiki motion page:

Motion 25
Move to apply to the C++ working paper the proposed wording in P0935R0 (Eradicating unnecessarily explicit default constructors from the standard library).

It doesn't appear to be applied as a DR, however the author himself was the one to change cppreference (looking at the history). @tcanens Do you have more context?

[tcanens]

In D91292#2440215, @ldionne wrote:

In D91292#2427945, @curdeius wrote:

I removed the unnecessary check for > C++11 in make_implicit, but that doesn't change a lot as it's used anyway only in C++20.
Anyway, I've just seen that P0935 has been adopted as a DR applied retroactively to previous standards down to C++11. My only source tho is https://en.cppreference.com/w/cpp/numeric/random/uniform_real_distribution/uniform_real_distribution.
Should I apply it to pre-C++20 then?

It was adopted as a paper, and it does *not* appear to have been voted as a DR. I found on the Rapperswill (2018) wiki motion page:

Motion 25
Move to apply to the C++ working paper the proposed wording in P0935R0 (Eradicating unnecessarily explicit default constructors from the standard library).

It doesn't appear to be applied as a DR, however the author himself was the one to change cppreference (looking at the history). @tcanens Do you have more context?

LWG doesn't do official DRs like ever, so cppreference policy for the library is that we look at what implementations do (or make an educated guess/prediction about what they will do) to call things "DRs". We are trying to document things for programmers, not standard archaeologists or language lawyers.

Both libstdc++ and MSVC implement P0935 unconditionally, so I suspect that I guessed correctly for this case.

[ldionne]

In D91292#2440252, @tcanens wrote:

LWG doesn't do official DRs like ever,

I'm not sure I follow. Aren't all LWG issues considered DRs and "back applied" to earlier standards, hence what we do in the libraries wrt LWG issues?

so cppreference policy for the library is that we look at what implementations do (or make an educated guess/prediction about what they will do) to call things "DRs". We are trying to document things for programmers, not standard archaeologists or language lawyers.

I think it's misleading to call it a DR if it isn't one. I believe it would be more correct (and equally useful) to say that most implementations support it back in C++11, without using the word DR. It's a bit pedantic, but I think nothing is lost by being more precise.

Both libstdc++ and MSVC implement P0935 unconditionally, so I suspect that I guessed correctly for this case.

@curdeius In that case, I believe we should support it unconditionally as well. At worst, it's a very very small extension in older standards. That'll also simplify the implementation and the tests a bit.

[tcanens]

In D91292#2440351, @ldionne wrote:

In D91292#2440252, @tcanens wrote:

LWG doesn't do official DRs like ever,

I'm not sure I follow. Aren't all LWG issues considered DRs and "back applied" to earlier standards, hence what we do in the libraries wrt LWG issues?

LWG doesn't move issue resolutions as formal DRs the way CWG does. And not all issues are DRs - see, e.g., LWG2911 aka is_aggregate. I think the "file an issue if you want a paper back applied" process (as in LWG3494) is a fairly new invention.

so cppreference policy for the library is that we look at what implementations do (or make an educated guess/prediction about what they will do) to call things "DRs". We are trying to document things for programmers, not standard archaeologists or language lawyers.

I think it's misleading to call it a DR if it isn't one. I believe it would be more correct (and equally useful) to say that most implementations support it back in C++11, without using the word DR. It's a bit pedantic, but I think nothing is lost by being more precise.

I think that adds unnecessary confusion and complexity, not to mention that ISO rules say that DRs only apply to the immediately previous standard so we still have similar problems with stuff that goes back farther than that. But I don't think this is the right place to discuss cppreference policy.

[ldionne]

In D91292#2440443, @tcanens wrote:

I think that adds unnecessary confusion and complexity, not to mention that ISO rules say that DRs only apply to the immediately previous standard so we still have similar problems with stuff that goes back farther than that. But I don't think this is the right place to discuss cppreference policy.

Indeed, I was just giving my opinion :-). cppreference is a great tool nonetheless.

@curdeius Let's implement this back to C++11 if that's OK by you. That way, we'll remove implementation divergence and simplify our life, and we'll also make cppreference tell the truth. 😁

[curdeius]

OK. No problem. That will be a nice cleanup indeed.

[curdeius]

• Apply to pre-C++20. That requires tho that the compiler supports delegated constructors in C++03 (it seems that clang does).

[curdeius]

• Revert for C++03 (no delegating constructors).

[curdeius]

• Fix C++03.

[curdeius]

Friendly ping.

[ldionne]

I didn't look again in detail, but I remember I was OK with the patch except for the question of whether to implement it as a DR. This has been settled now, so this LGTM. Thanks!

[curdeius]

Rebase to trigger CI to reverify.

libcxx/docs/Cxx2aStatusPaperStatus.csv

 "`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","*Removed in Cologne*","n/a"
 "`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","",""
+"`P0935R0 <https://wg21.link/P0935R0>`__","LWG","Eradicating unnecessarily explicit default constructors from the standard library","Rapperswil","|Complete|","12.0"
 "`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"

libcxx/include/algorithm

public:
             {return !(__x == __y);}
     };
 
 private:
     param_type __p_;
 
 public:
     // constructors and reset functions
-    explicit uniform_int_distribution(result_type __a = 0,
-                                      result_type __b = numeric_limits<result_type>::max())
+#ifndef _LIBCPP_CXX03_LANG
+    uniform_int_distribution() : uniform_int_distribution(0) {}
+    explicit uniform_int_distribution(
+        result_type __a, result_type __b = numeric_limits<result_type>::max())
+        : __p_(param_type(__a, __b)) {}
+#else
+    explicit uniform_int_distribution(
+        result_type __a = 0,
         : __p_(param_type(__a, __b)) {}
+#endif
     explicit uniform_int_distribution(const param_type& __p) : __p_(__p) {}
     void reset() {}
 
     // generating functions
     template<class _URNG> result_type operator()(_URNG& __g)
         {return (*this)(__g, __p_);}
     template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
 

libcxx/include/locale

 class wstring_convert
 {
 public:
     typedef basic_string<char, char_traits<char>, Byte_alloc> byte_string;
     typedef basic_string<Elem, char_traits<Elem>, Wide_alloc> wide_string;
     typedef typename Codecvt::state_type                      state_type;
     typedef typename wide_string::traits_type::int_type       int_type;
 
-    explicit wstring_convert(Codecvt* pcvt = new Codecvt);          // explicit in C++14
+    wstring_convert(Codecvt* pcvt = new Codecvt);          // before C++14
+    explicit wstring_convert(Codecvt* pcvt = new Codecvt); // before C++20
+    wstring_convert() : wstring_convert(new Codecvt) {}    // C++20
+    explicit wstring_convert(Codecvt* pcvt);               // C++20
+
     wstring_convert(Codecvt* pcvt, state_type state);
     explicit wstring_convert(const byte_string& byte_err,           // explicit in C++14
                     const wide_string& wide_err = wide_string());
     wstring_convert(const wstring_convert&) = delete;               // C++14
     wstring_convert & operator=(const wstring_convert &) = delete;  // C++14
     ~wstring_convert();
 
     wide_string from_bytes(char byte);

 
 template <class Codecvt, class Elem = wchar_t, class Tr = char_traits<Elem>>
 class wbuffer_convert
     : public basic_streambuf<Elem, Tr>
 {
 public:
     typedef typename Tr::state_type state_type;
 
-    explicit wbuffer_convert(streambuf* bytebuf = 0, Codecvt* pcvt = new Codecvt,
-                    state_type state = state_type());       // explicit in C++14
+    wbuffer_convert(streambuf* bytebuf = 0, Codecvt* pcvt = new Codecvt,
+                    state_type state = state_type());          // before C++14
+    explicit wbuffer_convert(streambuf* bytebuf = nullptr, Codecvt* pcvt = new Codecvt,
+                            state_type state = state_type()); // before C++20
+    wbuffer_convert() : wbuffer_convert(nullptr) {} // C++20
+    explicit wbuffer_convert(streambuf* bytebuf, Codecvt* pcvt = new Codecvt,
+                            state_type state = state_type()); // C++20
+
     wbuffer_convert(const wbuffer_convert&) = delete;               // C++14
     wbuffer_convert & operator=(const wbuffer_convert &) = delete;  // C++14
     ~wbuffer_convert();                                             // C++14
 
     streambuf* rdbuf() const;
     streambuf* rdbuf(streambuf* bytebuf);
 
     state_type state() const;
private:
     wide_string __wide_err_string_;
     _Codecvt* __cvtptr_;
     state_type __cvtstate_;
     size_t __cvtcount_;
 
     wstring_convert(const wstring_convert& __wc);
     wstring_convert& operator=(const wstring_convert& __wc);
 public:
+#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_EXPLICIT_AFTER_CXX11 wstring_convert(_Codecvt* __pcvt = new _Codecvt);
+    wstring_convert() : wstring_convert(new _Codecvt) {}
+    _LIBCPP_INLINE_VISIBILITY
+    explicit wstring_convert(_Codecvt* __pcvt);
+#else
+    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_EXPLICIT_AFTER_CXX11
+    wstring_convert(_Codecvt* __pcvt = new _Codecvt);
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     wstring_convert(_Codecvt* __pcvt, state_type __state);
     _LIBCPP_EXPLICIT_AFTER_CXX11 wstring_convert(const byte_string& __byte_err,
                     const wide_string& __wide_err = wide_string());
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     wstring_convert(wstring_convert&& __wc);
 #endif
private:
     state_type __st_;
     ios_base::openmode __cm_;
     bool __owns_eb_;
     bool __owns_ib_;
     bool __always_noconv_;
 
     wbuffer_convert(const wbuffer_convert&);
     wbuffer_convert& operator=(const wbuffer_convert&);
+
 public:
-    _LIBCPP_EXPLICIT_AFTER_CXX11 wbuffer_convert(streambuf* __bytebuf = nullptr,
-            _Codecvt* __pcvt = new _Codecvt, state_type __state = state_type());
+#ifndef _LIBCPP_CXX03_LANG
+    wbuffer_convert() : wbuffer_convert(nullptr) {}
+    explicit wbuffer_convert(streambuf* __bytebuf,
+                             _Codecvt* __pcvt = new _Codecvt,
+                             state_type __state = state_type());
+#else
+    _LIBCPP_EXPLICIT_AFTER_CXX11
+    wbuffer_convert(streambuf* __bytebuf = nullptr,
+                    _Codecvt* __pcvt = new _Codecvt,
+                    state_type __state = state_type());
+#endif
+
     ~wbuffer_convert();
 
     _LIBCPP_INLINE_VISIBILITY
     streambuf* rdbuf() const {return __bufptr_;}
     _LIBCPP_INLINE_VISIBILITY
     streambuf* rdbuf(streambuf* __bytebuf)
     {
         streambuf* __r = __bufptr_;

libcxx/include/queue

public:
     typedef typename container_type::const_reference const_reference;
     typedef typename container_type::size_type       size_type;
 
 protected:
     container_type c;
     Compare comp;
 
 public:
-    priority_queue() = default;
-    ~priority_queue() = default;
-
-    priority_queue(const priority_queue& q) = default;
-    priority_queue(priority_queue&& q) = default;
-
-    priority_queue& operator=(const priority_queue& q) = default;
-    priority_queue& operator=(priority_queue&& q) = default;
-
-    explicit priority_queue(const Compare& comp);
-    priority_queue(const Compare& comp, const container_type& c);
-    explicit priority_queue(const Compare& comp, container_type&& c);
+    priority_queue() : priority_queue(Compare()) {} // C++20
+    explicit priority_queue(const Compare& x) : priority_queue(x, Container()) {}
+    priority_queue(const Compare& x, const Container&);
+    explicit priority_queue(const Compare& x = Compare(), Container&&= Container()); // before C++20
+    priority_queue(const Compare& x, Container&&); // C++20
     template <class InputIterator>
         priority_queue(InputIterator first, InputIterator last,
                        const Compare& comp = Compare());
     template <class InputIterator>
         priority_queue(InputIterator first, InputIterator last,
                        const Compare& comp, const container_type& c);
     template <class InputIterator>
         priority_queue(InputIterator first, InputIterator last,
#endif  // _LIBCPP_CXX03_LANG
 
     _LIBCPP_INLINE_VISIBILITY
     explicit priority_queue(const value_compare& __comp)
         : c(), comp(__comp) {}
     _LIBCPP_INLINE_VISIBILITY
     priority_queue(const value_compare& __comp, const container_type& __c);
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
-    explicit priority_queue(const value_compare& __comp, container_type&& __c);
+    priority_queue(const value_compare& __comp, container_type&& __c);
 #endif
     template <class _InputIter>
         _LIBCPP_INLINE_VISIBILITY
         priority_queue(_InputIter __f, _InputIter __l,
                        const value_compare& __comp = value_compare());
     template <class _InputIter>
         _LIBCPP_INLINE_VISIBILITY
         priority_queue(_InputIter __f, _InputIter __l,

libcxx/include/random

public:
     static constexpr result_type multiplier = a;
     static constexpr result_type increment = c;
     static constexpr result_type modulus = m;
     static constexpr result_type min() { return c == 0u ? 1u: 0u;}
     static constexpr result_type max() { return m - 1u;}
     static constexpr result_type default_seed = 1u;
 
     // constructors and seeding functions
-    explicit linear_congruential_engine(result_type s = default_seed);
+    explicit linear_congruential_engine(result_type s = default_seed);         // before C++20
+    linear_congruential_engine() : linear_congruential_engine(default_seed) {} // C++20
+    explicit linear_congruential_engine(result_type s);                        // C++20
     template<class Sseq> explicit linear_congruential_engine(Sseq& q);
     void seed(result_type s = default_seed);
     template<class Sseq> void seed(Sseq& q);
 
     // generating functions
     result_type operator()();
     void discard(unsigned long long z);
 };
public:
     static constexpr result_type tempering_c = c;
     static constexpr size_t tempering_l = l;
     static constexpr result_type initialization_multiplier = f;
     static constexpr result_type min () { return 0; }
     static constexpr result_type max() { return 2^w - 1; }
     static constexpr result_type default_seed = 5489u;
 
     // constructors and seeding functions
-    explicit mersenne_twister_engine(result_type value = default_seed);
+    explicit mersenne_twister_engine(result_type s = default_seed);      // before C++20
+    mersenne_twister_engine() : mersenne_twister_engine(default_seed) {} // C++20
+    explicit mersenne_twister_engine(result_type s);                     // C++20
     template<class Sseq> explicit mersenne_twister_engine(Sseq& q);
     void seed(result_type value = default_seed);
     template<class Sseq> void seed(Sseq& q);
 
     // generating functions
     result_type operator()();
     void discard(unsigned long long z);
 };
 
public:
     static constexpr size_t word_size = w;
     static constexpr size_t short_lag = s;
     static constexpr size_t long_lag = r;
     static constexpr result_type min() { return 0; }
     static constexpr result_type max() { return m-1; }
     static constexpr result_type default_seed = 19780503u;
 
     // constructors and seeding functions
-    explicit subtract_with_carry_engine(result_type value = default_seed);
+    explicit subtract_with_carry_engine(result_type value = default_seed);     // before C++20
+    subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {} // C++20
+    explicit subtract_with_carry_engine(result_type value);                    // C++20
     template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);
     void seed(result_type value = default_seed);
     template<class Sseq> void seed(Sseq& q);
 
     // generating functions
     result_type operator()();
     void discard(unsigned long long z);
 };
public:
     // types
     typedef unsigned int result_type;
 
     // generator characteristics
     static constexpr result_type min() { return numeric_limits<result_type>::min(); }
     static constexpr result_type max() { return numeric_limits<result_type>::max(); }
 
     // constructors
-    explicit random_device(const string& token = "/dev/urandom");
+    explicit random_device(const string& token = implementation-defined); // before C++20
+    random_device() : random_device(implementation-defined) {}            // C++20
+    explicit random_device(const string& token);                          // C++20
 
     // generating functions
     result_type operator()();
 
     // property functions
     double entropy() const noexcept;
 
     // no copy functions
public:
         result_type b() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructors and reset functions
     explicit uniform_int_distribution(IntType a = 0,
-                                    IntType b = numeric_limits<IntType>::max());
+                                      IntType b = numeric_limits<IntType>::max()); // before C++20
+    uniform_int_distribution() : uniform_int_distribution(0) {}                    // C++20
+    explicit uniform_int_distribution(IntType a,
+                                      IntType b = numeric_limits<IntType>::max()); // C++20
     explicit uniform_int_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
         result_type a() const;
         result_type b() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructors and reset functions
-    explicit uniform_real_distribution(RealType a = 0.0, RealType b = 1.0);
+    explicit uniform_real_distribution(RealType a = 0.0, RealType b = 1.0); // before C++20
+    uniform_real_distribution() : uniform_real_distribution(0.0) {}         // C++20
+    explicit uniform_real_distribution(RealType a, RealType b = 1.0);       // C++20
     explicit uniform_real_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
 
         double p() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructors and reset functions
-    explicit bernoulli_distribution(double p = 0.5);
+    explicit bernoulli_distribution(double p = 0.5);          // before C++20
+    bernoulli_distribution() : bernoulli_distribution(0.5) {} // C++20
+    explicit bernoulli_distribution(double p);                // C++20
     explicit bernoulli_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
         IntType t() const;
         double p() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructors and reset functions
-    explicit binomial_distribution(IntType t = 1, double p = 0.5);
+    explicit binomial_distribution(IntType t = 1, double p = 0.5); // before C++20
+    binomial_distribution() : binomial_distribution(1) {}          // C++20
+    explicit binomial_distribution(IntType t, double p = 0.5);     // C++20
     explicit binomial_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
 
         double p() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructors and reset functions
-    explicit geometric_distribution(double p = 0.5);
+    explicit geometric_distribution(double p = 0.5);          // before C++20
+    geometric_distribution() : geometric_distribution(0.5) {} // C++20
+    explicit geometric_distribution(double p);                // C++20
     explicit geometric_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
         result_type k() const;
         double p() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructor and reset functions
-    explicit negative_binomial_distribution(result_type k = 1, double p = 0.5);
+    explicit negative_binomial_distribution(IntType k = 1, double p = 0.5); // before C++20
+    negative_binomial_distribution() : negative_binomial_distribution(1) {} // C++20
+    explicit negative_binomial_distribution(IntType k, double p = 0.5);     // C++20
     explicit negative_binomial_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
 
         double mean() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructors and reset functions
-    explicit poisson_distribution(double mean = 1.0);
+    explicit poisson_distribution(double mean = 1.0);     // before C++20
+    poisson_distribution() : poisson_distribution(1.0) {} // C++20
+    explicit poisson_distribution(double mean);           // C++20
     explicit poisson_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
 
         result_type lambda() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructors and reset functions
-    explicit exponential_distribution(result_type lambda = 1.0);
+    explicit exponential_distribution(RealType lambda = 1.0);     // before C++20
+    exponential_distribution() : exponential_distribution(1.0) {} // C++20
+    explicit exponential_distribution(RealType lambda);           // C++20
     explicit exponential_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
         result_type alpha() const;
         result_type beta() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructors and reset functions
-    explicit gamma_distribution(result_type alpha = 1, result_type beta = 1);
+    explicit gamma_distribution(RealType alpha = 0.0, RealType beta = 1.0); // before C++20
+    gamma_distribution() : gamma_distribution(0.0) {}                       // C++20
+    explicit gamma_distribution(RealType alpha, RealType beta = 1.0);       // C++20
     explicit gamma_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
         result_type a() const;
         result_type b() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructor and reset functions
-    explicit weibull_distribution(result_type a = 1, result_type b = 1);
+    explicit weibull_distribution(RealType a = 1.0, RealType b = 1.0); // before C++20
+    weibull_distribution() : weibull_distribution(1.0) {}              // C++20
+    explicit weibull_distribution(RealType a, RealType b = 1.0);       // C++20
     explicit weibull_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
         result_type a() const;
         result_type b() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructor and reset functions
-    explicit extreme_value_distribution(result_type a = 0, result_type b = 1);
+    explicit extreme_value_distribution(RealType a = 0.0, RealType b = 1.0); // before C++20
+    extreme_value_distribution() : extreme_value_distribution(0.0) {}        // C++20
+    explicit extreme_value_distribution(RealType a, RealType b = 1.0);       // C++20
     explicit extreme_value_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
         result_type mean() const;
         result_type stddev() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructors and reset functions
-    explicit normal_distribution(result_type mean = 0, result_type stddev = 1);
+    explicit normal_distribution(RealType mean = 0.0, RealType stddev = 1.0); // before C++20
+    normal_distribution() : normal_distribution(0.0) {}                       // C++20
+    explicit normal_distribution(RealType mean, RealType stddev = 1.0);       // C++20
     explicit normal_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
         result_type m() const;
         result_type s() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructor and reset functions
-    explicit lognormal_distribution(result_type m = 0, result_type s = 1);
+    explicit lognormal_distribution(RealType mean = 0.0, RealType stddev = 1.0); // before C++20
+    lognormal_distribution() : lognormal_distribution(0.0) {}                    // C++20
+    explicit lognormal_distribution(RealType mean, RealType stddev = 1.0);       // C++20
     explicit lognormal_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
 
         result_type n() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructor and reset functions
-    explicit chi_squared_distribution(result_type n = 1);
+    explicit chi_squared_distribution(RealType n = 1.0);          // before C++20
+    chi_squared_distribution() : chi_squared_distribution(1.0) {} // C++20
+    explicit chi_squared_distribution(RealType n);                // C++20
     explicit chi_squared_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
         result_type a() const;
         result_type b() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructor and reset functions
-    explicit cauchy_distribution(result_type a = 0, result_type b = 1);
+    explicit cauchy_distribution(RealType a = 0.0, RealType b = 1.0); // before C++20
+    cauchy_distribution() : cauchy_distribution(0.0) {}               // C++20
+    explicit cauchy_distribution(RealType a, RealType b = 1.0);       // C++20
     explicit cauchy_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
         result_type m() const;
         result_type n() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructor and reset functions
-    explicit fisher_f_distribution(result_type m = 1, result_type n = 1);
+    explicit fisher_f_distribution(RealType m = 1.0, RealType n = 1.0); // before C++20
+    fisher_f_distribution() : fisher_f_distribution(1.0) {}             // C++20
+    explicit fisher_f_distribution(RealType m, RealType n = 1.0);       // C++20
     explicit fisher_f_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
 
         result_type n() const;
 
         friend bool operator==(const param_type& x, const param_type& y);
         friend bool operator!=(const param_type& x, const param_type& y);
     };
 
     // constructor and reset functions
-    explicit student_t_distribution(result_type n = 1);
+    explicit student_t_distribution(RealType n = 1.0);        // before C++20
+    student_t_distribution() : student_t_distribution(1.0) {} // C++20
+    explicit student_t_distribution(RealType n);              // C++20
     explicit student_t_distribution(const param_type& parm);
     void reset();
 
     // generating functions
     template<class URNG> result_type operator()(URNG& g);
     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
 
     // property functions
public:
     static _LIBCPP_CONSTEXPR const result_type modulus = __m;
     _LIBCPP_INLINE_VISIBILITY
     static _LIBCPP_CONSTEXPR result_type min() {return _Min;}
     _LIBCPP_INLINE_VISIBILITY
     static _LIBCPP_CONSTEXPR result_type max() {return _Max;}
     static _LIBCPP_CONSTEXPR const result_type default_seed = 1u;
 
     // constructors and seeding functions
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    linear_congruential_engine() : linear_congruential_engine(default_seed) {}
+    _LIBCPP_INLINE_VISIBILITY
+    explicit linear_congruential_engine(result_type __s) { seed(__s); }
+#else
     _LIBCPP_INLINE_VISIBILITY
-    explicit linear_congruential_engine(result_type __s = default_seed)
-        {seed(__s);}
+    explicit linear_congruential_engine(result_type __s = default_seed) {
+      seed(__s);
+    }
+#endif
     template<class _Sseq>
         _LIBCPP_INLINE_VISIBILITY
         explicit linear_congruential_engine(_Sseq& __q,
         typename enable_if<__is_seed_sequence<_Sseq, linear_congruential_engine>::value>::type* = 0)
         {seed(__q);}
     _LIBCPP_INLINE_VISIBILITY
     void seed(result_type __s = default_seed)
         {seed(integral_constant<bool, __m == 0>(),
public:
     static _LIBCPP_CONSTEXPR const result_type initialization_multiplier = __f;
     _LIBCPP_INLINE_VISIBILITY
     static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
     _LIBCPP_INLINE_VISIBILITY
     static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
     static _LIBCPP_CONSTEXPR const result_type default_seed = 5489u;
 
     // constructors and seeding functions
+#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
-    explicit mersenne_twister_engine(result_type __sd = default_seed)
-        {seed(__sd);}
+    mersenne_twister_engine() : mersenne_twister_engine(default_seed) {}
+    _LIBCPP_INLINE_VISIBILITY
+    explicit mersenne_twister_engine(result_type __sd) { seed(__sd); }
+#else
+    _LIBCPP_INLINE_VISIBILITY
+    explicit mersenne_twister_engine(result_type __sd = default_seed) {
+      seed(__sd);
+    }
+#endif
     template<class _Sseq>
         _LIBCPP_INLINE_VISIBILITY
         explicit mersenne_twister_engine(_Sseq& __q,
         typename enable_if<__is_seed_sequence<_Sseq, mersenne_twister_engine>::value>::type* = 0)
         {seed(__q);}
     void seed(result_type __sd = default_seed);
     template<class _Sseq>
         _LIBCPP_INLINE_VISIBILITY
public:
     static _LIBCPP_CONSTEXPR const size_t long_lag = __r;
     _LIBCPP_INLINE_VISIBILITY
     static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
     _LIBCPP_INLINE_VISIBILITY
     static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
     static _LIBCPP_CONSTEXPR const result_type default_seed = 19780503u;
 
     // constructors and seeding functions
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {}
     _LIBCPP_INLINE_VISIBILITY
-    explicit subtract_with_carry_engine(result_type __sd = default_seed)
-        {seed(__sd);}
+    explicit subtract_with_carry_engine(result_type __sd) { seed(__sd); }
+#else
+    _LIBCPP_INLINE_VISIBILITY
+    explicit subtract_with_carry_engine(result_type __sd = default_seed) {
+      seed(__sd);
+    }
+#endif
     template<class _Sseq>
         _LIBCPP_INLINE_VISIBILITY
         explicit subtract_with_carry_engine(_Sseq& __q,
         typename enable_if<__is_seed_sequence<_Sseq, subtract_with_carry_engine>::value>::type* = 0)
         {seed(__q);}
     _LIBCPP_INLINE_VISIBILITY
     void seed(result_type __sd = default_seed)
         {seed(__sd, integral_constant<unsigned, 1 + (__w - 1) / 32>());}
public:
     static _LIBCPP_CONSTEXPR const result_type _Max = 0xFFFFFFFFu;
 
     _LIBCPP_INLINE_VISIBILITY
     static _LIBCPP_CONSTEXPR result_type min() { return _Min;}
     _LIBCPP_INLINE_VISIBILITY
     static _LIBCPP_CONSTEXPR result_type max() { return _Max;}
 
     // constructors
+#ifndef _LIBCPP_CXX03_LANG
+    random_device() : random_device("/dev/urandom") {}
+    explicit random_device(const string& __token);
+#else
     explicit random_device(const string& __token = "/dev/urandom");
+#endif
     ~random_device();
 
     // generating functions
     result_type operator()();
 
     // property functions
     double entropy() const _NOEXCEPT;
 
public:
             {return !(__x == __y);}
     };
 
 private:
     param_type __p_;
 
 public:
     // constructors and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    uniform_real_distribution() : uniform_real_distribution(0) {}
+    explicit uniform_real_distribution(result_type __a, result_type __b = 1)
+        : __p_(param_type(__a, __b)) {}
+#else
     _LIBCPP_INLINE_VISIBILITY
     explicit uniform_real_distribution(result_type __a = 0, result_type __b = 1)
         : __p_(param_type(__a, __b)) {}
+#endif
     _LIBCPP_INLINE_VISIBILITY
     explicit uniform_real_distribution(const param_type& __p) : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
     template<class _URNG>
         _LIBCPP_INLINE_VISIBILITY
public:
             {return !(__x == __y);}
     };
 
 private:
     param_type __p_;
 
 public:
     // constructors and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    bernoulli_distribution() : bernoulli_distribution(0.5) {}
     _LIBCPP_INLINE_VISIBILITY
-    explicit bernoulli_distribution(double __p = 0.5)
-        : __p_(param_type(__p)) {}
+    explicit bernoulli_distribution(double __p) : __p_(param_type(__p)) {}
+#else
+    _LIBCPP_INLINE_VISIBILITY
+    explicit bernoulli_distribution(double __p = 0.5) : __p_(param_type(__p)) {}
+#endif
     _LIBCPP_INLINE_VISIBILITY
     explicit bernoulli_distribution(const param_type& __p) : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
     template<class _URNG>
         _LIBCPP_INLINE_VISIBILITY
public:
         friend class binomial_distribution;
     };
 
 private:
     param_type __p_;
 
 public:
     // constructors and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    binomial_distribution() : binomial_distribution(1) {}
+    _LIBCPP_INLINE_VISIBILITY
+    explicit binomial_distribution(result_type __t, double __p = 0.5)
+        : __p_(param_type(__t, __p)) {}
+#else
     _LIBCPP_INLINE_VISIBILITY
     explicit binomial_distribution(result_type __t = 1, double __p = 0.5)
         : __p_(param_type(__t, __p)) {}
+#endif
     _LIBCPP_INLINE_VISIBILITY
     explicit binomial_distribution(const param_type& __p) : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
     template<class _URNG>
         _LIBCPP_INLINE_VISIBILITY
public:
             {return !(__x == __y);}
     };
 
 private:
     param_type __p_;
 
 public:
     // constructors and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    exponential_distribution() : exponential_distribution(1) {}
+    _LIBCPP_INLINE_VISIBILITY
+    explicit exponential_distribution(result_type __lambda)
+        : __p_(param_type(__lambda)) {}
+#else
     _LIBCPP_INLINE_VISIBILITY
     explicit exponential_distribution(result_type __lambda = 1)
         : __p_(param_type(__lambda)) {}
+#endif
     _LIBCPP_INLINE_VISIBILITY
     explicit exponential_distribution(const param_type& __p) : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
     template<class _URNG>
         _LIBCPP_INLINE_VISIBILITY

 
 private:
     param_type __p_;
     result_type _V_;
     bool _V_hot_;
 
 public:
     // constructors and reset functions
+#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
-    explicit normal_distribution(result_type __mean = 0, result_type __stddev = 1)
+    normal_distribution() : normal_distribution(0) {}
+    _LIBCPP_INLINE_VISIBILITY
+    explicit normal_distribution(result_type __mean, result_type __stddev = 1)
         : __p_(param_type(__mean, __stddev)), _V_hot_(false) {}
+#else
+    _LIBCPP_INLINE_VISIBILITY
+    explicit normal_distribution(result_type __mean = 0,
+                                 result_type __stddev = 1)
+        : __p_(param_type(__mean, __stddev)), _V_hot_(false) {}
+#endif
     _LIBCPP_INLINE_VISIBILITY
     explicit normal_distribution(const param_type& __p)
         : __p_(__p), _V_hot_(false) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {_V_hot_ = false;}
 
     // generating functions
     template<class _URNG>
public:
                    lognormal_distribution<_RT>& __x);
     };
 
 private:
     param_type __p_;
 
 public:
     // constructor and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    lognormal_distribution() : lognormal_distribution(0) {}
     _LIBCPP_INLINE_VISIBILITY
-    explicit lognormal_distribution(result_type __m = 0, result_type __s = 1)
+    explicit lognormal_distribution(result_type __m, result_type __s = 1)
         : __p_(param_type(__m, __s)) {}
+#else
+    _LIBCPP_INLINE_VISIBILITY
+    explicit lognormal_distribution(result_type __m = 0,
+                                    result_type __s = 1)
+        : __p_(param_type(__m, __s)) {}
+#endif
     _LIBCPP_INLINE_VISIBILITY
     explicit lognormal_distribution(const param_type& __p)
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {__p_.__nd_.reset();}
 
     // generating functions
     template<class _URNG>
public:
         friend class poisson_distribution;
     };
 
 private:
     param_type __p_;
 
 public:
     // constructors and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    poisson_distribution() : poisson_distribution(1.0) {}
     _LIBCPP_INLINE_VISIBILITY
-    explicit poisson_distribution(double __mean = 1.0) : __p_(__mean) {}
+    explicit poisson_distribution(double __mean)
+        : __p_(__mean) {}
+#else
+    _LIBCPP_INLINE_VISIBILITY
+    explicit poisson_distribution(double __mean = 1.0)
+        : __p_(__mean) {}
+#endif
     _LIBCPP_INLINE_VISIBILITY
     explicit poisson_distribution(const param_type& __p) : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
     template<class _URNG>
         _LIBCPP_INLINE_VISIBILITY
public:
             {return !(__x == __y);}
     };
 
 private:
     param_type __p_;
 
 public:
     // constructor and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    weibull_distribution() : weibull_distribution(1) {}
+    _LIBCPP_INLINE_VISIBILITY
+    explicit weibull_distribution(result_type __a, result_type __b = 1)
+        : __p_(param_type(__a, __b)) {}
+#else
     _LIBCPP_INLINE_VISIBILITY
     explicit weibull_distribution(result_type __a = 1, result_type __b = 1)
         : __p_(param_type(__a, __b)) {}
+#endif
     _LIBCPP_INLINE_VISIBILITY
     explicit weibull_distribution(const param_type& __p)
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
     template<class _URNG>
public:
             {return !(__x == __y);}
     };
 
 private:
     param_type __p_;
 
 public:
     // constructor and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    extreme_value_distribution() : extreme_value_distribution(0) {}
     _LIBCPP_INLINE_VISIBILITY
-    explicit extreme_value_distribution(result_type __a = 0, result_type __b = 1)
+    explicit extreme_value_distribution(result_type __a, result_type __b = 1)
         : __p_(param_type(__a, __b)) {}
+#else
+    _LIBCPP_INLINE_VISIBILITY
+    explicit extreme_value_distribution(result_type __a = 0,
+                                        result_type __b = 1)
+        : __p_(param_type(__a, __b)) {}
+#endif
     _LIBCPP_INLINE_VISIBILITY
     explicit extreme_value_distribution(const param_type& __p)
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
     template<class _URNG>
public:
             {return !(__x == __y);}
     };
 
 private:
     param_type __p_;
 
 public:
     // constructors and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    gamma_distribution() : gamma_distribution(1) {}
     _LIBCPP_INLINE_VISIBILITY
-    explicit gamma_distribution(result_type __alpha = 1, result_type __beta = 1)
+    explicit gamma_distribution(result_type __alpha, result_type __beta = 1)
         : __p_(param_type(__alpha, __beta)) {}
+#else
+    _LIBCPP_INLINE_VISIBILITY
+    explicit gamma_distribution(result_type __alpha = 1,
+                                result_type __beta = 1)
+        : __p_(param_type(__alpha, __beta)) {}
+#endif
     _LIBCPP_INLINE_VISIBILITY
     explicit gamma_distribution(const param_type& __p)
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
     template<class _URNG>
public:
             {return !(__x == __y);}
     };
 
 private:
     param_type __p_;
 
 public:
     // constructor and reset functions
+#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
-    explicit negative_binomial_distribution(result_type __k = 1, double __p = 0.5)
+    negative_binomial_distribution() : negative_binomial_distribution(1) {}
+    _LIBCPP_INLINE_VISIBILITY
+    explicit negative_binomial_distribution(result_type __k, double __p = 0.5)
         : __p_(__k, __p) {}
+#else
+    _LIBCPP_INLINE_VISIBILITY
+    explicit negative_binomial_distribution(result_type __k = 1,
+                                            double __p = 0.5)
+        : __p_(__k, __p) {}
+#endif
     _LIBCPP_INLINE_VISIBILITY
     explicit negative_binomial_distribution(const param_type& __p) : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
     template<class _URNG>
         _LIBCPP_INLINE_VISIBILITY
public:
             {return !(__x == __y);}
     };
 
 private:
     param_type __p_;
 
 public:
     // constructors and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    geometric_distribution() : geometric_distribution(0.5) {}
     _LIBCPP_INLINE_VISIBILITY
-    explicit geometric_distribution(double __p = 0.5) : __p_(__p) {}
+    explicit geometric_distribution(double __p)
+        : __p_(__p) {}
+#else
+    _LIBCPP_INLINE_VISIBILITY
+    explicit geometric_distribution(double __p = 0.5)
+        : __p_(__p) {}
+#endif
     _LIBCPP_INLINE_VISIBILITY
     explicit geometric_distribution(const param_type& __p) : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
     template<class _URNG>
         _LIBCPP_INLINE_VISIBILITY
public:
             {return !(__x == __y);}
     };
 
 private:
     param_type __p_;
 
 public:
     // constructor and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    chi_squared_distribution() : chi_squared_distribution(1) {}
+    _LIBCPP_INLINE_VISIBILITY
+    explicit chi_squared_distribution(result_type __n)
+        : __p_(param_type(__n)) {}
+#else
     _LIBCPP_INLINE_VISIBILITY
     explicit chi_squared_distribution(result_type __n = 1)
         : __p_(param_type(__n)) {}
+#endif
     _LIBCPP_INLINE_VISIBILITY
     explicit chi_squared_distribution(const param_type& __p)
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
     template<class _URNG>
public:
             {return !(__x == __y);}
     };
 
 private:
     param_type __p_;
 
 public:
     // constructor and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    cauchy_distribution() : cauchy_distribution(0) {}
+    _LIBCPP_INLINE_VISIBILITY
+    explicit cauchy_distribution(result_type __a, result_type __b = 1)
+        : __p_(param_type(__a, __b)) {}
+#else
     _LIBCPP_INLINE_VISIBILITY
     explicit cauchy_distribution(result_type __a = 0, result_type __b = 1)
         : __p_(param_type(__a, __b)) {}
+#endif
     _LIBCPP_INLINE_VISIBILITY
     explicit cauchy_distribution(const param_type& __p)
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
     template<class _URNG>
public:
             {return !(__x == __y);}
     };
 
 private:
     param_type __p_;
 
 public:
     // constructor and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    fisher_f_distribution() : fisher_f_distribution(1) {}
+    _LIBCPP_INLINE_VISIBILITY
+    explicit fisher_f_distribution(result_type __m, result_type __n = 1)
+        : __p_(param_type(__m, __n)) {}
+#else
     _LIBCPP_INLINE_VISIBILITY
     explicit fisher_f_distribution(result_type __m = 1, result_type __n = 1)
         : __p_(param_type(__m, __n)) {}
+#endif
     _LIBCPP_INLINE_VISIBILITY
     explicit fisher_f_distribution(const param_type& __p)
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {}
 
     // generating functions
     template<class _URNG>
public:
     };
 
 private:
     param_type __p_;
     normal_distribution<result_type> __nd_;
 
 public:
     // constructor and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    student_t_distribution() : student_t_distribution(1) {}
+    _LIBCPP_INLINE_VISIBILITY
+    explicit student_t_distribution(result_type __n)
+        : __p_(param_type(__n)) {}
+#else
     _LIBCPP_INLINE_VISIBILITY
     explicit student_t_distribution(result_type __n = 1)
         : __p_(param_type(__n)) {}
+#endif
     _LIBCPP_INLINE_VISIBILITY
     explicit student_t_distribution(const param_type& __p)
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY
     void reset() {__nd_.reset();}
 
     // generating functions
     template<class _URNG>

libcxx/include/regex

public:
     typedef const_iterator                                    iterator;
     typedef typename iterator_traits<BidirectionalIterator>::difference_type difference_type;
     typedef typename allocator_traits<Allocator>::size_type   size_type;
     typedef Allocator                                         allocator_type;
     typedef typename iterator_traits<BidirectionalIterator>::value_type char_type;
     typedef basic_string<char_type>                           string_type;
 
     // construct/copy/destroy:
-    explicit match_results(const Allocator& a = Allocator());
+    explicit match_results(const Allocator& a = Allocator()); // before C++20
+    match_results() : match_results(Allocator()) {}           // C++20
+    explicit match_results(const Allocator& a);               // C++20
     match_results(const match_results& m);
     match_results(match_results&& m) noexcept;
     match_results& operator=(const match_results& m);
     match_results& operator=(match_results&& m);
     ~match_results();
 
     bool ready() const;
 
public:
     typedef typename __container_type::const_iterator         const_iterator;
     typedef const_iterator                                    iterator;
     typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
     typedef typename allocator_traits<allocator_type>::size_type size_type;
     typedef typename iterator_traits<_BidirectionalIterator>::value_type char_type;
     typedef basic_string<char_type>                           string_type;
 
     // construct/copy/destroy:
+#ifndef _LIBCPP_CXX03_LANG
+    match_results() : match_results(allocator_type()) {}
+    explicit match_results(const allocator_type& __a);
+#else
     explicit match_results(const allocator_type& __a = allocator_type());
+#endif
+
 //    match_results(const match_results&) = default;
 //    match_results& operator=(const match_results&) = default;
 //    match_results(match_results&& __m) = default;
 //    match_results& operator=(match_results&& __m) = default;
 //    ~match_results() = default;
 
     _LIBCPP_INLINE_VISIBILITY
     bool ready() const {return __ready_;}

libcxx/include/sstream

 public:
     typedef charT                          char_type;
     typedef traits                         traits_type;
     typedef typename traits_type::int_type int_type;
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
     typedef Allocator                      allocator_type;
 
-    // 27.8.1.1 Constructors:
-    explicit basic_stringbuf(ios_base::openmode which = ios_base::in | ios_base::out);
+    // 27.8.1.1 [stringbuf.cons], constructors:
+    explicit basic_stringbuf(ios_base::openmode which = ios_base::in | ios_base::out); // before C++20
+    basic_stringbuf() : basic_stringbuf(ios_base::in | ios_base::out) {}               // C++20
+    explicit basic_stringbuf(ios_base::openmode which);                                // C++20
     explicit basic_stringbuf(const basic_string<char_type, traits_type, allocator_type>& str,
                              ios_base::openmode which = ios_base::in | ios_base::out);
     basic_stringbuf(basic_stringbuf&& rhs);
 
     // 27.8.1.2 Assign and swap:
     basic_stringbuf& operator=(basic_stringbuf&& rhs);
     void swap(basic_stringbuf& rhs);
 
public:
     typedef charT                          char_type;
     typedef traits                         traits_type;
     typedef typename traits_type::int_type int_type;
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
     typedef Allocator                      allocator_type;
 
     // 27.8.2.1 Constructors:
-    explicit basic_istringstream(ios_base::openmode which = ios_base::in);
+    explicit basic_istringstream(ios_base::openmode which = ios_base::in); // before C++20
+    basic_istringstream() : basic_istringstream(ios_base::in) {}           // C++20
+    explicit basic_istringstream(ios_base::openmode which);                // C++20
+
     explicit basic_istringstream(const basic_string<char_type, traits_type,allocator_type>& str,
                                  ios_base::openmode which = ios_base::in);
     basic_istringstream(basic_istringstream&& rhs);
 
     // 27.8.2.2 Assign and swap:
     basic_istringstream& operator=(basic_istringstream&& rhs);
     void swap(basic_istringstream& rhs);
 
public:
     typedef charT                          char_type;
     typedef traits                         traits_type;
     typedef typename traits_type::int_type int_type;
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
     typedef Allocator                      allocator_type;
 
     // 27.8.3.1 Constructors/destructor:
-    explicit basic_ostringstream(ios_base::openmode which = ios_base::out);
+    explicit basic_ostringstream(ios_base::openmode which = ios_base::out); // before C++20
+    basic_ostringstream() : basic_ostringstream(ios_base::out) {}           // C++20
+    explicit basic_ostringstream(ios_base::openmode which);                 // C++20
+
     explicit basic_ostringstream(const basic_string<char_type, traits_type, allocator_type>& str,
                                  ios_base::openmode which = ios_base::out);
     basic_ostringstream(basic_ostringstream&& rhs);
 
     // 27.8.3.2 Assign/swap:
     basic_ostringstream& operator=(basic_ostringstream&& rhs);
     void swap(basic_ostringstream& rhs);
 
public:
     typedef charT                          char_type;
     typedef traits                         traits_type;
     typedef typename traits_type::int_type int_type;
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
     typedef Allocator                      allocator_type;
 
     // constructors/destructor
-    explicit basic_stringstream(ios_base::openmode which = ios_base::out|ios_base::in);
+    explicit basic_stringstream(ios_base::openmode which = ios_base::out | ios_base::in); // before C++20
+    basic_stringstream() : basic_stringstream(ios_base::out | ios_base::in) {}            // C++20
+    explicit basic_stringstream(ios_base::openmode which);                                // C++20
+
     explicit basic_stringstream(const basic_string<char_type, traits_type, allocator_type>& str,
                                 ios_base::openmode which = ios_base::out|ios_base::in);
     basic_stringstream(basic_stringstream&& rhs);
 
     // 27.8.5.1 Assign/swap:
     basic_stringstream& operator=(basic_stringstream&& rhs);
     void swap(basic_stringstream& rhs);
 

 
 private:
 
     string_type __str_;
     mutable char_type* __hm_;
     ios_base::openmode __mode_;
 
 public:
-    // 27.8.1.1 Constructors:
+    // 30.8.2.1 [stringbuf.cons], constructors
+#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
-    explicit basic_stringbuf(ios_base::openmode __wch = ios_base::in | ios_base::out)
-        : __hm_(nullptr), __mode_(__wch)
-    { }
+    basic_stringbuf() : basic_stringbuf(ios_base::in | ios_base::out) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit basic_stringbuf(ios_base::openmode __wch)
+        : __hm_(nullptr), __mode_(__wch) {}
+#else
+    _LIBCPP_INLINE_VISIBILITY
+    explicit basic_stringbuf(ios_base::openmode __wch = ios_base::in |
+                                                        ios_base::out)
+        : __hm_(nullptr), __mode_(__wch) {}
+#endif
 
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_stringbuf(const string_type& __s,
                              ios_base::openmode __wch = ios_base::in | ios_base::out)
         : __str_(__s.get_allocator()), __hm_(nullptr), __mode_(__wch)
     {
         str(__s);
     }
public:
     typedef _Allocator                     allocator_type;
 
     typedef basic_string<char_type, traits_type, allocator_type> string_type;
 
 private:
     basic_stringbuf<char_type, traits_type, allocator_type> __sb_;
 
 public:
-    // 27.8.2.1 Constructors:
+    // 30.8.3.1 [istringstream.cons], constructors
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    basic_istringstream() : basic_istringstream(ios_base::in) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit basic_istringstream(ios_base::openmode __wch)
+        : basic_istream<_CharT, _Traits>(&__sb_), __sb_(__wch | ios_base::in) {}
+#else
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_istringstream(ios_base::openmode __wch = ios_base::in)
-        : basic_istream<_CharT, _Traits>(&__sb_)
-        , __sb_(__wch | ios_base::in)
-    { }
+        : basic_istream<_CharT, _Traits>(&__sb_), __sb_(__wch | ios_base::in) {}
+#endif
+
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_istringstream(const string_type& __s,
                                  ios_base::openmode __wch = ios_base::in)
         : basic_istream<_CharT, _Traits>(&__sb_)
         , __sb_(__s, __wch | ios_base::in)
     { }
 
     _LIBCPP_INLINE_VISIBILITY
public:
     typedef _Allocator                     allocator_type;
 
     typedef basic_string<char_type, traits_type, allocator_type> string_type;
 
 private:
     basic_stringbuf<char_type, traits_type, allocator_type> __sb_;
 
 public:
-    // 27.8.2.1 Constructors:
+    // 30.8.4.1 [ostringstream.cons], constructors
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_INLINE_VISIBILITY
+    basic_ostringstream() : basic_ostringstream(ios_base::out) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit basic_ostringstream(ios_base::openmode __wch)
+        : basic_ostream<_CharT, _Traits>(&__sb_),
+          __sb_(__wch | ios_base::out) {}
+#else
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_ostringstream(ios_base::openmode __wch = ios_base::out)
-        : basic_ostream<_CharT, _Traits>(&__sb_)
-        , __sb_(__wch | ios_base::out)
-    { }
+        : basic_ostream<_CharT, _Traits>(&__sb_),
+          __sb_(__wch | ios_base::out) {}
+#endif
 
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_ostringstream(const string_type& __s,
                                  ios_base::openmode __wch = ios_base::out)
         : basic_ostream<_CharT, _Traits>(&__sb_)
         , __sb_(__s, __wch | ios_base::out)
     { }
 
public:
     typedef _Allocator                     allocator_type;
 
     typedef basic_string<char_type, traits_type, allocator_type> string_type;
 
 private:
     basic_stringbuf<char_type, traits_type, allocator_type> __sb_;
 
 public:
-    // 27.8.2.1 Constructors:
+    // 30.8.5.1 [stringstream.cons], constructors
+#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
-    explicit basic_stringstream(ios_base::openmode __wch = ios_base::in | ios_base::out)
-        : basic_iostream<_CharT, _Traits>(&__sb_)
-        , __sb_(__wch)
-    { }
+    basic_stringstream() : basic_stringstream(ios_base::in | ios_base::out) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit basic_stringstream(ios_base::openmode __wch)
+        : basic_iostream<_CharT, _Traits>(&__sb_), __sb_(__wch) {}
+#else
+    _LIBCPP_INLINE_VISIBILITY
+    explicit basic_stringstream(ios_base::openmode __wch = ios_base::in |
+                                                           ios_base::out)
+        : basic_iostream<_CharT, _Traits>(&__sb_), __sb_(__wch) {}
+#endif
 
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_stringstream(const string_type& __s,
                                 ios_base::openmode __wch = ios_base::in | ios_base::out)
         : basic_iostream<_CharT, _Traits>(&__sb_)
         , __sb_(__s, __wch)
     { }
 

libcxx/include/strstream

 
 /*
     strstream synopsis
 
 class strstreambuf
     : public basic_streambuf<char>
 {
 public:
-    explicit strstreambuf(streamsize alsize_arg = 0);
+    explicit strstreambuf(streamsize alsize_arg = 0); // before C++20
+    strstreambuf() : strstreambuf(0) {}               // C++20
+    explicit strstreambuf(streamsize alsize_arg);     // C++20
+
     strstreambuf(void* (*palloc_arg)(size_t), void (*pfree_arg)(void*));
     strstreambuf(char* gnext_arg, streamsize n, char* pbeg_arg = nullptr);
     strstreambuf(const char* gnext_arg, streamsize n);
 
     strstreambuf(signed char* gnext_arg, streamsize n, signed char* pbeg_arg = nullptr);
     strstreambuf(const signed char* gnext_arg, streamsize n);
     strstreambuf(unsigned char* gnext_arg, streamsize n, unsigned char* pbeg_arg = nullptr);
     strstreambuf(const unsigned char* gnext_arg, streamsize n);

 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 class _LIBCPP_TYPE_VIS strstreambuf
     : public streambuf
 {
 public:
+#ifndef _LIBCPP_CXX03_LANG
+    strstreambuf() : strstreambuf(0) {}
+    explicit strstreambuf(streamsize __alsize);
+#else
     explicit strstreambuf(streamsize __alsize = 0);
+#endif
     strstreambuf(void* (*__palloc)(size_t), void (*__pfree)(void*));
     strstreambuf(char* __gnext, streamsize __n, char* __pbeg = nullptr);
     strstreambuf(const char* __gnext, streamsize __n);
 
     strstreambuf(signed char* __gnext, streamsize __n, signed char* __pbeg = nullptr);
     strstreambuf(const signed char* __gnext, streamsize __n);
     strstreambuf(unsigned char* __gnext, streamsize __n, unsigned char* __pbeg = nullptr);
     strstreambuf(const unsigned char* __gnext, streamsize __n);

libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp.pass.cpp

 
 // explicit priority_queue(const Compare& comp);
 
 #include <queue>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
+#if TEST_STD_VER >= 11
+#include "test_convertible.h"
+#endif
 
 int main(int, char**)
 {
-    std::priority_queue<int, std::vector<int, limited_allocator<int, 10> > > q((std::less<int>()));
+    typedef std::vector<int, limited_allocator<int, 10> > Container;
+    typedef std::less<int> Compare;
+    typedef std::priority_queue<int, Container> Q;
+    Q q((Compare()));
     assert(q.size() == 0);
     q.push(1);
     q.push(2);
     assert(q.size() == 2);
     assert(q.top() == 2);
 
+#if TEST_STD_VER >= 11
+    static_assert(!test_convertible<Q, const Compare&>(), "");
+#endif
+
     return 0;
 }

libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp_container.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <queue>
 
-// explicit priority_queue(const Compare& comp, const container_type& c);
+// priority_queue(const Compare& comp, const Container& c);
 
 #include <queue>
 #include <cassert>
 #include <functional>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "test_convertible.h"
+#endif
 
 template <class C>
 C
 make(int n)
 {
     C c;
     for (int i = 0; i < n; ++i)
         c.push_back(i);
     return c;
 }
 
 int main(int, char**)
 {
-    std::vector<int> v = make<std::vector<int> >(5);
-    std::priority_queue<int, std::vector<int>, std::greater<int> > q(std::greater<int>(), v);
+    typedef std::vector<int> Container;
+    typedef std::greater<int> Compare;
+    typedef std::priority_queue<int, Container, Compare> Q;
+    Container v = make<Container>(5);
+    Q q(Compare(), v);
     assert(q.size() == 5);
     assert(q.top() == 0);
 
+#if TEST_STD_VER >= 11
+    // It should be explicit, so not convertible before C++20.
+    static_assert(test_convertible<Q, const Compare&, const Container&>(), "");
+#endif
+
     return 0;
 }

libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_comp_rcontainer.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
 // <queue>
 
-// explicit priority_queue(const Compare& comp, container_type&& c);
+// explicit priority_queue(const Compare& comp, Container&& c); // before C++20
+// priority_queue(const Compare& comp, Container&& c);          // C++20
 
 #include <queue>
 #include <cassert>
 
 #include "test_macros.h"
 #include "MoveOnly.h"
-
+#include "test_convertible.h"
 
 template <class C>
 C
 make(int n)
 {
     C c;
     for (int i = 0; i < n; ++i)
         c.push_back(MoveOnly(i));
     return c;
 }
 
-
 int main(int, char**)
 {
-    std::priority_queue<MoveOnly> q(std::less<MoveOnly>(), make<std::vector<MoveOnly> >(5));
+    typedef std::vector<MoveOnly> Container;
+    typedef std::less<MoveOnly> Compare;
+    typedef std::priority_queue<MoveOnly> Q;
+    Q q(Compare(), make<Container>(5));
     assert(q.size() == 5);
     assert(q.top() == MoveOnly(4));
 
+    static_assert(test_convertible<Q, const Compare&, Container&&>(), "");
+
     return 0;
 }

libcxx/test/std/containers/container.adaptors/priority.queue/priqueue.cons/ctor_default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <queue>
 
-// priority_queue();
+// explicit priority_queue(const Compare& x = Compare(), Container&& = Container()); // before C++20
+// priority_queue() : priority_queue(Compare()) {}                                   // C++20
+// explicit priority_queue(const Compare& x) : priority_queue(x, Container()) {}     // C++20
 
 #include <queue>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
+#if TEST_STD_VER >= 11
+#include "test_convertible.h"
+#endif
 
 int main(int, char**)
 {
-    std::priority_queue<int, std::vector<int, limited_allocator<int, 10> > > q;
+    typedef std::vector<int, limited_allocator<int, 10> > Container;
+    typedef std::priority_queue<int, Container> Q;
+    Q q;
     assert(q.size() == 0);
     q.push(1);
     q.push(2);
     assert(q.size() == 2);
     assert(q.top() == 2);
 
+#if TEST_STD_VER >= 11
+    // It should be explicit, so not convertible before C++20.
+    static_assert(test_convertible<Q>(), "");
+#endif
+
     return 0;
 }

libcxx/test/std/containers/container.adaptors/queue/queue.cons/ctor_container.pass.cpp

 
 // explicit queue(const container_type& c);
 
 #include <queue>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "test_convertible.h"
+#endif
 
 template <class C>
 C
 make(int n)
 {
     C c;
     for (int i = 0; i < n; ++i)
         c.push_back(i);
     return c;
 }
 
 int main(int, char**)
 {
-    std::deque<int> d = make<std::deque<int> >(5);
-    std::queue<int> q(d);
+    typedef std::deque<int> Container;
+    typedef std::queue<int> Q;
+    Container d = make<Container>(5);
+    Q q(d);
     assert(q.size() == 5);
     for (std::size_t i = 0; i < d.size(); ++i)
     {
         assert(q.front() == d[i]);
         q.pop();
     }
 
+#if TEST_STD_VER >= 11
+    static_assert(!test_convertible<Q, const Container&>(), "");
+#endif
+
     return 0;
 }

libcxx/test/std/containers/container.adaptors/queue/queue.cons/ctor_default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <queue>
 
-// queue();
+// explicit queue(Container&& = Container()); // before C++20
+// queue() : queue(Container()) {}            // C++20
+// explicit queue(Container&&);               // before C++20
 
 #include <queue>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
+#if TEST_STD_VER >= 11
+#include "test_convertible.h"
+#endif
 
 int main(int, char**)
 {
-    std::queue<int, std::vector<int, limited_allocator<int, 10> > > q;
+    typedef std::vector<int, limited_allocator<int, 10> > Container;
+    typedef std::queue<int, Container> Q;
+    Q q;
     assert(q.size() == 0);
     q.push(1);
     q.push(2);
     assert(q.size() == 2);
     assert(q.front() == 1);
     assert(q.back() == 2);
 
+#if TEST_STD_VER >= 11
+    // It should be explicit, so not convertible before C++20.
+    static_assert(test_convertible<Q>(), "");
+#endif
+
     return 0;
 }

libcxx/test/std/containers/container.adaptors/queue/queue.cons/ctor_rcontainer.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
 // <queue>
 
-// explicit queue(container_type&& c);
+// explicit queue(Container&& c = Container()); // before C++20
+// queue() : queue(Container()) {}              // C++20
+// explicit queue(Container&& c);               // C++20
 
 #include <queue>
 #include <cassert>
 
 #include "test_macros.h"
 #include "MoveOnly.h"
-
+#if TEST_STD_VER >= 11
+#include "test_convertible.h"
+#endif
 
 template <class C>
 C
 make(int n)
 {
     C c;
     for (int i = 0; i < n; ++i)
         c.push_back(MoveOnly(i));
     return c;
 }
 
-
 int main(int, char**)
 {
-    std::queue<MoveOnly> q(make<std::deque<MoveOnly> >(5));
+    typedef std::deque<MoveOnly> Container;
+    typedef std::queue<MoveOnly> Q;
+    Q q(make<std::deque<MoveOnly> >(5));
     assert(q.size() == 5);
 
+#if TEST_STD_VER >= 11
+    static_assert(!test_convertible<Q, Container&&>(), "");
+#endif
+
     return 0;
 }

libcxx/test/std/containers/container.adaptors/stack/stack.cons/ctor_container.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <stack>
 
-// explicit stack(const container_type& c);
+// explicit stack(const Container&);
 
 #include <stack>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "test_convertible.h"
+#endif
 
 template <class C>
 C
 make(int n)
 {
     C c;
     for (int i = 0; i < n; ++i)
         c.push_back(i);
     return c;
 }
 
 int main(int, char**)
 {
-    std::deque<int> d = make<std::deque<int> >(5);
-    std::stack<int> q(d);
+    typedef std::deque<int> Container;
+    typedef std::stack<int> Q;
+    Container d = make<Container>(5);
+    Q q(d);
     assert(q.size() == 5);
     for (std::size_t i = 0; i < d.size(); ++i)
     {
         assert(q.top() == d[d.size() - i - 1]);
         q.pop();
     }
 
+#if TEST_STD_VER >= 11
+    static_assert(!test_convertible<Q, const Container&>(), "");
+#endif
+
     return 0;
 }

libcxx/test/std/containers/container.adaptors/stack/stack.cons/ctor_default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <stack>
 
-// stack();
+// explicit stack(Container&& = Container()); // before C++20
+// stack() : stack(Container()) {}            // C++20
+// explicit stack(Container&&);               // before C++20
 
 #include <stack>
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
+#if TEST_STD_VER >= 11
+#include "test_convertible.h"
+#endif
 
 int main(int, char**)
 {
-    std::stack<int, std::vector<int, limited_allocator<int, 10> > > q;
+    typedef std::vector<int, limited_allocator<int, 10> > Container;
+    typedef std::stack<int, Container> Q;
+    Q q;
     assert(q.size() == 0);
     q.push(1);
     q.push(2);
     assert(q.size() == 2);
     assert(q.top() == 2);
 
+#if TEST_STD_VER >= 11
+    // It should be explicit, so not convertible before C++20.
+    static_assert(test_convertible<Q>(), "");
+#endif
+
     return 0;
 }

libcxx/test/std/containers/container.adaptors/stack/stack.cons/ctor_rcontainer.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
 // <stack>
 
-// explicit stack(container_type&& c);
+// explicit stack(Container&&= Container());  // before C++20
+// stack() : stack(Container()) {}            // C++20
+// explicit stack(Container&&);               // C++20
 
 #include <stack>
 #include <cassert>
 
 #include "test_macros.h"
 #include "MoveOnly.h"
-
+#if TEST_STD_VER >= 11
+#include "test_convertible.h"
+#endif
 
 template <class C>
 C
 make(int n)
 {
     C c;
     for (int i = 0; i < n; ++i)
         c.push_back(MoveOnly(i));
     return c;
 }
 
-
 int main(int, char**)
 {
-    std::stack<MoveOnly> q(make<std::deque<MoveOnly> >(5));
+    typedef std::deque<MoveOnly> Container;
+    typedef std::stack<MoveOnly> Q;
+    Q q(make<Container>(5));
     assert(q.size() == 5);
 
+#if TEST_STD_VER >= 11
+    static_assert(!test_convertible<Q, Container&&>(), "");
+#endif
+
   return 0;
 }

libcxx/test/std/depr/depr.str.strstreams/depr.strstreambuf/depr.strstreambuf.cons/default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <strstream>
 
 // class strstreambuf
 
-// explicit strstreambuf(streamsize alsize_arg = 0);
+// explicit strstreambuf(streamsize alsize_arg = 0); // before C++20
+// strstreambuf() : strstreambuf(0) {}               // C++20
+// explicit strstreambuf(streamsize alsize_arg);     // C++20
 
 #include <strstream>
 #include <cassert>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "test_convertible.h"
+#endif
 
 int main(int, char**)
 {
     {
         std::strstreambuf s;
         assert(s.str() == nullptr);
         assert(s.pcount() == 0);
     }
     {
         std::strstreambuf s(1024);
         LIBCPP_ASSERT(s.str() == nullptr);
         assert(s.pcount() == 0);
     }
 
+#if TEST_STD_VER >= 11
+    {
+      typedef std::strstreambuf B;
+      static_assert(test_convertible<B>(), "");
+      static_assert(!test_convertible<B, std::streamsize>(), "");
+    }
+#endif
+
     return 0;
 }

libcxx/test/std/input.output/string.streams/istringstream/istringstream.cons/default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <sstream>
 
 // template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
 // class basic_istringstream
 
-// explicit basic_istringstream(ios_base::openmode which = ios_base::in);
+// explicit basic_istringstream(ios_base::openmode which = ios_base::in); // before C++20
+// basic_istringstream() : basic_istringstream(ios_base::in) {}           // C++20
+// explicit basic_istringstream(ios_base::openmode which);                // C++20
 
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "test_convertible.h"
+
+template <typename S>
+void test() {
+  static_assert(test_convertible<S>(), "");
+  static_assert(!test_convertible<S, std::ios_base::openmode>(), "");
+}
+#endif
 
 int main(int, char**)
 {
     {
         std::istringstream ss;
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == "");
int main(int, char**)
     }
     {
         std::wistringstream ss(std::ios_base::in);
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == L"");
     }
 
+#if TEST_STD_VER >= 11
+    test<std::istringstream>();
+    test<std::wistringstream>();
+#endif
+
     return 0;
 }

libcxx/test/std/input.output/string.streams/ostringstream/ostringstream.cons/default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <sstream>
 
 // template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
 // class basic_ostringstream
 
-// explicit basic_ostringstream(ios_base::openmode which = ios_base::in);
+// explicit basic_ostringstream(ios_base::openmode which = ios_base::out); // before C++20
+// basic_ostringstream() : basic_ostringstream(ios_base::out) {}           // C++20
+// explicit basic_ostringstream(ios_base::openmode which);                 // C++20
 
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "test_convertible.h"
+
+template <typename S>
+void test() {
+  static_assert(test_convertible<S>(), "");
+  static_assert(!test_convertible<S, std::ios_base::openmode>(), "");
+}
+#endif
 
 int main(int, char**)
 {
     {
         std::ostringstream ss;
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == "");
int main(int, char**)
     }
     {
         std::wostringstream ss(std::ios_base::out);
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == L"");
     }
 
+#if TEST_STD_VER >= 11
+    test<std::ostringstream>();
+    test<std::wostringstream>();
+#endif
+
     return 0;
 }

libcxx/test/std/input.output/string.streams/stringbuf/stringbuf.cons/default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <sstream>
 
 // template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
 // class basic_stringbuf
 
-// explicit basic_stringbuf(ios_base::openmode which = ios_base::in | ios_base::out);
+// explicit basic_stringbuf(ios_base::openmode which = ios_base::in | ios_base::out); // before C++20
+// basic_stringbuf() : basic_stringbuf(ios_base::in | ios_base::out) {}               // C++20
+// explicit basic_stringbuf(ios_base::openmode which);                                // C++20
 
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "test_convertible.h"
+#endif
 
 template<typename CharT>
 struct testbuf
     : std::basic_stringbuf<CharT>
 {
     void check()
     {
         assert(this->eback() == NULL);
int main(int, char**)
         testbuf<char> buf;
         buf.check();
     }
     {
         testbuf<wchar_t> buf;
         buf.check();
     }
 
+#if TEST_STD_VER >= 11
+    {
+      typedef std::stringbuf B;
+      static_assert(test_convertible<B>(), "");
+      static_assert(!test_convertible<B, std::ios_base::openmode>(), "");
+    }
+#endif
+
     return 0;
 }

libcxx/test/std/input.output/string.streams/stringstream.cons/default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <sstream>
 
 // template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
 // class basic_stringstream
 
-// explicit basic_stringstream(ios_base::openmode which = ios_base::out|ios_base::in);
+// explicit basic_stringstream(ios_base::openmode which = ios_base::out | ios_base::in); // before C++20
+// basic_stringstream() : basic_stringstream(ios_base::out | ios_base::in) {}            // C++20
+// explicit basic_stringstream(ios_base::openmode which);                                // C++20
 
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "test_convertible.h"
+
+template <typename S>
+void test() {
+  static_assert(test_convertible<S>(), "");
+  static_assert(!test_convertible<S, std::ios_base::openmode>(), "");
+}
+#endif
 
 int main(int, char**)
 {
     {
         std::stringstream ss;
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == "");
int main(int, char**)
     }
     {
         std::wstringstream ss(std::ios_base::in);
         assert(ss.rdbuf() != 0);
         assert(ss.good());
         assert(ss.str() == L"");
     }
 
+#if TEST_STD_VER >= 11
+    test<std::stringstream>();
+    test<std::wstringstream>();
+#endif
+
     return 0;
 }

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/ctor.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // wbuffer_convert<Codecvt, Elem, Tr>
 
-// wbuffer_convert(streambuf *bytebuf = 0, Codecvt *pcvt = new Codecvt,
-//                 state_type state = state_type());
+// wbuffer_convert(streambuf* bytebuf = 0, Codecvt* pcvt = new Codecvt,
+//                 state_type state = state_type());          // before C++14
+// explicit wbuffer_convert(streambuf* bytebuf = nullptr, Codecvt* pcvt = new Codecvt,
+//                          state_type state = state_type()); // before C++20
+// wbuffer_convert() : wbuffer_convert(nullptr) {} // C++20
+// explicit wbuffer_convert(streambuf* bytebuf, Codecvt* pcvt = new Codecvt,
+//                          state_type state = state_type()); // C++20
 
 #include <locale>
 #include <codecvt>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 #include "count_new.h"
+#if TEST_STD_VER >= 11
+#include "test_convertible.h"
+#endif
 
 int main(int, char**)
 {
     globalMemCounter.reset();
     typedef std::wbuffer_convert<std::codecvt_utf8<wchar_t> > B;
 #if TEST_STD_VER > 11
     static_assert(!std::is_convertible<std::streambuf*, B>::value, "");
     static_assert( std::is_constructible<B, std::streambuf*>::value, "");
#endif
     {
         std::stringstream s;
         B b(s.rdbuf(), new std::codecvt_utf8<wchar_t>, std::mbstate_t());
         assert(b.rdbuf() == s.rdbuf());
         assert(globalMemCounter.checkOutstandingNewNotEq(0));
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
 
+#if TEST_STD_VER >= 11
+    {
+      static_assert(test_convertible<B>(), "");
+      static_assert(!test_convertible<B, std::streambuf*>(), "");
+    }
+#endif
+
     return 0;
 }

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.string/ctor_codecvt.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // wstring_convert<Codecvt, Elem, Wide_alloc, Byte_alloc>
 
-// wstring_convert(Codecvt* pcvt = new Codecvt);
+// wstring_convert(Codecvt* pcvt = new Codecvt);          // before C++14
+// explicit wstring_convert(Codecvt* pcvt = new Codecvt); // before C++20
+// wstring_convert() : wstring_convert(new Codecvt) {}    // C++20
+// explicit wstring_convert(Codecvt* pcvt);               // C++20
 
 #include <locale>
 #include <codecvt>
 #include <cassert>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "test_convertible.h"
+#endif
 
 int main(int, char**)
 {
     {
         typedef std::codecvt_utf8<wchar_t> Codecvt;
         typedef std::wstring_convert<Codecvt> Myconv;
         Myconv myconv;
         assert(myconv.converted() == 0);
     }
     {
         typedef std::codecvt_utf8<wchar_t> Codecvt;
         typedef std::wstring_convert<Codecvt> Myconv;
         Myconv myconv(new Codecvt);
         assert(myconv.converted() == 0);
 #if TEST_STD_VER > 11
         static_assert(!std::is_convertible<Codecvt*, Myconv>::value, "");
         static_assert( std::is_constructible<Myconv, Codecvt*>::value, "");
 #endif
     }
 
+#if TEST_STD_VER >= 11
+    {
+      typedef std::codecvt_utf8<wchar_t> Codecvt;
+      typedef std::wstring_convert<Codecvt> B;
+      static_assert(test_convertible<B>(), "");
+      static_assert(!test_convertible<B, Codecvt*>(), "");
+    }
+#endif
+
     return 0;
 }

libcxx/test/std/numerics/rand/rand.device/ctor.pass.cpp

 // XFAIL: with_system_cxx_lib=macosx10.9
 
 // UNSUPPORTED: libcpp-has-no-random-device
 
 // <random>
 
 // class random_device;
 
-// explicit random_device(const string& token = implementation-defined);
+// explicit random_device(const string& token = implementation-defined); // before C++20
+// random_device() : random_device(implementation-defined) {}            // C++20
+// explicit random_device(const string& token);                          // C++20
 
 // For the following ctors, the standard states: "The semantics and default
 // value of the token parameter are implementation-defined". Implementations
 // therefore aren't required to accept any string, but the default shouldn't
 // throw.
 
 #include <random>
 #include <system_error>
 #include <cassert>
 
 #if !defined(_WIN32)
 #include <unistd.h>
 #endif
 
 #include "test_macros.h"
-
+#if TEST_STD_VER >= 11
+#include "test_convertible.h"
+#endif
 
 bool is_valid_random_device(const std::string &token) {
 #if defined(_LIBCPP_USING_DEV_RANDOM)
   // Not an exhaustive list: they're the only tokens that are tested below.
   return token == "/dev/urandom" || token == "/dev/random";
 #else
   return token == "/dev/urandom";
 #endif
try {
     LIBCPP_ASSERT(false);
   } catch (const std::system_error&) {
   }
 #else
   ((void)token);
 #endif
 }
 
-
 int main(int, char**) {
   {
     std::random_device r;
   }
   {
     std::string token = "wrong file";
     check_random_device_invalid(token);
   }
// streams so that the descriptor '0' is available.
     ec = close(STDOUT_FILENO);
     assert(!ec);
     ec = close(STDERR_FILENO);
     assert(!ec);
     std::random_device r;
   }
 #endif // !defined(_WIN32)
 
+#if TEST_STD_VER >= 11
+  static_assert(test_convertible<std::random_device>(), "");
+#endif
+
   return 0;
 }

libcxx/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/ctor_double.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // class bernoulli_distribution
 
-// explicit bernoulli_distribution(double p = 0.5);
+// explicit bernoulli_distribution(double p = 0.5);          // before C++20
+// bernoulli_distribution() : bernoulli_distribution(0.5) {} // C++20
+// explicit bernoulli_distribution(double p);                // C++20
 
 #include <random>
 #include <cassert>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "make_implicit.h"
+#include "test_convertible.h"
+#endif
 
 int main(int, char**)
 {
     {
         typedef std::bernoulli_distribution D;
         D d;
         assert(d.p() == 0.5);
     }
     {
         typedef std::bernoulli_distribution D;
         D d(0);
         assert(d.p() == 0);
     }
     {
         typedef std::bernoulli_distribution D;
         D d(0.75);
         assert(d.p() == 0.75);
     }
 
+#if TEST_STD_VER >= 11
+    {
+      typedef std::bernoulli_distribution D;
+      static_assert(test_convertible<D>(), "");
+      assert(D(0.5) == make_implicit<D>());
+      static_assert(!test_convertible<D, double>(), "");
+    }
+#endif
+
     return 0;
 }

libcxx/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/ctor_int_double.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class IntType = int>
 // class binomial_distribution
 
-// explicit binomial_distribution(IntType t = 1, double p = 0.5);
+// explicit binomial_distribution(IntType t = 1, double p = 0.5); // before C++20
+// binomial_distribution() : binomial_distribution(1) {}          // C++20
+// explicit binomial_distribution(IntType t, double p = 0.5);     // C++20
 
 #include <random>
 #include <cassert>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "make_implicit.h"
+#include "test_convertible.h"
+#endif
+
+template <class T>
+void test_implicit() {
+#if TEST_STD_VER >= 11
+  typedef std::binomial_distribution<T> D;
+  static_assert(test_convertible<D>(), "");
+  assert(D(1) == make_implicit<D>());
+  static_assert(!test_convertible<D, T>(), "");
+  static_assert(!test_convertible<D, T, double>(), "");
+#endif
+}
 
 int main(int, char**)
 {
     {
         typedef std::binomial_distribution<> D;
         D d;
         assert(d.t() == 1);
         assert(d.p() == 0.5);
     }
     {
         typedef std::binomial_distribution<> D;
         D d(3);
         assert(d.t() == 3);
         assert(d.p() == 0.5);
     }
     {
         typedef std::binomial_distribution<> D;
         D d(3, 0.75);
         assert(d.t() == 3);
         assert(d.p() == 0.75);
     }
 
+    test_implicit<int>();
+    test_implicit<long>();
+
     return 0;
 }

libcxx/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/ctor_double.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class IntType = int>
 // class geometric_distribution
 
-// explicit geometric_distribution(double p = 0.5);
+// explicit geometric_distribution(double p = 0.5);          // before C++20
+// geometric_distribution() : geometric_distribution(0.5) {} // C++20
+// explicit geometric_distribution(double p);                // C++20
 
 #include <random>
 #include <cassert>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "make_implicit.h"
+#include "test_convertible.h"
+#endif
+
+template <class T>
+void test_implicit() {
+#if TEST_STD_VER >= 11
+  typedef std::geometric_distribution<T> D;
+  static_assert(test_convertible<D>(), "");
+  assert(D(0.5) == make_implicit<D>());
+  static_assert(!test_convertible<D, double>(), "");
+#endif
+}
 
 int main(int, char**)
 {
     {
         typedef std::geometric_distribution<> D;
         D d;
         assert(d.p() == 0.5);
     }
     {
         typedef std::geometric_distribution<> D;
         D d(0.75);
         assert(d.p() == 0.75);
     }
 
+    test_implicit<int>();
+    test_implicit<long>();
+
     return 0;
 }

libcxx/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/ctor_int_double.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class IntType = int>
 // class negative_binomial_distribution
 
-// explicit negative_binomial_distribution(IntType t = 1, double p = 0.5);
+// explicit negative_binomial_distribution(IntType k = 1, double p = 0.5); // before C++20
+// negative_binomial_distribution() : negative_binomial_distribution(1) {} // C++20
+// explicit negative_binomial_distribution(IntType k, double p = 0.5);     // C++20
 
 #include <random>
 #include <cassert>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "make_implicit.h"
+#include "test_convertible.h"
+#endif
+
+template <class T>
+void test_implicit() {
+#if TEST_STD_VER >= 11
+  typedef std::negative_binomial_distribution<T> D;
+  static_assert(test_convertible<D>(), "");
+  assert(D(1) == make_implicit<D>());
+  static_assert(!test_convertible<D, T>(), "");
+  static_assert(!test_convertible<D, T, double>(), "");
+#endif
+}
 
 int main(int, char**)
 {
     {
         typedef std::negative_binomial_distribution<> D;
         D d;
         assert(d.k() == 1);
         assert(d.p() == 0.5);
     }
     {
         typedef std::negative_binomial_distribution<> D;
         D d(3);
         assert(d.k() == 3);
         assert(d.p() == 0.5);
     }
     {
         typedef std::negative_binomial_distribution<> D;
         D d(3, 0.75);
         assert(d.k() == 3);
         assert(d.p() == 0.75);
     }
 
+    test_implicit<int>();
+    test_implicit<long>();
+
     return 0;
 }

libcxx/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/ctor_double_double.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class cauchy_distribution
 
-// explicit cauchy_distribution(result_type a = 0, result_type b = 1);
+// explicit cauchy_distribution(RealType a = 0.0, RealType b = 1.0); // before C++20
+// cauchy_distribution() : cauchy_distribution(0.0) {}               // C++20
+// explicit cauchy_distribution(RealType a, RealType b = 1.0);       // C++20
 
 #include <random>
 #include <cassert>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "make_implicit.h"
+#include "test_convertible.h"
+#endif
+
+template <class T>
+void test_implicit() {
+#if TEST_STD_VER >= 11
+  typedef std::cauchy_distribution<T> D;
+  static_assert(test_convertible<D>(), "");
+  assert(D(0) == make_implicit<D>());
+  static_assert(!test_convertible<D, T>(), "");
+  static_assert(!test_convertible<D, T, T>(), "");
+#endif
+}
 
 int main(int, char**)
 {
     {
         typedef std::cauchy_distribution<> D;
         D d;
         assert(d.a() == 0);
         assert(d.b() == 1);
     }
     {
         typedef std::cauchy_distribution<> D;
         D d(14.5);
         assert(d.a() == 14.5);
         assert(d.b() == 1);
     }
     {
         typedef std::cauchy_distribution<> D;
         D d(14.5, 5.25);
         assert(d.a() == 14.5);
         assert(d.b() == 5.25);
     }
 
+    test_implicit<float>();
+    test_implicit<double>();
+
     return 0;
 }

libcxx/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/ctor_double.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class chi_squared_distribution
 
-// explicit chi_squared_distribution(result_type alpha = 0, result_type beta = 1);
+// explicit chi_squared_distribution(RealType n = 1.0);          // before C++20
+// chi_squared_distribution() : chi_squared_distribution(1.0) {} // C++20
+// explicit chi_squared_distribution(RealType n);                // C++20
 
 #include <random>
 #include <cassert>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "make_implicit.h"
+#include "test_convertible.h"
+#endif
+
+template <class T>
+void test_implicit() {
+#if TEST_STD_VER >= 11
+  typedef std::chi_squared_distribution<T> D;
+  static_assert(test_convertible<D>(), "");
+  assert(D(1) == make_implicit<D>());
+  static_assert(!test_convertible<D, T>(), "");
+#endif
+}
 
 int main(int, char**)
 {
     {
         typedef std::chi_squared_distribution<> D;
         D d;
         assert(d.n() == 1);
     }
     {
         typedef std::chi_squared_distribution<> D;
         D d(14.5);
         assert(d.n() == 14.5);
     }
 
+    test_implicit<float>();
+    test_implicit<double>();
+
     return 0;
 }

libcxx/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/ctor_double_double.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class fisher_f_distribution
 
-// explicit fisher_f_distribution(result_type alpha = 0, result_type beta = 1);
+// explicit fisher_f_distribution(RealType m = 1.0, RealType n = 1.0); // before C++20
+// fisher_f_distribution() : fisher_f_distribution(1.0) {}             // C++20
+// explicit fisher_f_distribution(RealType m, RealType n = 1.0);       // C++20
 
 #include <random>
 #include <cassert>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "make_implicit.h"
+#include "test_convertible.h"
+#endif
+
+template <class T>
+void test_implicit() {
+#if TEST_STD_VER >= 11
+  typedef std::fisher_f_distribution<T> D;
+  static_assert(test_convertible<D>(), "");
+  assert(D(1) == make_implicit<D>());
+  static_assert(!test_convertible<D, T>(), "");
+  static_assert(!test_convertible<D, T, T>(), "");
+#endif
+}
 
 int main(int, char**)
 {
     {
         typedef std::fisher_f_distribution<> D;
         D d;
         assert(d.m() == 1);
         assert(d.n() == 1);
     }
     {
         typedef std::fisher_f_distribution<> D;
         D d(14.5);
         assert(d.m() == 14.5);
         assert(d.n() == 1);
     }
     {
         typedef std::fisher_f_distribution<> D;
         D d(14.5, 5.25);
         assert(d.m() == 14.5);
         assert(d.n() == 5.25);
     }
 
+    test_implicit<float>();
+    test_implicit<double>();
+
     return 0;
 }

libcxx/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/ctor_double_double.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class lognormal_distribution
 
-// explicit lognormal_distribution(result_type mean = 0, result_type stddev = 1);
+// explicit lognormal_distribution(RealType mean = 0.0, RealType stddev = 1.0); // before C++20
+// lognormal_distribution() : lognormal_distribution(0.0) {}                    // C++20
+// explicit lognormal_distribution(RealType mean, RealType stddev = 1.0);       // C++20
 
 #include <random>
 #include <cassert>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "make_implicit.h"
+#include "test_convertible.h"
+#endif
+
+template <class T>
+void test_implicit() {
+#if TEST_STD_VER >= 11
+  typedef std::lognormal_distribution<T> D;
+  static_assert(test_convertible<D>(), "");
+  assert(D(0) == make_implicit<D>());
+  static_assert(!test_convertible<D, T>(), "");
+  static_assert(!test_convertible<D, T, T>(), "");
+#endif
+}
 
 int main(int, char**)
 {
     {
         typedef std::lognormal_distribution<> D;
         D d;
         assert(d.m() == 0);
         assert(d.s() == 1);
     }
     {
         typedef std::lognormal_distribution<> D;
         D d(14.5);
         assert(d.m() == 14.5);
         assert(d.s() == 1);
     }
     {
         typedef std::lognormal_distribution<> D;
         D d(14.5, 5.25);
         assert(d.m() == 14.5);
         assert(d.s() == 5.25);
     }
 
+    test_implicit<float>();
+    test_implicit<double>();
+
     return 0;
 }

libcxx/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/ctor_double_double.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class normal_distribution
 
-// explicit normal_distribution(result_type mean = 0, result_type stddev = 1);
+// explicit normal_distribution(RealType mean = 0.0, RealType stddev = 1.0); // before C++20
+// normal_distribution() : normal_distribution(0.0) {}                       // C++20
+// explicit normal_distribution(RealType mean, RealType stddev = 1.0);       // C++20
 
 #include <random>
 #include <cassert>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "make_implicit.h"
+#include "test_convertible.h"
+#endif
+
+template <class T>
+void test_implicit() {
+#if TEST_STD_VER >= 11
+  typedef std::normal_distribution<T> D;
+  static_assert(test_convertible<D>(), "");
+  assert(D(0) == make_implicit<D>());
+  static_assert(!test_convertible<D, T>(), "");
+  static_assert(!test_convertible<D, T, T>(), "");
+#endif
+}
 
 int main(int, char**)
 {
     {
         typedef std::normal_distribution<> D;
         D d;
         assert(d.mean() == 0);
         assert(d.stddev() == 1);
     }
     {
         typedef std::normal_distribution<> D;
         D d(14.5);
         assert(d.mean() == 14.5);
         assert(d.stddev() == 1);
     }
     {
         typedef std::normal_distribution<> D;
         D d(14.5, 5.25);
         assert(d.mean() == 14.5);
         assert(d.stddev() == 5.25);
     }
 
+    test_implicit<float>();
+    test_implicit<double>();
+
     return 0;
 }

libcxx/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/ctor_double.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class student_t_distribution
 
-// explicit student_t_distribution(result_type alpha = 0, result_type beta = 1);
+// explicit student_t_distribution(RealType n = 1.0);        // before C++20
+// student_t_distribution() : student_t_distribution(1.0) {} // C++20
+// explicit student_t_distribution(RealType n);              // C++20
 
 #include <random>
 #include <cassert>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "make_implicit.h"
+#include "test_convertible.h"
+#endif
+
+template <class T>
+void test_implicit() {
+#if TEST_STD_VER >= 11
+  typedef std::student_t_distribution<T> D;
+  static_assert(test_convertible<D>(), "");
+  assert(D(1) == make_implicit<D>());
+  static_assert(!test_convertible<D, T>(), "");
+#endif
+}
 
 int main(int, char**)
 {
     {
         typedef std::student_t_distribution<> D;
         D d;
         assert(d.n() == 1);
     }
     {
         typedef std::student_t_distribution<> D;
         D d(14.5);
         assert(d.n() == 14.5);
     }
 
+    test_implicit<float>();
+    test_implicit<double>();
+
     return 0;
 }

libcxx/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/ctor_double.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class exponential_distribution
 
-// explicit exponential_distribution(RealType lambda = 1.0);
+// explicit exponential_distribution(RealType lambda = 1.0);     // before C++20
+// exponential_distribution() : exponential_distribution(1.0) {} // C++20
+// explicit exponential_distribution(RealType lambda);           // C++20
 
 #include <random>
 #include <cassert>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "make_implicit.h"
+#include "test_convertible.h"
+#endif
+
+template <class T>
+void test_implicit() {
+#if TEST_STD_VER >= 11
+  typedef std::exponential_distribution<T> D;
+  static_assert(test_convertible<D>(), "");
+  assert(D(1) == make_implicit<D>());
+  static_assert(!test_convertible<D, T>(), "");
+#endif
+}
 
 int main(int, char**)
 {
     {
         typedef std::exponential_distribution<> D;
         D d;
         assert(d.lambda() == 1);
     }
     {
         typedef std::exponential_distribution<> D;
         D d(3.5);
         assert(d.lambda() == 3.5);
     }
 
+    test_implicit<float>();
+    test_implicit<double>();
+
     return 0;
 }

libcxx/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/ctor_double_double.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class extreme_value_distribution
 
-// explicit extreme_value_distribution(result_type a = 0, result_type b = 1);
+// explicit extreme_value_distribution(RealType a = 0.0, RealType b = 1.0); // before C++20
+// extreme_value_distribution() : extreme_value_distribution(0.0) {}        // C++20
+// explicit extreme_value_distribution(RealType a, RealType b = 1.0);       // C++20
 
 #include <random>
 #include <cassert>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "make_implicit.h"
+#include "test_convertible.h"
+#endif
+
+template <class T>
+void test_implicit() {
+#if TEST_STD_VER >= 11
+  typedef std::extreme_value_distribution<T> D;
+  static_assert(test_convertible<D>(), "");
+  assert(D(0) == make_implicit<D>());
+  static_assert(!test_convertible<D, T>(), "");
+  static_assert(!test_convertible<D, T, T>(), "");
+#endif
+}
 
 int main(int, char**)
 {
     {
         typedef std::extreme_value_distribution<> D;
         D d;
         assert(d.a() == 0);
         assert(d.b() == 1);
     }
     {
         typedef std::extreme_value_distribution<> D;
         D d(14.5);
         assert(d.a() == 14.5);
         assert(d.b() == 1);
     }
     {
         typedef std::extreme_value_distribution<> D;
         D d(14.5, 5.25);
         assert(d.a() == 14.5);
         assert(d.b() == 5.25);
     }
 
+    test_implicit<float>();
+    test_implicit<double>();
+
     return 0;
 }

libcxx/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/ctor_double_double.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class gamma_distribution
 
-// explicit gamma_distribution(result_type alpha = 0, result_type beta = 1);
+// explicit gamma_distribution(RealType alpha = 1.0, RealType beta = 1.0); // before C++20
+// gamma_distribution() : gamma_distribution(1.0) {}                       // C++20
+// explicit gamma_distribution(RealType alpha, RealType beta = 1.0);       // C++20
 
 #include <random>
 #include <cassert>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "make_implicit.h"
+#include "test_convertible.h"
+#endif
+
+template <class T>
+void test_implicit() {
+#if TEST_STD_VER >= 11
+  typedef std::gamma_distribution<T> D;
+  static_assert(test_convertible<D>(), "");
+  assert(D(1) == make_implicit<D>());
+  static_assert(!test_convertible<D, T>(), "");
+  static_assert(!test_convertible<D, T, T>(), "");
+#endif
+}
 
 int main(int, char**)
 {
     {
         typedef std::gamma_distribution<> D;
         D d;
         assert(d.alpha() == 1);
         assert(d.beta() == 1);
     }
     {
         typedef std::gamma_distribution<> D;
         D d(14.5);
         assert(d.alpha() == 14.5);
         assert(d.beta() == 1);
     }
     {
         typedef std::gamma_distribution<> D;
         D d(14.5, 5.25);
         assert(d.alpha() == 14.5);
         assert(d.beta() == 5.25);
     }
 
+    test_implicit<float>();
+    test_implicit<double>();
+
     return 0;
 }

libcxx/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/ctor_double.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class IntType = int>
 // class poisson_distribution
 
-// explicit poisson_distribution(RealType lambda = 1.0);
+// explicit poisson_distribution(double mean = 1.0);     // before C++20
+// poisson_distribution() : poisson_distribution(1.0) {} // C++20
+// explicit poisson_distribution(double mean);           // C++20
 
 #include <random>
 #include <cassert>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "make_implicit.h"
+#include "test_convertible.h"
+#endif
+
+template <class T>
+void test_implicit() {
+#if TEST_STD_VER >= 11
+  typedef std::poisson_distribution<T> D;
+  static_assert(test_convertible<D>(), "");
+  assert(D(1) == make_implicit<D>());
+  static_assert(!test_convertible<D, double>(), "");
+#endif
+}
 
 int main(int, char**)
 {
     {
         typedef std::poisson_distribution<> D;
         D d;
         assert(d.mean() == 1);
     }
     {
         typedef std::poisson_distribution<> D;
         D d(3.5);
         assert(d.mean() == 3.5);
     }
 
+    test_implicit<int>();
+    test_implicit<long>();
+
     return 0;
 }

libcxx/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/ctor_double_double.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class RealType = double>
 // class weibull_distribution
 
-// explicit weibull_distribution(result_type a = 0, result_type b = 1);
+// explicit weibull_distribution(RealType a = 1.0, RealType b = 1.0); // before C++20
+// weibull_distribution() : weibull_distribution(1.0) {}              // C++20
+// explicit weibull_distribution(RealType a, RealType b = 1.0);       // C++20
 
 #include <random>
 #include <cassert>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "make_implicit.h"
+#include "test_convertible.h"
+#endif
+
+template <class T>
+void test_implicit() {
+#if TEST_STD_VER >= 11
+  typedef std::weibull_distribution<T> D;
+  static_assert(test_convertible<D>(), "");
+  assert(D(1) == make_implicit<D>());
+  static_assert(!test_convertible<D, T>(), "");
+  static_assert(!test_convertible<D, T, T>(), "");
+#endif
+}
 
 int main(int, char**)
 {
     {
         typedef std::weibull_distribution<> D;
         D d;
         assert(d.a() == 1);
         assert(d.b() == 1);
     }
     {
         typedef std::weibull_distribution<> D;
         D d(14.5);
         assert(d.a() == 14.5);
         assert(d.b() == 1);
     }
     {
         typedef std::weibull_distribution<> D;
         D d(14.5, 5.25);
         assert(d.a() == 14.5);
         assert(d.b() == 5.25);
     }
 
+    test_implicit<float>();
+    test_implicit<double>();
+
     return 0;
 }

libcxx/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/ctor_int_int.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class _IntType = int>
 // class uniform_int_distribution
 
 // explicit uniform_int_distribution(IntType a = 0,
-//                                   IntType b = numeric_limits<IntType>::max());
+//                                   IntType b = numeric_limits<IntType>::max()); // before C++20
+// uniform_int_distribution() : uniform_int_distribution(0) {}                    // C++20
+// explicit uniform_int_distribution(IntType a,
+//                                   IntType b = numeric_limits<IntType>::max()); // C++20
 
 #include <random>
 #include <cassert>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "make_implicit.h"
+#include "test_convertible.h"
+#endif
+
+template <class T>
+void test_implicit() {
+#if TEST_STD_VER >= 11
+  typedef std::uniform_int_distribution<> D;
+  static_assert(test_convertible<D>(), "");
+  assert(D(0) == make_implicit<D>());
+  static_assert(!test_convertible<D, T>(), "");
+  static_assert(!test_convertible<D, T, T>(), "");
+#endif
+}
 
 int main(int, char**)
 {
     {
         typedef std::uniform_int_distribution<> D;
         D d;
         assert(d.a() == 0);
         assert(d.b() == std::numeric_limits<int>::max());
     }
     {
         typedef std::uniform_int_distribution<> D;
         D d(-6);
         assert(d.a() == -6);
         assert(d.b() == std::numeric_limits<int>::max());
     }
     {
         typedef std::uniform_int_distribution<> D;
         D d(-6, 106);
         assert(d.a() == -6);
         assert(d.b() == 106);
     }
 
+    test_implicit<int>();
+    test_implicit<long>();
+
     return 0;
 }

libcxx/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/ctor_int_int.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// <random>
-
-// template<class RealType = double>
-// class uniform_real_distribution
-
-// explicit uniform_real_distribution(RealType a = 0,
-//                                    RealType b = 1);
-
-#include <random>
-#include <cassert>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    {
-        typedef std::uniform_real_distribution<> D;
-        D d;
-        assert(d.a() == 0);
-        assert(d.b() == 1);
-    }
-    {
-        typedef std::uniform_real_distribution<> D;
-        D d(-6);
-        assert(d.a() == -6);
-        assert(d.b() == 1);
-    }
-    {
-        typedef std::uniform_real_distribution<> D;
-        D d(-6, 106);
-        assert(d.a() == -6);
-        assert(d.b() == 106);
-    }
-
-  return 0;
-}

libcxx/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/ctor_real_real.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <random>
+
+// template<class RealType = double>
+// class uniform_real_distribution
+
+// explicit uniform_real_distribution(RealType a = 0.0,
+//                                    RealType b = 1.0);             // before C++20
+// uniform_real_distribution() : uniform_real_distribution(0.0) {}   // C++20
+// explicit uniform_real_distribution(RealType a, RealType b = 1.0); // C++20
+
+#include <random>
+#include <cassert>
+
+#include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "make_implicit.h"
+#include "test_convertible.h"
+#endif
+
+template <class T>
+void test_implicit() {
+#if TEST_STD_VER >= 11
+  typedef std::uniform_real_distribution<T> D;
+  static_assert(test_convertible<D>(), "");
+  assert(D(0) == make_implicit<D>());
+  static_assert(!test_convertible<D, T>(), "");
+  static_assert(!test_convertible<D, T, T>(), "");
+#endif
+}
+
+int main(int, char**)
+{
+    {
+        typedef std::uniform_real_distribution<> D;
+        D d;
+        assert(d.a() == 0.0);
+        assert(d.b() == 1.0);
+    }
+    {
+        typedef std::uniform_real_distribution<> D;
+        D d(-6.5);
+        assert(d.a() == -6.5);
+        assert(d.b() == 1.0);
+    }
+    {
+        typedef std::uniform_real_distribution<> D;
+        D d(-6.9, 106.1);
+        assert(d.a() == -6.9);
+        assert(d.b() == 106.1);
+    }
+
+    test_implicit<float>();
+    test_implicit<double>();
+
+    return 0;
+}

libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_result_type.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template <class UIntType, UIntType a, UIntType c, UIntType m>
 //   class linear_congruential_engine;
 
-// explicit linear_congruential_engine(result_type s = default_seed);
+// explicit linear_congruential_engine(result_type s = default_seed);         // before C++20
+// linear_congruential_engine() : linear_congruential_engine(default_seed) {} // C++20
+// explicit linear_congruential_engine(result_type s);                        // C++20
 
 // Serializing/deserializing the state of the RNG requires iostreams
 // UNSUPPORTED: libcpp-has-no-localization
 
 #include <random>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "make_implicit.h"
+#include "test_convertible.h"
+#endif
+
+template <class T>
+std::string to_string(T const& e) {
+  std::ostringstream os;
+  os << e;
+  return os.str();
+}
 
 template <class T>
 void
 test1()
 {
     // c % m != 0 && s % m != 0
     {
         typedef std::linear_congruential_engine<T, 2, 3, 7> E;
         E e(5);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "5");
+        assert(to_string(e) == "5");
     }
     {
         typedef std::linear_congruential_engine<T, 2, 3, 0> E;
         E e(5);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "5");
+        assert(to_string(e) == "5");
     }
     {
         typedef std::linear_congruential_engine<T, 2, 3, 4> E;
         E e(5);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "1");
+        assert(to_string(e) == "1");
     }
 }
 
 template <class T>
 void
 test2()
 {
     // c % m != 0 && s % m == 0
     {
         typedef std::linear_congruential_engine<T, 2, 3, 7> E;
         E e(7);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "0");
+        assert(to_string(e) == "0");
     }
     {
         typedef std::linear_congruential_engine<T, 2, 3, 0> E;
         E e(0);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "0");
+        assert(to_string(e) == "0");
     }
     {
         typedef std::linear_congruential_engine<T, 2, 3, 4> E;
         E e(4);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "0");
+        assert(to_string(e) == "0");
     }
 }
 
 template <class T>
 void
 test3()
 {
     // c % m == 0 && s % m != 0
     {
         typedef std::linear_congruential_engine<T, 2, 0, 7> E;
         E e(3);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "3");
+        assert(to_string(e) == "3");
     }
     {
         typedef std::linear_congruential_engine<T, 2, 0, 0> E;
         E e(5);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "5");
+        assert(to_string(e) == "5");
     }
     {
         typedef std::linear_congruential_engine<T, 2, 0, 4> E;
         E e(7);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "3");
+        assert(to_string(e) == "3");
     }
 }
 
 template <class T>
 void
 test4()
 {
     // c % m == 0 && s % m == 0
     {
         typedef std::linear_congruential_engine<T, 2, 0, 7> E;
         E e(7);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "1");
+        assert(to_string(e) == "1");
     }
     {
         typedef std::linear_congruential_engine<T, 2, 0, 0> E;
         E e(0);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "1");
+        assert(to_string(e) == "1");
     }
     {
         typedef std::linear_congruential_engine<T, 2, 0, 4> E;
         E e(8);
-        std::ostringstream os;
-        os << e;
-        assert(os.str() == "1");
-    }
+        assert(to_string(e) == "1");
+    }
+
+template <class T>
+void test_implicit() {
+#if TEST_STD_VER >= 11
+  typedef std::linear_congruential_engine<T, 2, 0, 7> E;
+  static_assert(test_convertible<E>(), "");
+  assert(E(E::default_seed) == make_implicit<E>());
+  static_assert(!test_convertible<E, T>(), "");
+#endif
 }
 
 int main(int, char**)
 {
     test1<unsigned short>();
     test1<unsigned int>();
     test1<unsigned long>();
     test1<unsigned long long>();
 
     test2<unsigned short>();
     test2<unsigned int>();
     test2<unsigned long>();
     test2<unsigned long long>();
 
     test3<unsigned short>();
     test3<unsigned int>();
     test3<unsigned long>();
     test3<unsigned long long>();
 
     test4<unsigned short>();
     test4<unsigned int>();
     test4<unsigned long>();
     test4<unsigned long long>();
 
+    test_implicit<unsigned short>();
+
     return 0;
 }

libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template <class UIntType, size_t w, size_t n, size_t m, size_t r,
 //           UIntType a, size_t u, UIntType d, size_t s,
 //           UIntType b, size_t t, UIntType c, size_t l, UIntType f>
 // class mersenne_twister_engine;
 
-// explicit mersenne_twister_engine(result_type s = default_seed);
+// explicit mersenne_twister_engine(result_type s = default_seed);      // before C++20
+// mersenne_twister_engine() : mersenne_twister_engine(default_seed) {} // C++20
+// explicit mersenne_twister_engine(result_type s);                     // C++20
 
 // Serializing/deserializing the state of the RNG requires iostreams
 // UNSUPPORTED: libcpp-has-no-localization
 
 #include <random>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "make_implicit.h"
+#include "test_convertible.h"
+#endif
+
+template <class T>
+std::string
+to_string(T const &e)
+{
+    std::ostringstream os;
+    os << e;
+    return os.str();
+}
 
 void
 test1()
 {
     const char* a = "0 1 1812433255 1900727105 1208447044 2481403966 4042607538 337614300 "
     "3232553940 1018809052 3202401494 1775180719 3192392114 594215549 184016991 "
     "829906058 610491522 3879932251 3139825610 297902587 4075895579 2943625357 "
     "3530655617 1423771745 2135928312 2891506774 1066338622 135451537 933040465 "
test1()
     "1708182873 2796363264 292154131 4280019913 1102652157 1185393592 "
     "1494991690 4270076389 2384840717 425785147 2385321880 317514772 3926962743 "
     "392176856 3465421709 1878853468 122662664 2958252160 1858961315 2244939588 "
     "2361884409 2860936803 683833250 3291277128 1686857206 1112632275 "
     "1200680507 3342928196 2677058150 939442136 3407104669 2906783932 "
     "3668048733 2030009470 1910839172 1234925283 3575831445 123595418 "
     "2362440495 3048484911 1796872496";
     std::mt19937 e1(0);
-    std::ostringstream os;
-    os << e1;
-    assert(os.str() == a);
+    assert(to_string(e1) == a);
 }
 
 void
 test2()
 {
     const char* a = "0 1 6364136223846793007 13885033948157127961 "
     "15324573939901584278 12737837167382305846 15195339788985155882 "
     "6554113247712070460 17235932740818599105 13007415075556305955 "
test2()
     "6533591052147596041 1308401457054431629 17488144120120152559 "
     "14075631579093810083 4015705597302725704 6833920126528811473 "
     "5095302940809114298 8312250184258072842 15770605014574863643 "
     "14091690436120485477 15763282477731738396 16394237160547425954 "
     "5066318118328746621 13140493775100916989 6371148952471982853 "
     "15150289760867914983 4931341382074091848 12635920082410445322 "
     "8498109357807439006 14836776625250834986";
     std::mt19937_64 e1(0);
-    std::ostringstream os;
-    os << e1;
-    assert(os.str() == a);
+    assert(to_string(e1) == a);
+}
+
+template <class E, typename Arg>
+void test_implicit() {
+#if TEST_STD_VER >= 11
+  static_assert(test_convertible<E>(), "");
+  assert(E(E::default_seed) == make_implicit<E>());
+  static_assert(!test_convertible<E, Arg>(), "");
+#endif
 }
 
 int main(int, char**)
 {
     test1();
     test2();
 
+    test_implicit<std::mt19937, uint_fast32_t>();
+    test_implicit<std::mt19937_64, uint_fast64_t>();
+
     return 0;
 }

libcxx/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_result_type.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class UIntType, size_t w, size_t s, size_t r>
 // class subtract_with_carry_engine;
 
-// explicit subtract_with_carry_engine(result_type s = default_seed);
+// explicit subtract_with_carry_engine(result_type s = default_seed);         // before C++20
+// subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {} // C++20
+// explicit subtract_with_carry_engine(result_type s);                        // C++20
 
 // Serializing/deserializing the state of the RNG requires iostreams
 // UNSUPPORTED: libcpp-has-no-localization
 
 #include <random>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "make_implicit.h"
+#include "test_convertible.h"
+#endif
+
+template <class T>
+std::string
+to_string(T const &e)
+{
+    std::ostringstream os;
+    os << e;
+    return os.str();
+}
 
 void
 test1()
 {
     const char* a = "15136306 8587749 2346244 16479026 15515802 9510553 "
     "16090340 14501685 13839944 10789678 11581259 9590790 5840316 5953700 "
     "13398366 8134459 16629731 6851902 15583892 1317475 4231148 9092691 "
     "5707268 2355175 0";
     std::ranlux24_base e1(0);
-    std::ostringstream os;
-    os << e1;
-    assert(os.str() == a);
+    assert(to_string(e1) == a);
 }
 
 void
 test2()
 {
     const char* a = "10880375256626 126660097854724 33643165434010 "
     "78293780235492 179418984296008 96783156950859 238199764491708 "
     "34339434557790 155299155394531 29014415493780 209265474179052 "
     "263777435457028 0";
     std::ranlux48_base e1(0);
-    std::ostringstream os;
-    os << e1;
-    assert(os.str() == a);
+    assert(to_string(e1) == a);
+}
+
+#if TEST_STD_VER >= 11
+template <class E>
+void test_implicit_ctor() {
+  assert(E(E::default_seed) == make_implicit<E>());
 }
+#endif
 
 int main(int, char**)
 {
     test1();
     test2();
 
+#if TEST_STD_VER >= 11
+    static_assert(test_convertible<std::ranlux24_base>(), "");
+    static_assert(test_convertible<std::ranlux48_base>(), "");
+    test_implicit_ctor<std::ranlux24_base>();
+    test_implicit_ctor<std::ranlux48_base>();
+    static_assert(!test_convertible<std::ranlux24_base, uint_fast32_t>(), "");
+    static_assert(!test_convertible<std::ranlux48_base, uint_fast64_t>(), "");
+#endif
+
   return 0;
 }

libcxx/test/std/re/re.results/re.results.const/default.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <regex>
 
 // class match_results<BidirectionalIterator, Allocator>
 
-// match_results(const Allocator& a = Allocator());
+// explicit match_results(const Allocator& a = Allocator()); // before C++20
+// match_results() : match_results(Allocator()) {}           // C++20
+// explicit match_results(const Allocator& a);               // C++20
 
 #include <regex>
 #include <cassert>
 #include "test_macros.h"
+#if TEST_STD_VER >= 11
+#include "test_convertible.h"
+
+template <typename T>
+void test_implicit() {
+  static_assert(test_convertible<T>(), "");
+  static_assert(!test_convertible<T, typename T::allocator_type>(), "");
+}
+#endif
 
 template <class CharT>
 void
 test()
 {
-    std::match_results<const CharT*> m;
+    typedef std::match_results<const CharT*> M;
+    typedef std::allocator<std::sub_match<const CharT*> > Alloc;
+    M m;
     assert(m.size() == 0);
     assert(!m.ready());
-    assert(m.get_allocator() == std::allocator<std::sub_match<const CharT*> >());
+    assert(m.get_allocator() == Alloc());
+
+#if TEST_STD_VER >= 11
+    test_implicit<M>();
+#endif
 }
 
 int main(int, char**)
 {
     test<char>();
     test<wchar_t>();
 
   return 0;
 }

libcxx/test/support/make_implicit.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <stack>
+#ifndef SUPPORT_MAKE_IMPLICIT_H
+#define SUPPORT_MAKE_IMPLICIT_H
 
-// stack();
+// "make_implicit<Tp>(Args&&... args)" is a function to construct 'Tp'
+// from 'Args...' using implicit construction.
 
-#include <stack>
-#include <vector>
-#include <cassert>
+#include <utility>
 
-#include "test_macros.h"
-#include "test_allocator.h"
-
-int main(int, char**)
-{
-    std::stack<int, std::vector<int, limited_allocator<int, 10> > > q;
-    assert(q.size() == 0);
-    q.push(1);
-    q.push(2);
-    assert(q.size() == 2);
-    assert(q.top() == 2);
-
-  return 0;
+template <class T, class... Args>
+T make_implicit(Args&&... args) {
+  return {std::forward<Args>(args)...};
 }
+
+#endif // SUPPORT_MAKE_IMPLICIT_H