Consistent comma after e.g. and i.e.

After grepping to determine the preferred idiom, it seems clear that
the standard prefers to follow both e.g. and i.e. with a comma, rather
than omit it.  This patch applies that rule to the few places that
were missing the comma.

Author: AlisdairM

source/declarators.tex

@@ -2251,7 +2251,7 @@
 \end{example}
 
 \begin{example}
-One can make a class uncopyable, i.e. move-only, by using deleted
+One can make a class uncopyable, i.e., move-only, by using deleted
 definitions of the copy constructor and copy assignment operator, and then
 providing defaulted definitions of the move constructor and move assignment operator.
 \begin{codeblock}

source/iostreams.tex

@@ -40,7 +40,7 @@
 \pnum
 Figure~\ref{fig:streampos} illustrates relationships among various types
 described in this clause. A line from \textbf{A} to \textbf{B} indicates that \textbf{A}
-is an alias (e.g. a typedef) for \textbf{B} or that \textbf{A} is defined in terms of
+is an alias (e.g., a typedef) for \textbf{B} or that \textbf{A} is defined in terms of
 \textbf{B}.
 
 \begin{importgraphic}

source/lib-intro.tex

@@ -2668,13 +2668,17 @@
 \begin{note}
 If the parameter is a generic parameter of the form \tcode{T\&\&} and an lvalue of type
 \tcode{A} is bound, the argument binds to an lvalue reference\iref{temp.deduct.call}
-and thus is not covered by the previous sentence. \end{note} \begin{note} If a program casts
-an lvalue to an xvalue while passing that lvalue to a library function (e.g. by calling the function
-with the argument \tcode{std::move(x)}), the program
+and thus is not covered by the previous sentence.
+\end{note}
+\begin{note}
+If a program casts
+an lvalue to an xvalue while passing that lvalue to a library function
+(e.g., by calling the function with the argument \tcode{std::move(x)}), the program
 is effectively asking that function to treat that lvalue as a temporary object.
 The implementation
 is free to optimize away aliasing checks which might be needed if the argument was
-an lvalue. \end{note}
+an lvalue.
+\end{note}
 \end{itemize}
 
 \rSec3[res.on.objects]{Library object access}

source/templates.tex

@@ -850,7 +850,7 @@
 the \grammarterm{template-id}. \begin{note} The second \tcode{>}
 token produced by this replacement rule may terminate an enclosing
 \grammarterm{template-id} construct or it may be part of a different
-construct (e.g. a cast).\end{note}
+construct (e.g., a cast).\end{note}
 \begin{example}
 
 \begin{codeblock}

source/threads.tex

@@ -99,13 +99,13 @@
 
 \begin{itemize}
 \item
-if $C_a > C_t$, the waiting function should wake as soon as possible, i.e. $C_a + D_i + D_m$,
+if $C_a > C_t$, the waiting function should wake as soon as possible, i.e., $C_a + D_i + D_m$,
 since the timeout is already satisfied. \begin{note} This specification may result in the total
 duration of the wait decreasing when measured against a steady clock. \end{note}
 
 \item
 if $C_a \leq C_t$, the waiting function should not time out until \tcode{Clock::now()} returns a
-time $C_n \geq C_t$, i.e. waking at $C_t + D_i + D_m$. \begin{note} When the clock is adjusted
+time $C_n \geq C_t$, i.e., waking at $C_t + D_i + D_m$. \begin{note} When the clock is adjusted
 backwards, this specification may result in the total duration of the wait increasing when
 measured against a steady clock. When the clock is adjusted forwards, this specification may
 result in the total duration of the wait decreasing when measured against a steady clock.
@@ -147,7 +147,7 @@
 An \defn{execution agent} is an entity such as a thread that may perform work in parallel with
 other execution agents. \begin{note} Implementations or users may introduce other kinds of
 agents such as processes or thread-pool tasks. \end{note} The calling agent is determined by
-context, e.g. the calling thread that contains the call, and so on.
+context, e.g., the calling thread that contains the call, and so on.
 
 \pnum
 \begin{note} Some lockable objects are ``agent oblivious'' in that they work for any

source/utilities.tex

@@ -4858,7 +4858,7 @@
 \pnum
 \complexity
 For \tcode{sizeof...(Variants) <= 1}, the invocation of the callable object is
-implemented in constant time, i.e. it does not depend on \tcode{sizeof...(Types).}
+implemented in constant time, i.e., it does not depend on \tcode{sizeof...(Types).}
 For \tcode{sizeof...(Variants) > 1}, the invocation of the callable object has
 no complexity requirements.
 \end{itemdescr}
@@ -4987,7 +4987,7 @@
 \pnum
 \begin{note}
 The discriminated type may contain values of different types but does not attempt conversion between them,
-i.e. \tcode{5} is held strictly as an \tcode{int} and is not implicitly convertible either to \tcode{"5"} or to \tcode{5.0}.
+i.e., \tcode{5} is held strictly as an \tcode{int} and is not implicitly convertible either to \tcode{"5"} or to \tcode{5.0}.
 This indifference to interpretation but awareness of type effectively allows safe, generic containers of single values, with no scope for surprises from ambiguous conversions.
 \end{note}