Replace 'class' with 'typename' in template parameters

Author: matssson

src/content/1.1/category-the-essence-of-composition.tex

@@ -131,7 +131,7 @@ \section{Properties of Composition}
 universally polymorphic. In C++ we could define it as a template:
 
 \begin{snip}{cpp}
-template<class T> T id(T x) { return x; }
+template<typename T> T id(T x) { return x; }
 \end{snip}
 Of course, in C++ nothing is that simple, because you have to take into
 account not only what you're passing but also how (that is, by value, by

src/content/1.10/natural-transformations.tex

@@ -162,7 +162,7 @@ \section{Polymorphic Functions}
 syntax. A similar construct in C++ would be slightly more verbose:
 
 \begin{snip}{cpp}
-template<class A> G<A> alpha(F<A>);
+template<typename A> G<A> alpha(F<A>);
 \end{snip}
 There is a more profound difference between Haskell's polymorphic
 functions and C++ generic functions, and it's reflected in the way these

src/content/1.2/types-and-functions.tex

@@ -394,7 +394,7 @@ \section{Examples of Types}
 In C++ you would write this function as:
 
 \begin{snip}{cpp}
-template<class T>
+template<typename T>
 void unit(T) {}
 \end{snip}
 Next in the typology of types is a two-element set. In C++ it's called

src/content/1.3/categories-great-and-small.tex

@@ -180,13 +180,13 @@ \section{Monoid as Set}
 C++20 standard's concept feature.
 
 \begin{snip}{cpp}
-template<class T>
+template<typename T>
 struct mempty;
 
-template<class T>
+template<typename T>
 T mappend(T, T) = delete;
 
-template<class M>
+template<typename M>
 concept Monoid = requires (M m) {
     { mempty<M>::value() } -> std::same_as<M>;
     { mappend(m, m) } -> std::same_as<M>;

src/content/1.4/kleisli-categories.tex

@@ -120,7 +120,7 @@
 \code{A} and the second component is a string:
 
 \begin{snip}{cpp}
-template<class A>
+template<typename A>
 using Writer = pair<A, string>;
 \end{snip}
 Here are the embellished functions:
@@ -226,7 +226,7 @@ \section{The Writer Category}
 return a third embellished function:
 
 \begin{snip}{cpp}
-template<class A, class B, class C>
+template<typename A, typename B, typename C>
 function<Writer<C>(A)> compose(function<Writer<B>(A)> m1,
                                function<Writer<C>(B)> m2)
 {
@@ -282,7 +282,7 @@ \section{The Writer Category}
 string to the log:
 
 \begin{snip}{cpp}
-template<class A>
+template<typename A>
 Writer<A> identity(A x) {
     return make_pair(x, "");
 }
@@ -411,7 +411,7 @@ \section{Challenge}
 type \code{optional}:
 
 \begin{snip}{cpp}
-template<class A>
+template<typename A>
 class optional {
     bool _isValid;
     A _value;

src/content/1.5/products-and-coproducts.tex

@@ -244,7 +244,7 @@ \section{Products}
 In C++, we would use template functions, for instance:
 
 \begin{snip}{cpp}
-template<class A, class B>
+template<typename A, typename B>
 A fst(pair<A, B> const & p) {
     return p.first;
 }

src/content/1.6/simple-algebraic-data-types.tex

@@ -253,7 +253,7 @@ \section{Sum Types}
 empty list:
 
 \begin{snip}{cpp}
-template<class A>
+template<typename A>
 class List {
     Node<A> * _head;
 public:

src/content/1.7/functors.tex

@@ -266,7 +266,7 @@ \subsection{Optional}
 management issues characteristic of C++):
 
 \begin{snip}{cpp}
-template<class T>
+template<typename T>
 class optional {
     bool _isValid; // the tag
     T _v;
@@ -282,7 +282,7 @@ \subsection{Optional}
 functions:
 
 \begin{snip}{cpp}
-template<class A, class B>
+template<typename A, typename B>
 std::function<optional<B>(optional<A>)>
 fmap(std::function<B(A)> f) {
     return [f](optional<A> opt) {
@@ -297,7 +297,7 @@ \subsection{Optional}
 returning a function. Here's the uncurried version of it:
 
 \begin{snip}{cpp}
-template<class A, class B>
+template<typename A, typename B>
 optional<B> fmap(std::function<B(A)> f, optional<A> opt) {
     if (!opt.isValid())
         return optional<B>{};
@@ -380,22 +380,22 @@ \subsection{Functor in C++}
 \code{F}. This is the syntax for it:
 
 \begin{snip}{cpp}
-template<template<class> F, class A, class B>
+template<template<typename> F, typename A, typename B>
 F<B> fmap(std::function<B(A)>, F<A>);
 \end{snip}
 We would like to be able to specialize this template for different
 functors. Unfortunately, there is a prohibition against partial
 specialization of template functions in C++. You can't write:
 
 \begin{snip}{cpp}
-template<class A, class B>
+template<typename A, typename B>
 optional<B> fmap<optional>(std::function<B(A)> f, optional<A> opt)
 \end{snip}
 Instead, we have to fall back on function overloading, which brings us
 back to the original definition of the uncurried \code{fmap}:
 
 \begin{snip}{cpp}
-template<class A, class B>
+template<typename A, typename B>
 optional<B> fmap(std::function<B(A)> f, optional<A> opt) {
     if (!opt.isValid())
         return optional<B>{};
@@ -456,7 +456,7 @@ \subsection{The List Functor}
 is just a thin encapsulation of \code{std::transform}:
 
 \begin{snip}{cpp}
-template<class A, class B>
+template<typename A, typename B>
 std::vector<B> fmap(std::function<B(A)> f, std::vector<A> v) {
     std::vector<B> w;
     std::transform( std::begin(v)
@@ -611,7 +611,7 @@ \section{Functors as Containers}
 arguments --- which are compile-time --- and values, which are run-time:
 
 \begin{snip}{cpp}
-template<class C, class A>
+template<typename C, typename A>
 struct Const {
     Const(C v) : _v(v) {}
     C _v;
@@ -622,7 +622,7 @@ \section{Functors as Containers}
 changing its value:
 
 \begin{snip}{cpp}
-template<class C, class A, class B>
+template<typename C, typename A, typename B>
 Const<C, B> fmap(std::function<B(A)> f, Const<C, A> c) {
     return Const<C, B>{c._v};
 }

src/content/1.8/functoriality.tex

@@ -305,15 +305,15 @@ \section{Functors in C++}
 a good idea in any case):
 
 \begin{snip}{cpp}
-template<class T>
-struct Tree {
+template<typename T>
+struct Tree { 
     virtual ~Tree() {}
 };
 \end{snip}
 The \code{Leaf} is just an \code{Identity} functor in disguise:
 
 \begin{snip}{cpp}
-template<class T>
+template<typename T>
 struct Leaf : public Tree<T> {
     T _label;
     Leaf(T l) : _label(l) {}
@@ -322,7 +322,7 @@ \section{Functors in C++}
 The \code{Node} is a product type:
 
 \begin{snip}{cpp}
-template<class T>
+template<typename T>
 struct Node : public Tree<T> {
     Tree<T> * _left;
     Tree<T> * _right;
@@ -338,7 +338,7 @@ \section{Functors in C++}
 thinking.
 
 \begin{snip}{cpp}
-template<class A, class B>
+template<typename A, typename B>
 Tree<B> * fmap(std::function<B(A)> f, Tree<A> * t) {
     Leaf<A> * pl = dynamic_cast <Leaf<A>*>(t);
     if (pl)