Qualify all calls to std::get

There have been some discussions and confusion about whether `std::get`
can be specialized for user types.
It can't, it's not a customization point and the standard always
calls it qualified. As the issue has come around a few times,
the standard should make it clear that this calls is always
qualified, like it does for std::move and std::forward.

Author: cor3ntin

source/declarations.tex

@@ -6774,9 +6774,9 @@
 that is a function template whose first template parameter
 is a non-type parameter,
 the initializer is
-\tcode{\exposidnc{e}.get<i>()}. Otherwise, the initializer is \tcode{get<i>(\exposid{e})},
+\tcode{\exposidnc{e}.std::get<i>()}. Otherwise, the initializer is \tcode{std::get<i>(\exposid{e})},
 where \tcode{get} undergoes argument-dependent lookup\iref{basic.lookup.argdep}.
-In either case, \tcode{get<i>} is interpreted as a \grammarterm{template-id}.
+In either case, \tcode{std::get<i>} is interpreted as a \grammarterm{template-id}.
 \begin{note}
 Ordinary unqualified lookup\iref{basic.lookup.unqual} is not performed.
 \end{note}

source/iterators.tex

@@ -4910,7 +4910,7 @@
 \pnum
 \effects
 Initializes \tcode{v_} as if by
-\tcode{v_\{in_place_index<$i$>, get<$i$>(x.v_)\}},
+\tcode{v_\{in_place_index<$i$>, std::get<$i$>(x.v_)\}},
 where $i$ is \tcode{x.v_.index()}.
 \end{itemdescr}
 
@@ -4932,9 +4932,9 @@
 Equivalent to:
 \begin{itemize}
 \item If \tcode{v_.index() == x.v_.index()}, then
-\tcode{get<$i$>(v_) = get<$i$>(x.v_)}.
+\tcode{std::get<$i$>(v_) = std::get<$i$>(x.v_)}.
 
-\item Otherwise, \tcode{v_.emplace<$i$>(get<$i$>(x.v_))}.
+\item Otherwise, \tcode{v_.emplace<$i$>(std::get<$i$>(x.v_))}.
 \end{itemize}
 where $i$ is \tcode{x.v_.index()}.
 
@@ -4959,7 +4959,7 @@
 
 \pnum
 \effects
-Equivalent to: \tcode{return *get<I>(v_);}
+Equivalent to: \tcode{return *std::get<I>(v_);}
 \end{itemdescr}
 
 \indexlibrarymember{operator->}{common_iterator}%
@@ -4987,19 +4987,19 @@
 \begin{itemize}
 \item
 If \tcode{I} is a pointer type or if the expression
-\tcode{get<I>(v_).operator->()} is
-well-formed, equivalent to: \tcode{return get<I>(v_);}
+\tcode{std::get<I>(v_).operator->()} is
+well-formed, equivalent to: \tcode{return std::get<I>(v_);}
 
 \item
 Otherwise, if \tcode{iter_reference_t<I>} is a reference type, equivalent to:
 \begin{codeblock}
-auto&& tmp = *get<I>(v_);
+auto&& tmp = *std::get<I>(v_);
 return addressof(tmp);
 \end{codeblock}
 
 \item
 Otherwise, equivalent to:
-\tcode{return \exposid{proxy}(*get<I>(v_));} where
+\tcode{return \exposid{proxy}(*std::get<I>(v_));} where
 \exposid{proxy} is the exposition-only class:
 \begin{codeblock}
 class @\exposid{proxy}@ {
@@ -5029,7 +5029,7 @@
 
 \pnum
 \effects
-Equivalent to \tcode{++get<I>(v_)}.
+Equivalent to \tcode{++std::get<I>(v_)}.
 
 \pnum
 \returns
@@ -5064,7 +5064,7 @@
 is \tcode{false},
 equivalent to:
 \begin{codeblock}
-return get<I>(v_)++;
+return std::get<I>(v_)++;
 \end{codeblock}
 Otherwise, equivalent to:
 \begin{codeblock}
@@ -5105,7 +5105,7 @@
 \pnum
 \returns
 \tcode{true} if \tcode{$i$ == $j$},
-and otherwise \tcode{get<$i$>(x.v_) == get<$j$>(y.v_)},
+and otherwise \tcode{std::get<$i$>(x.v_) == std::get<$j$>(y.v_)},
 where $i$ is \tcode{x.v_.index()} and $j$ is \tcode{y.v_.index()}.
 \end{itemdescr}
 
@@ -5126,7 +5126,7 @@
 \pnum
 \returns
 \tcode{true} if $i$ and $j$ are each \tcode{1}, and otherwise
-\tcode{get<$i$>(x.v_) == get<$j$>(y.v_)}, where
+\tcode{std::get<$i$>(x.v_) == std::get<$j$>(y.v_)}, where
 $i$ is \tcode{x.v_.index()} and $j$ is \tcode{y.v_.index()}.
 \end{itemdescr}
 
@@ -5147,7 +5147,7 @@
 \pnum
 \returns
 \tcode{0} if $i$ and $j$ are each \tcode{1}, and otherwise
-\tcode{get<$i$>(x.v_) - get<$j$>(y.v_)}, where
+\tcode{std::get<$i$>(x.v_) - std::get<$j$>(y.v_)}, where
 $i$ is \tcode{x.v_.index()} and $j$ is \tcode{y.v_.index()}.
 \end{itemdescr}
 
@@ -5167,7 +5167,7 @@
 
 \pnum
 \effects
-Equivalent to: \tcode{return ranges::iter_move(get<I>(i.v_));}
+Equivalent to: \tcode{return ranges::iter_move(std::get<I>(i.v_));}
 \end{itemdescr}
 
 \indexlibrarymember{iter_swap}{common_iterator}%
@@ -5185,7 +5185,7 @@
 
 \pnum
 \effects
-Equivalent to \tcode{ranges::iter_swap(get<I>(x.v_), get<I2>(y.v_))}.
+Equivalent to \tcode{ranges::iter_swap(std::get<I>(x.v_), std::get<I2>(y.v_))}.
 \end{itemdescr}
 
 \rSec2[default.sentinel]{Default sentinel}

source/memory.tex

@@ -1054,8 +1054,8 @@
 Equivalent to:
 \begin{codeblock}
 return uses_allocator_construction_args<T>(alloc, piecewise_construct,
-                                           forward_as_tuple(get<0>(std::move(pr))),
-                                           forward_as_tuple(get<1>(std::move(pr))));
+                                           forward_as_tuple(std::get<0>(std::move(pr))),
+                                           forward_as_tuple(std::get<1>(std::move(pr))));
 \end{codeblock}
 \end{itemdescr}
 

source/ranges.tex

@@ -8961,7 +8961,7 @@
 \item
 Otherwise, \tcode{true}
 if there exists an integer $0 \leq i < \tcode{sizeof...(Views)}$
-such that \tcode{bool(std::\brk{}get<$i$>(x.\exposid{current_}) ==
+such that \tcode{bool(std::\brk{}std::get<$i$>(x.\exposid{current_}) ==
 std::get<$i$>(y.\exposid{current_}))} is \tcode{true}.
 \begin{note}
 This allows \tcode{zip_view} to model \libconcept{common_range}

source/threads.tex

@@ -6970,7 +6970,7 @@
 \pnum
 \effects
 For all \tcode{i} in \range{0}{sizeof...(MutexTypes)},
-\tcode{get<i>(pm).unlock()}.
+\tcode{std::get<i>(pm).unlock()}.
 \end{itemdescr}
 
 \rSec3[thread.lock.unique]{Class template \tcode{unique_lock}}