More typo fixed, up to auto.

Author: j-jorge

examples/anonymous-namespace/sound_system-anonymous.cpp

@@ -0,0 +1,17 @@
+#include <cstdio>
+
+namespace
+{
+  struct system
+  {
+    system()
+    {
+      printf("sound system\n");
+    }
+  };
+}
+
+void init_sound_system()
+{
+  system s;
+}

examples/anonymous-namespace/sound_system.cpp

@@ -0,0 +1,14 @@
+#include <cstdio>
+
+struct system
+{
+  system()
+  {
+    printf("sound system\n");
+  }
+};
+
+void init_sound_system()
+{
+  system s;
+}

examples/static-assert/even_sized_array-11.cpp

@@ -8,8 +8,8 @@ struct even_sized_array
   typedef T type[N];
 };
 
-// So many less code <3
-void foo()
+// So much less code <3
+void test()
 {
   even_sized_array<int, 8>::type ok;
   even_sized_array<int, 9>::type nok;

examples/static-assert/even_sized_array-98.cpp

@@ -20,7 +20,7 @@ struct even_sized_array
   type;
 };
 
-void foo()
+void test()
 {
   even_sized_array<int, 8>::type ok;
   even_sized_array<int, 9>::type nok;

examples/uniform-initialization/struct.cpp

@@ -25,7 +25,8 @@ struct foo_initializer_list
     : a(v2), b(v1)
   {}
 
-  // We will come back to std::initializer list later :)
+  // An initializer list allows to construct an object using an aggregate-like
+  // syntax. We will come back to it in @\ref{initializer-list}@ :)
   foo_initializer_list(const std::initializer_list<int>& i)
     // Note that the fields are set to the same value.
     : a(*i.begin()),

parts/11/auto.tex

@@ -31,10 +31,9 @@ \subsection{Auto}
 \subsubsection{Auto as a Type Placeholder}
 
 The \code{auto} keyword tells the compiler to deduce the actual type
-of a variable from whatever is assigned to it. It can be used every
-time a type should be typed, as long as there is an expression the
-compiler can use to find the type. It can be augmented with
-\code{const} or \code{\&}.
+of a variable from whatever is assigned to it. It can be used as long
+as there is an expression the compiler can use to find the type. It
+can be augmented with \code{const} or \code{\&}.
 
 A typical use is for iterating over an associative container in a for
 loop:
@@ -61,7 +60,7 @@ \subsubsection{Auto as a Type Placeholder}
 
 \begin{lstlisting}
 template<typename F>
-auto foo(F&& f) -> decltype(f())
+auto indirect_call(F&& f) -> decltype(f())
 {
   return f();
 }
@@ -78,8 +77,9 @@ \subsubsection{When not to Use \code{auto}}
 
 In practice, the use of this keyword has lead to very painful to read
 code, where nothing can be understood without going through every
-expression assigned to an \code{auto} variable. This is a very high
-load to pass to the next reader.
+expression assigned to an \code{auto} variable, and where entire
+functions have to be interpreted to eventually find the returned
+type. This is a very high load to pass to the next reader.
 
 \begin{guideline}
 Mind the next reader; write what you mean.

parts/11/constexpr.tex

@@ -31,7 +31,8 @@ \subsection{\code{constexpr}}
 
 This implementation works but has two major problems: first it is
 incredibly verbose, second it forces us to implement the same
-algorithm twice, doubling the risk of bugs and errors.
+algorithm twice, respectively for run time and compile time
+computations, doubling the risk of bugs and errors.
 
 \bigskip
 
@@ -44,9 +45,4 @@ \subsection{\code{constexpr}}
 tell the compiler that it can and should be computed at compile-time
 when it appears in constant expressions. It is for example totally
 possible to call the \code{constexpr popcount()} function as a
-template argument, like in \code{popcount<popcount<42>>()}.
-
-Finally, as an extra bonus, while compilers typically put limits on
-the template instantiations depth, i.e. the number of times a template
-can be instantiated recursively, there is no such limit to
-constexpr functions.
+template argument, like in \code{popcount<popcount<42>{}>()}.

parts/11/decltype.tex

@@ -1,10 +1,10 @@
 \subsection{Type Deduction with \code{decltype}}
 \label{decltype}
 
-During the pre-\cpp11 every variable, member, argument, etc. has to be
-exactly typed. For example, if we were writing a template function
-receiving another function as an argument, how could we store the
-result of a call of this function in a local variable?
+During the pre-\cpp11 era every variable, member, argument, etc. has
+to be explicitly typed. For example, if we were writing a template
+function operating on a range, how could we declare a variable of the
+type of its items?
 
 \begin{lstlisting}
 template
@@ -60,3 +60,6 @@ \subsection{Type Deduction with \code{decltype}}
   }
 }
 \end{lstlisting}
+
+In the example above, \code{decltype(*first)} is the type of the
+result of dereferencing \code{first}.

parts/11/lambdas.tex

@@ -69,6 +69,7 @@ \subsection{Lambdas}
 {
   // Only three lines for the equivalent of the type
   // declaration, definition and the instantiation.
+  // The third argument is a lambda.
   return std::find_if
     (strings.begin(), strings.end(),
      [=](const std::string& string) -> bool
@@ -93,12 +94,12 @@ \subsubsection{The Internals of Lambdas}
 [a, b, c]( /* arguments */ ) -> T { /* statements */ }
 \end{lstlisting}
 
-is totally equivalent to
+is equivalent to
 
 \begin{lstlisting}
 struct something
 {
-  T operator( /* arguments */ ) const { /* statements */ }
+  T operator()( /* arguments */ ) const { /* statements */ }
 
   /* deduced type */ a;
   /* deduced type */ b;
@@ -124,9 +125,9 @@ \subsubsection{The Internals of Lambdas}
 \item {\it capture} is a list of variables from the parent scope that
   must be accessible inside the lambda. Use \code{[=]} to tell the
   compiler to automatically copy any variable used by the lambda, or
-  \code{[\&]} to keep a reference to the used variables from the
-  parent scope. Variables can also be captured in a fine-grained way,
-  e.g. \code{[=a, \&b]} to copy the value of \code{a} but store a
+  \code{[\&]} to keep a reference to the corresponding variables from
+  the parent scope. Variables can also be captured in a fine-grained
+  way, e.g. \code{[=a, \&b]} to copy the value of \code{a} but store a
   reference to \code{b}.
 \item {\it arguments} are the arguments of the function.
 \item By default the variables captured by value cannot be assigned to

parts/11/scoped-enumerations.tex

@@ -2,19 +2,19 @@ \subsection{Scoped Enumerations}
 
 An enumeration in pre-\cpp11 code is just like a C enumeration: a list
 of constants of type \code{int} in the scope containing the
-enumeration. For example, note how \code{foobar::foo} can be accessed
-directly and assigned to an integer in the code below:
+enumeration. For example, note how \code{appliance::fan} can be
+accessed directly and assigned to an integer in the code below:
 
 \begin{lstlisting}
-enum foobar
+enum appliance
 {
-  foo,
-  bar
+  fan,
+  oven
 };
 
 int main()
 {
-  int v = foo;
+  int v = fan;
 }
 \end{lstlisting}
 
@@ -33,14 +33,14 @@ \subsection{Scoped Enumerations}
 enum follower
 {
   fan,
-  anonymous
+  admirer
 };
 \end{lstlisting}
 
 The above code will fail to compile with a message along the lines of
 ``error: ‘fan’ conflicts with a previous declaration.'' Now the
 typical solution to that was to add a unique prefix to the enumerated
-values, but in the times of namespaces and so, is it really a a solution?
+values, but in the times of namespaces and so, is it really a solution?
 
 \bigskip
 
@@ -67,8 +67,8 @@ \subsection{Scoped Enumerations}
 enumerations and do not conflict with each other; so if we want to
 access a value we must now prefix it with the name of the enumeration,
 like in \code{follower::fan}. Moreover, they are also not implicitly
-convertible to \code{int} anymore, which may or may not always be good
-thing.
+convertible to \code{int} anymore, which may or may not always be a
+good thing.
 
 The fact that we can also define the type of their values allows for
 smaller memory consumption when needed, but also add the possibility