[std] Harmonize 'reference binds to an expression' phrasing

Author: jensmaurer

source/basic.tex

@@ -4272,8 +4272,7 @@
 sequenced before the construction of the next array element, if any.
 
 \pnum
-The third context is when a reference is bound to a
-temporary object.
+The third context is when a reference binds to a temporary object.
 \begin{footnote}
 The same rules apply to initialization of an
   \tcode{initializer_list} object\iref{dcl.init.list} with its

source/classes.tex

@@ -2824,8 +2824,7 @@
 \indextext{restriction!bit-field}%
 \indextext{restriction!address of bit-field}%
 \indextext{restriction!pointer to bit-field}%
-A non-const reference shall not be bound to a
-bit-field\iref{dcl.init.ref}.
+A non-const reference shall not bind to a bit-field\iref{dcl.init.ref}.
 \begin{note}
 If the initializer for a reference of type \keyword{const} \tcode{T\&} is
 an lvalue that refers to a bit-field, the reference is bound to a

source/declarations.tex

@@ -5424,7 +5424,7 @@
 functions\iref{over.match.ref} and choosing the best one through overload
 resolution\iref{over.match}),
 \end{itemize}
-then the reference is bound to the initializer expression lvalue in the
+then the reference binds to the initializer expression lvalue in the
 first case and to the lvalue result of the conversion
 in the second case (or, in either case, to the appropriate base class subobject of the object).
 \begin{note}
@@ -5481,24 +5481,24 @@
 its type \tcode{T4} is adjusted to type ``\cvqual{cv1} \tcode{T4}''\iref{conv.qual}
 and the temporary materialization conversion\iref{conv.rval} is applied.
 In any case,
-the reference is bound to the resulting glvalue
+the reference binds to the resulting glvalue
 (or to an appropriate base class subobject).
 
 \begin{example}
 \begin{codeblock}
 struct A { };
 struct B : A { } b;
 extern B f();
-const A& rca2 = f();                // bound to the \tcode{A} subobject of the \tcode{B} rvalue.
+const A& rca2 = f();                // binds to the \tcode{A} subobject of the \tcode{B} rvalue.
 A&& rra = f();                      // same as above
 struct X {
   operator B();
   operator int&();
 } x;
-const A& r = x;                     // bound to the \tcode{A} subobject of the result of the conversion
+const A& r = x;                     // binds to the \tcode{A} subobject of the result of the conversion
 int i2 = 42;
-int&& rri = static_cast<int&&>(i2); // bound directly to \tcode{i2}
-B&& rrb = x;                        // bound directly to the result of \tcode{operator B}
+int&& rri = static_cast<int&&>(i2); // binds directly to \tcode{i2}
+B&& rrb = x;                        // binds directly to the result of \tcode{operator B}
 \end{codeblock}
 \end{example}
 

source/lib-intro.tex

@@ -2797,7 +2797,7 @@
 pointer did point to the first element of such an array) are in fact valid.
 
 \item
-If a function argument binds to an rvalue reference parameter, the implementation may
+If a function argument is bound to an rvalue reference parameter, the implementation may
 assume that this parameter is a unique reference to this argument,
 except that the argument passed to a move-assignment operator may be
 a reference to \tcode{*this}\iref{lib.types.movedfrom}.

source/overloading.tex

@@ -1510,8 +1510,8 @@
 \tcode{F}.
 If the parameter has reference type, the implicit conversion sequence
 includes the operation of binding the reference, and the fact that
-an lvalue reference to non-\keyword{const} cannot be bound to an rvalue
-and that an rvalue reference cannot be bound to an lvalue
+an lvalue reference to non-\keyword{const} cannot bind to an rvalue
+and that an rvalue reference cannot bind to an lvalue
 can affect
 the viability of the function (see~\ref{over.ics.ref}).
 

source/templates.tex

@@ -427,9 +427,9 @@
   &x;                           // OK
   &i;                           // error: address of non-reference template-parameter
   &a;                           // OK
-  int& ri = i;                  // error: non-const reference bound to temporary
-  const int& cri = i;           // OK: const reference bound to temporary
-  const A& ra = a;              // OK: const reference bound to a template parameter object
+  int& ri = i;                  // error: attempt to bind non-const reference to temporary
+  const int& cri = i;           // OK: const reference binds to temporary
+  const A& ra = a;              // OK: const reference binds to a template parameter object
 }
 \end{codeblock}
 \end{example}