P0433R2 Integrating template deduction for class templates into the standard library

Deduction guides for lock_guard and scoped_lock are not in this branch,
but in motions-2017-03-lwg-17 instead (with the changes to lock_guard
and scoped_lock).

Editorial differences from P0433R2 wording:
- Consistent indentation and whitespace.
- [namespace.std] Replace period of previous \item with ", or".
- [allocator.adaptor.syn] Fix "OuterAllocator" parameter, to "OuterAlloc".
- [refwrap] Change "typename T" to "class T" in template parameter list.
- [sequence.reqmts] Add period after "unevaluated operand" and
  parentheses around cross-reference to [temp.deduct].
- [associative.reqmts] Add periods after each \item.
- [unord.reqmts] Add periods after each \item.
- [associative.overview] Change "exposition only type aliases" to
  "exposition-only alias templates" and add semi-colon after third
  template.
- [unord.general] Change "exposition only type aliases" to
  "exposition-only alias templates".
- [template.valarray.overview] Change "typename T" to "class T".
- [container.adaptors.general] Added periods to bullet list items.
- [thread.lock.unique]. [thread.lock.shared] Change parameter M to Mutex.

Also fixes NB US-7, US-14 (C++17 CD)

Author: jwakely

source/containers.tex

@@ -2177,7 +2177,9 @@
 standard library class or class template, or
 
 \item an explicit or partial specialization of any member class template
-of a standard library class or class template.
+of a standard library class or class template, or
+
+\item a deduction guide for any standard library class template.
 \end{itemize}
 A program may explicitly instantiate a template defined in the standard library
 only if the declaration depends on the name of a user-defined type

source/lib-intro.tex

@@ -6737,6 +6737,8 @@
     valarray apply(T func(const T&)) const;
     void resize(size_t sz, T c = T());
   };
+
+  template<class T, size_t cnt> valarray(const T(&)[cnt], size_t) -> valarray<T>;
 }
 \end{codeblock}
 

source/numerics.tex

@@ -1407,6 +1407,11 @@
       // \ref{re.regex.swap}, swap
       void swap(basic_regex&);
     };
+
+  template<class ForwardIterator>
+    basic_regex(ForwardIterator, ForwardIterator,
+                regex_constants::syntax_option_type = regex_constants::ECMAScript)
+      -> basic_regex<typename iterator_traits<ForwardIterator>::value_type>;
 }
 \end{codeblock}
 

source/regex.tex

@@ -1134,6 +1134,13 @@
     int compare(size_type pos1, size_type n1,
                 const charT* s, size_type n2) const;
   };
+
+  template<class InputIterator,
+           class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
+    basic_string(InputIterator, InputIterator, Allocator = Allocator())
+      -> basic_string<typename iterator_traits<InputIterator>::value_type,
+                      char_traits<typename iterator_traits<InputIterator>::value_type>,
+                      Allocator>;
 }
 \end{codeblock}
 
@@ -1472,6 +1479,20 @@
 \throws The second form throws nothing if \tcode{alloc == str.get_allocator()}.
 \end{itemdescr}
 
+\begin{itemdecl}
+template<class InputIterator,
+         class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
+  basic_string(InputIterator, InputIterator, Allocator = Allocator())
+    -> basic_string<typename iterator_traits<InputIterator>::value_type,
+                    char_traits<typename iterator_traits<InputIterator>::value_type>,
+                    Allocator>;
+\end{itemdecl}
+
+\begin{itemdescr}
+\remarks Shall not participate in overload resolution if
+\tcode{InputIterator} is a type that does not qualify as an input iterator,
+or if \tcode{Allocator} is a type that does not qualify as an allocator~(\ref{sequence.reqmts}).
+\end{itemdescr}
 
 \indexlibrarymember{operator=}{basic_string}%
 \begin{itemdecl}

source/strings.tex

@@ -1771,6 +1771,8 @@
     bool owns;      // \expos
   };
 
+  template<class Mutex> unique_lock(unique_lock<Mutex>) -> unique_lock<Mutex>;
+
   template <class Mutex>
     void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
 }
@@ -2214,6 +2216,8 @@
     bool owns;      // \expos
   };
 
+  template<class Mutex> shared_lock(shared_lock<Mutex>) -> shared_lock<Mutex>;
+
   template <class Mutex>
     void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
 }

source/threads.tex

@@ -905,6 +905,9 @@
 
       void swap(pair& p) noexcept(@\seebelow@);
     };
+
+  template<class T1, class T2>
+    pair(T1, T2) -> pair<T1, T2>;
 }
 \end{codeblock}
 
@@ -1542,6 +1545,17 @@
       // \ref{tuple.swap}, \tcode{tuple} swap
       void swap(tuple&) noexcept(@\seebelow@);
     };
+
+  template<class... UTypes>
+    tuple(UTypes...) -> tuple<UTypes...>;
+  template<class T1, class T2>
+    tuple(pair<T1, T2>) -> tuple<T1, T2>;
+  template<class Alloc, class... UTypes>
+    tuple(allocator_arg_t, Alloc, UTypes...) -> tuple<UTypes...>;
+  template<class Alloc, class T1, class T2>
+    tuple(allocator_arg_t, Alloc, pair<T1, T2>) -> tuple<T1, T2>;
+  template<class Alloc, class... UTypes>
+    tuple(allocator_arg_t, Alloc, tuple<UTypes...>) -> tuple<UTypes...>;
 }
 \end{codeblock}
 
@@ -2632,6 +2646,8 @@
   private:
     T *val; // \expos
   };
+
+template<class T> optional(T) -> optional<T>;
 \end{codeblock}
 
 \pnum
@@ -8485,6 +8501,9 @@
 \pnum
 \remarks If this constructor is instantiated with a pointer type or reference type
 for the template argument \tcode{D}, the program is ill-formed.
+If class template argument deduction~(\ref{over.match.class.deduct})
+would select the function template corresponding to this constructor,
+then the program is ill-formed.
 \end{itemdescr}
 
 \indexlibrary{\idxcode{unique_ptr}!constructor}%
@@ -8570,6 +8589,10 @@
 deleter. If \tcode{D} is a reference type then \tcode{get_deleter()}
 returns a reference to the lvalue \tcode{d}.
 
+\remarks If class template argument deduction~(\ref{over.match.class.deduct})
+would select a function template corresponding to either of these constructors,
+then the program is ill-formed.
+
 \begin{example}
 
 \begin{codeblock}
@@ -9397,6 +9420,9 @@
     template<class U> bool owner_before(const weak_ptr<U>& b) const;
   };
 
+  template<class T> shared_ptr(weak_ptr<T>) ->  shared_ptr<T>;
+  template<class T, class D> shared_ptr(unique_ptr<T, D>) ->  shared_ptr<T>;
+
   // \ref{util.smartptr.shared.create}, \tcode{shared_ptr} creation
   template<class T, class... Args>
     shared_ptr<T> make_shared(Args&&... args);
@@ -10312,6 +10338,9 @@
     template<class U> bool owner_before(const weak_ptr<U>& b) const;
   };
 
+  template<class T> weak_ptr(shared_ptr<T>) -> weak_ptr<T>;
+
+
   // \ref{util.smartptr.weak.spec}, specialized algorithms
   template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
 }
@@ -12208,6 +12237,10 @@
     scoped_allocator_adaptor select_on_container_copy_construction() const;
   };
 
+  template<class OuterAlloc, class... InnerAllocs>
+    scoped_allocator_adaptor(OuterAlloc, InnerAllocs...)
+      -> scoped_allocator_adaptor<OuterAlloc, InnerAllocs...>;
+
   template <class OuterA1, class OuterA2, class... InnerAllocs>
     bool operator==(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
                     const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept;
@@ -12831,33 +12864,6 @@
            class BinaryPredicate = equal_to<>>
     class boyer_moore_horspool_searcher;
 
-  template<class ForwardIterator, class BinaryPredicate = equal_to<>>
-    default_searcher<ForwardIterator, BinaryPredicate>
-      make_default_searcher(
-          ForwardIterator pat_first,
-          ForwardIterator pat_last,
-          BinaryPredicate pred = BinaryPredicate());
-
-  template<class RandomAccessIterator,
-           class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>,
-           class BinaryPredicate = equal_to<>>
-    boyer_moore_searcher<RandomAccessIterator, Hash, BinaryPredicate>
-      make_boyer_moore_searcher(
-          RandomAccessIterator pat_first,
-          RandomAccessIterator pat_last,
-          Hash hf = Hash(),
-          BinaryPredicate pred = BinaryPredicate());
-
-  template<class RandomAccessIterator,
-           class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>,
-           class BinaryPredicate = equal_to<>>
-    boyer_moore_horspool_searcher<RandomAccessIterator, Hash, BinaryPredicate>
-      make_boyer_moore_horspool_searcher(
-          RandomAccessIterator pat_first,
-          RandomAccessIterator pat_last,
-          Hash hf = Hash(),
-          BinaryPredicate pred = BinaryPredicate());
-
   // \ref{unord.hash}, hash function primary template
   template <class T>
     struct hash;
@@ -13041,6 +13047,9 @@
     result_of_t<T&(ArgTypes&&...)>
     operator() (ArgTypes&&...) const;
   };
+
+  template<class T>
+    reference_wrapper(reference_wrapper<T>) -> reference_wrapper<T>;
 }
 \end{codeblock}
 
@@ -14343,9 +14352,13 @@
     const type_info& target_type() const noexcept;
     template<class T>       T* target() noexcept;
     template<class T> const T* target() const noexcept;
-
   };
 
+  template<class R, class... ArgTypes>
+    function(R(*)(ArgTypes...)) -> function<R(ArgTypes...)>;
+
+  template<class F> function(F) -> function<@\seebelow@>;
+
   // \ref{func.wrap.func.nullptr}, Null pointer comparisons
   template <class R, class... ArgTypes>
     bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
@@ -14387,6 +14400,12 @@
 wrapper~(\ref{func.def}) whose call signature~(\ref{func.def})
 is \tcode{R(ArgTypes...)}.
 
+\pnum
+\begin{note}
+The types deduced by the deduction guides for \tcode{function}
+may change in future versions of this International Standard.
+\end{note}
+
 \rSec4[func.wrap.func.con]{\tcode{function} construct/copy/destroy}
 
 \indexlibrary{\idxcode{function}!constructor}%
@@ -14491,6 +14510,30 @@
 or move constructor.
 \end{itemdescr}
 
+
+\begin{itemdecl}
+template<class F> function(F) -> function<@\seebelow@>;
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\remarks This deduction guide participates in overload resolution only if
+\tcode{\&F::operator()} is well-formed when treated as an unevaluated operand.
+In that case, if \tcode{decltype(\&F::operator())} is of the form
+\tcode{R(G::*)(A...)}~\cv{}~\tcode{\&\opt{}~noexcept\opt}
+for a class type \tcode{G}, then the deduced type is \tcode{function<R(A...)>}.
+
+\pnum
+\begin{example}
+\begin{codeblock}
+void f() {
+  int i{5};
+  function g = [&](double) { return i; }; // deduces \tcode{function<int(double)>}
+}
+\end{codeblock}
+\end{example}
+\end{itemdescr}
+
 \indexlibrarymember{operator=}{function}%
 \begin{itemdecl}
 function& operator=(const function& f);
@@ -14762,25 +14805,6 @@
 \end{itemize}
 \end{itemdescr}
 
-\rSec4[func.search.default.creation]{\tcode{default_searcher} creation functions}
-
-\indexlibrary{\idxcode{make_default_searcher}}%
-\begin{itemdecl}
-template <class ForwardIterator, class BinaryPredicate = equal_to<>>
-  default_searcher<ForwardIterator, BinaryPredicate>
-    make_default_searcher(ForwardIterator pat_first, ForwardIterator pat_last,
-                          BinaryPredicate pred = BinaryPredicate());
-\end{itemdecl}
-
-\begin{itemdescr}
-\pnum
-\effects
-Equivalent to:
-\begin{codeblock}
-return default_searcher<ForwardIterator, BinaryPredicate>(pat_first, pat_last, pred);
-\end{codeblock}
-\end{itemdescr}
-
 \rSec3[func.search.bm]{Class template \tcode{boyer_moore_searcher}}
 
 \indexlibrary{\idxcode{boyer_moore_searcher}}%
@@ -14874,30 +14898,6 @@
 At most \tcode{(last - first) * (pat_last_ - pat_first_)} applications of the predicate.
 \end{itemdescr}
 
-\rSec4[func.search.bm.creation]{\tcode{boyer_moore_searcher} creation functions}
-
-\indexlibrary{\idxcode{make_boyer_moore_searcher}}%
-\begin{itemdecl}
-template <class RandomAccessIterator,
-          class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>,
-          class BinaryPredicate = equal_to<>>
-  boyer_moore_searcher<RandomAccessIterator, Hash, BinaryPredicate>
-    make_boyer_moore_searcher(RandomAccessIterator pat_first,
-                              RandomAccessIterator pat_last,
-                              Hash hf = Hash(),
-                              BinaryPredicate pred = BinaryPredicate());
-\end{itemdecl}
-
-\begin{itemdescr}
-\pnum
-\effects
-Equivalent to:
-\begin{codeblock}
-return boyer_moore_searcher<RandomAccessIterator, Hash, BinaryPredicate>(
-    pat_first, pat_last, hf, pred);
-\end{codeblock}
-\end{itemdescr}
-
 \rSec3[func.search.bmh]{Class template \tcode{boyer_moore_horspool_searcher}}
 
 \indexlibrary{\idxcode{boyer_moore_horspool_searcher}}%
@@ -14991,30 +14991,6 @@
 At most \tcode{(last - first) * (pat_last_ - pat_first_)} applications of the predicate.
 \end{itemdescr}
 
-\rSec4[func.search.bmh.creation]{\tcode{boyer_moore_horspool_searcher} creation functions}
-
-\indexlibrary{\idxcode{make_boyer_moore_horspool_searcher}}%
-\begin{itemdecl}
-template <class RandomAccessIterator,
-          class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>,
-          class BinaryPredicate = equal_to<>>
-  boyer_moore_horspool_searcher<RandomAccessIterator, Hash, BinaryPredicate>
-    make_boyer_moore_horspool_searcher(RandomAccessIterator pat_first,
-                                       RandomAccessIterator pat_last,
-                                       Hash hf = Hash(),
-                                       BinaryPredicate pred = BinaryPredicate());
-\end{itemdecl}
-
-\begin{itemdescr}
-\pnum
-\effects
-Equivalent to:
-\begin{codeblock}
-return boyer_moore_horspool_searcher<RandomAccessIterator, Hash, BinaryPredicate>(
-    pat_first, pat_last, hf, pred);
-\end{codeblock}
-\end{itemdescr}
-
 \rSec2[unord.hash]{Class template \tcode{hash}}
 
 \pnum