diff --git a/category-theory-for-programmers.pdf b/category-theory-for-programmers.pdf index ef4eedf..d2e51bd 100644 Binary files a/category-theory-for-programmers.pdf and b/category-theory-for-programmers.pdf differ diff --git a/src/content/1.1/Category - The Essence of Composition.tex b/src/content/1.1/Category - The Essence of Composition.tex index e3cf408..5e2d77f 100644 --- a/src/content/1.1/Category - The Essence of Composition.tex +++ b/src/content/1.1/Category - The Essence of Composition.tex @@ -50,7 +50,7 @@ C g(B b); \end{Verbatim} Their composition is: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} C g_after_f(A a) { return g(f(a)); @@ -87,9 +87,9 @@ g ◦ f \end{Verbatim} You can even use Unicode double colons and arrows: -\begin{minted}[escapeinside=||,mathescape=true]{text} -f |\ensuremath{\Colon}| A → B -\end{minted} +\begin{Verbatim}[commandchars=\\\{\}] +f \ensuremath{\Colon} A → B +\end{Verbatim} So here's the first Haskell lesson: Double colon means ``has the type of\ldots{}'' A function type is created by inserting an arrow between two types. You compose two functions by inserting a period between them @@ -142,7 +142,7 @@ identity function that just returns back its argument. The implementation is the same for every type, which means this function is universally polymorphic. In C++ we could define it as a template: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} template T id(T x) { return x; } \end{Verbatim} Of course, in C++ nothing is that simple, because you have to take into diff --git a/src/content/1.10/Natural Transformations.tex b/src/content/1.10/Natural Transformations.tex index ba61b3d..d58bd9a 100644 --- a/src/content/1.10/Natural Transformations.tex +++ b/src/content/1.10/Natural Transformations.tex @@ -169,7 +169,7 @@ Keep in mind that it's really a family of functions parameterized by \code{a}. This is another example of the terseness of the Haskell syntax. A similar construct in C++ would be slightly more verbose: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} template G alpha(F); \end{Verbatim} There is a more profound difference between Haskell's polymorphic @@ -746,7 +746,7 @@ for vertical composition, but not vice versa. Finally, the two compositions satisfy the interchange law: \begin{Verbatim}[commandchars=\\\{\}] -(β' ⋅ α') ◦ (β ⋅ α) = (β' ◦ β) ⋅ (α' ◦ α) +(β' \ensuremath{\cdot} α') ◦ (β \ensuremath{\cdot} α) = (β' ◦ β) \ensuremath{\cdot} (α' ◦ α) \end{Verbatim} I will quote Saunders Mac Lane here: The reader may enjoy writing down diff --git a/src/content/1.2/Types and Functions.tex b/src/content/1.2/Types and Functions.tex index fbaa3c6..a4dcc29 100644 --- a/src/content/1.2/Types and Functions.tex +++ b/src/content/1.2/Types and Functions.tex @@ -247,7 +247,7 @@ The function \code{product} multiplies all elements of a list. That's just like a definition of factorial taken from a math text. Compare this with C: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} int fact(int n) { int i; int result = 1; @@ -342,7 +342,7 @@ Think of functions from and to this type. A function from \code{void} can always be called. If it's a pure function, it will always return the same result. Here's an example of such a function: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} int f44() { return 44; } \end{Verbatim} You might think of this function as taking ``nothing'', but as we've @@ -418,7 +418,7 @@ unit _ = () \end{Verbatim} In C++ you would write this function as: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} template void unit(T) {} \end{Verbatim} @@ -434,7 +434,7 @@ data Bool = True | False \code{True} or \code{False}.) In principle, one should also be able to define a Boolean type in C++ as an enumeration: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} enum bool { true, false @@ -455,8 +455,8 @@ the Haskell library \code{Data.Char} is full of predicates like \code{} that defines, among others, \code{isalpha} and \code{isdigit}, but these return an \code{int} rather than a Boolean. The actual predicates are defined in \code{std::ctype} and -have the form \code{ctype::is(alpha,\ c)}, -\code{ctype::is(digit,\ c)}, etc. +have the form \code{ctype::is(alpha, c)}, +\code{ctype::is(digit, c)}, etc. \section{Challenges}\label{challenges} @@ -491,18 +491,18 @@ have the form \code{ctype::is(alpha,\ c)}, \item The factorial function from the example in the text. \item -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} std::getchar() \end{Verbatim} \item -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} bool f() { std::cout << "Hello!" << std::endl; return true; } \end{Verbatim} \item -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} int f(int x) { static int y = 0; diff --git a/src/content/1.3/Categories Great and Small.tex b/src/content/1.3/Categories Great and Small.tex index 3882c61..f374fbb 100644 --- a/src/content/1.3/Categories Great and Small.tex +++ b/src/content/1.3/Categories Great and Small.tex @@ -1,4 +1,4 @@ -\lettrine[lhang=0.17]{Y}{ou can get real appreciation} for categories by studying a variety of +\lettrine[lhang=0.17]{Y}{ou can get} real appreciation for categories by studying a variety of examples. Categories come in all shapes and sizes and often pop up in unexpected places. We'll start with something really simple. @@ -195,7 +195,7 @@ so this might be a little confusing to the beginner.) The closest one can get to declaring a monoid in C++ would be to use the (proposed) syntax for concepts. -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} template T mempty = delete; @@ -223,7 +223,7 @@ type) that tests whether there exist appropriate definitions of An instantiation of the Monoid concept can be accomplished by providing appropriate specializations and overloads: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} template<> std::string mempty = {""}; diff --git a/src/content/1.4/Kleisli Categories.tex b/src/content/1.4/Kleisli Categories.tex index f87d206..b875e1e 100644 --- a/src/content/1.4/Kleisli Categories.tex +++ b/src/content/1.4/Kleisli Categories.tex @@ -5,7 +5,7 @@ functions that log or trace their execution. Something that, in an imperative language, would likely be implemented by mutating some global state, as in: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} string logger; bool negate(bool b) { @@ -25,7 +25,7 @@ have to pass the log explicitly, in and out. Let's do that by adding a string argument, and pairing regular output with a string that contains the updated log: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} pair negate(bool b, string logger) { return make_pair(!b, logger + "Not so! "); } @@ -60,7 +60,7 @@ continuous log is a separate concern. We still want the function to produce a string, but we'd like to unburden it from producing a log. So here's the compromise solution: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} pair negate(bool b) { return make_pair(!b, "Not so! "); } @@ -72,7 +72,7 @@ To see how this can be done, let's switch to a slightly more realistic example. We have one function from string to string that turns lower case characters to upper case: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} string toUpper(string s) { string result; int (*toupperp)(int) = &toupper; // toupper is overloaded @@ -83,14 +83,14 @@ string toUpper(string s) { and another that splits a string into a vector of strings, breaking it on whitespace boundaries: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} vector toWords(string s) { return words(s); } \end{Verbatim} The actual work is done in the auxiliary function \code{words}: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} vector words(string s) { vector result{""}; for (auto i = begin(s); i != end(s); ++i) @@ -118,13 +118,13 @@ in a generic way by defining a template \code{Writer} that encapsulates a pair whose first component is a value of arbitrary type \code{A} and the second component is a string: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} template using Writer = pair; \end{Verbatim} Here are the embellished functions: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} Writer toUpper(string s) { string result; int (*toupperp)(int) = &toupper; @@ -140,7 +140,7 @@ We want to compose these two functions into another embellished function that uppercases a string and splits it into words, all the while producing a log of those actions. Here's how we may do it: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} Writer> process(string s) { auto p1 = toUpper(s); auto p2 = toWords(p1.first); @@ -174,7 +174,7 @@ important point is that this morphism is still considered an arrow between the objects \code{int} and \code{bool}, even though the embellished function returns a pair: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} pair isEven(int n) { return make_pair(n % 2 == 0, "isEven "); } @@ -184,7 +184,7 @@ with another morphism that goes from the object \code{bool} to whatever. In particular, we should be able to compose it with our earlier \code{negate}: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} pair negate(bool b) { return make_pair(!b, "Not so! "); } @@ -193,7 +193,7 @@ Obviously, we cannot compose these two morphisms the same way we compose regular functions, because of the input/output mismatch. Their composition should look more like this: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} pair isOdd(int n) { pair p1 = isEven(n); pair p2 = negate(p1.first); @@ -224,7 +224,7 @@ corresponding to three objects in our category. It should take two embellished functions that are composable according to our rules, and return a third embellished function: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} template function(A)> compose(function(A)> m1, function(B)> m2) @@ -249,7 +249,7 @@ There is still a lot of noise with the passing of types to the C++14-compliant compiler that supports generalized lambda functions with return type deduction (credit for this code goes to Eric Niebler): -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} auto const compose = [](auto m1, auto m2) { return [m1, m2](auto x) { auto p1 = m1(x); @@ -261,7 +261,7 @@ auto const compose = [](auto m1, auto m2) { In this new definition, the implementation of \code{process} simplifies to: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} Writer> process(string s) { return compose(toUpper, toWords)(s); } @@ -271,7 +271,7 @@ category, but what are the identity morphisms? These are not our regular identity functions! They have to be morphisms from type A back to type A, which means they are embellished functions of the form: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} Writer identity(A); \end{Verbatim} They have to behave like units with respect to composition. If you look @@ -279,7 +279,7 @@ at our definition of composition, you'll see that an identity morphism should pass its argument without change, and only contribute an empty string to the log: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} template Writer identity(A x) { return make_pair(x, ""); } @@ -324,7 +324,7 @@ a -> Writer b We'll declare the composition as a funny infix operator, sometimes called the ``fish'': -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} (>=>) :: (a -> Writer b) -> (b -> Writer c) -> (a -> Writer c) \end{Verbatim} It's a function of two arguments, each being a function on its own, and @@ -390,7 +390,7 @@ standard Prelude library. Finally, the composition of the two functions is accomplished with the help of the fish operator: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} process :: String -> Writer [String] process = upCase >=> toWords \end{Verbatim} @@ -432,7 +432,7 @@ mathematical sense, so it doesn't fit the standard categorical mold. It can, however, be represented by a function that returns an embellished type \code{optional}: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} template class optional { bool _isValid; A _value; @@ -446,7 +446,7 @@ public: As an example, here's the implementation of the embellished function \code{safe\_root}: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} optional safe_root(double x) { if (x >= 0) return optional{sqrt(x)}; else return optional{}; diff --git a/src/content/1.5/Products and Coproducts.tex b/src/content/1.5/Products and Coproducts.tex index 31a6584..898ebc7 100644 --- a/src/content/1.5/Products and Coproducts.tex +++ b/src/content/1.5/Products and Coproducts.tex @@ -265,7 +265,7 @@ snd (_, y) = y \end{Verbatim} In C++, we would use template functions, for instance: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} template A fst(pair const & p) { return p.first; @@ -359,7 +359,7 @@ equations are in natural numbers, and the dot is multiplication: \emph{m} is a common factor shared by \emph{p'} and \emph{q'}. Just to build some intuitions, let me show you that the pair -\code{(Int,\ Bool)} with the two canonical projections, \code{fst} +\code{(Int, Bool)} with the two canonical projections, \code{fst} and \code{snd} is indeed \emph{better} than the two candidates I presented before. @@ -387,7 +387,7 @@ The \code{m} for the second example is similarly uniquely determined: \begin{Verbatim}[commandchars=\\\{\}] m (x, _, b) = (x, b) \end{Verbatim} -We were able to show that \code{(Int,\ Bool)} is better than either of +We were able to show that \code{(Int, Bool)} is better than either of the two candidates. Let's see why the opposite is not true. Could we find some \code{m'} that would help us reconstruct \code{fst} and \code{snd} from \code{p} and \code{q}? @@ -512,7 +512,7 @@ have to define a tag --- an enumeration --- and combine it with the union. For instance, a tagged union of an \code{int} and a\\ \code{char const *} could be implemented as: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} struct Contact { enum { isPhone, isEmail } tag; union { int phoneNum; char const * emailAddr; }; @@ -522,7 +522,7 @@ The two injections can either be implemented as constructors or as functions. For instance, here's the first injection as a function \code{PhoneNum}: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} Contact PhoneNum(int n) { Contact c; c.tag = isPhone; @@ -673,7 +673,7 @@ isomorphism is the same as a bijection. \section{Challenges}\label{challenges} \begin{enumerate} - \tightlist +\tightlist \item Show that the terminal object is unique up to unique isomorphism. \item @@ -688,14 +688,14 @@ isomorphism is the same as a bijection. Show that \code{Either} is a ``better'' coproduct than \code{int} equipped with two injections: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} int i(int n) { return n; } int j(bool b) { return b? 0: 1; } \end{Verbatim} Hint: Define a function -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} int m(Either const & e); \end{Verbatim} @@ -707,7 +707,7 @@ int m(Either const & e); \item Still continuing: What about these injections? -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} int i(int n) { if (n < 0) return n; return n + 2; diff --git a/src/content/1.6/Simple Algebraic Data Types.tex b/src/content/1.6/Simple Algebraic Data Types.tex index ae17a51..bf7c89d 100644 --- a/src/content/1.6/Simple Algebraic Data Types.tex +++ b/src/content/1.6/Simple Algebraic Data Types.tex @@ -25,8 +25,8 @@ Library. \end{figure} \noindent -Pairs are not strictly commutative: a pair \code{(Int,\ Bool)} cannot -be substituted for a pair \code{(Bool,\ Int)}, even though they carry +Pairs are not strictly commutative: a pair \code{(Int, Bool)} cannot +be substituted for a pair \code{(Bool, Int)}, even though they carry the same information. They are, however, commutative up to isomorphism --- the isomorphism being given by the \code{swap} function (which is its own inverse): @@ -114,7 +114,7 @@ can be defined alternatively as: \begin{Verbatim}[commandchars=\\\{\}] data Pair a b = P a b \end{Verbatim} -Here, \code{Pair\ a\ b} is the name of the type paremeterized by two +Here, \code{Pair a b} is the name of the type paremeterized by two other types, \code{a} and \code{b}; and \code{P} is the name of the data constructor. You define a pair type by passing two types to the \code{Pair} type constructor. You construct a pair value by passing @@ -173,7 +173,7 @@ named fields is called a record in Haskell, and a \code{struct} in C. Let's have a look at a simple example. We want to describe chemical elements by combining two strings, name and symbol; and an integer, the atomic number; into one data structure. We can use a tuple -\code{(String,\ String,\ Int)} and remember which component represents +\code{(String, String, Int)} and remember which component represents what. We would extract components by pattern matching, as in this function that checks if the symbol of the element is the prefix of its name (as in \textbf{He} being the prefix of \textbf{Helium}): @@ -185,7 +185,7 @@ startsWithSymbol (name, symbol, _) = isPrefixOf symbol name This code is error prone, and is hard to read and maintain. It's much better to define a record: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} data Element = Element { name :: String , symbol :: String , atomicNumber :: Int } @@ -193,7 +193,7 @@ data Element = Element { name :: String The two representations are isomorphic, as witnessed by these two conversion functions, which are the inverse of each other: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} tupleToElem :: (String, String, Int) -> Element tupleToElem (n, s, a) = Element { name = n , symbol = s @@ -242,7 +242,7 @@ And like pairs, \code{Either}s are commutative (up to isomorphism), can be nested, and the nesting order is irrelevant (up to isomorphism). So we can, for instance, define a sum equivalent of a triple: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} data OneOfThree a b c = Sinistral a | Medial b | Dextral c \end{Verbatim} and so on. @@ -279,7 +279,7 @@ data Color = Red | Green | Blue \end{Verbatim} is the C++: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} enum { Red, Green, Blue }; \end{Verbatim} An even simpler sum type: @@ -328,7 +328,7 @@ List a = Nil | Cons a (List a) can be translated to C++ using the null pointer trick to implement the empty list: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} template class List { Node * _head; @@ -380,7 +380,7 @@ the first constructor argument with a wildcard, because we are not interested in it. The second argument to \code{Cons} is bound to the variable \code{t} (I will call these things variables even though, strictly speaking, they never vary: once bound to an expression, a -variable never changes). The return value is \code{Just\ t}. Now, +variable never changes). The return value is \code{Just t}. Now, depending on how your \code{List} was created, it will match one of the clauses. If it was created using \code{Cons}, the two arguments that were passed to it will be retrieved (and the first discarded). @@ -417,7 +417,7 @@ example, is it possible to create a pair of, say \code{Int} and To create a pair you need two values. Although you can easily come up with an integer, there is no value of type \code{Void}. Therefore, for -any type \code{a}, the type \code{(a,\ Void)} is uninhabited --- has +any type \code{a}, the type \code{(a, Void)} is uninhabited --- has no values --- and is therefore equivalent to \code{Void}. In other words, \code{a*0 = 0}. @@ -511,7 +511,7 @@ equation: \begin{Verbatim}[commandchars=\\\{\}] List a = Nil | Cons a (List a) \end{Verbatim} -If we do our usual substitutions, and also replace \code{List\ a} with +If we do our usual substitutions, and also replace \code{List a} with \code{x}, we get the equation: \begin{Verbatim}[commandchars=\\\{\}] @@ -613,7 +613,7 @@ circ (Rect d h) = 2.0 * (d + h) have to touch in Haskell vs. C++ or Java? (Even if you're not a Haskell programmer, the modifications should be pretty obvious.) \item - Show that \code{a\ +\ a\ =\ 2\ *\ a} holds for types (up to + Show that \code{a + a = 2 * a} holds for types (up to isomorphism). Remember that \code{2} corresponds to \code{Bool}, according to our translation table. \end{enumerate} \ No newline at end of file diff --git a/src/content/1.7/Functors.tex b/src/content/1.7/Functors.tex index 36e53c9..3031265 100644 --- a/src/content/1.7/Functors.tex +++ b/src/content/1.7/Functors.tex @@ -56,7 +56,7 @@ want all identity morphisms in C to be mapped to identity morphisms in D: \begin{Verbatim}[commandchars=\\\{\}] -F ida = idF a +F id\textsubscript{a} = id\textsubscript{F a} \end{Verbatim} Here, \emph{id\textsubscript{a}} is the identity at the object \emph{a}, and \emph{id\textsubscript{F a}} the identity at \emph{F a}. @@ -209,7 +209,7 @@ There are two cases to consider: \code{Nothing} and \code{Just}. Here's the first case (I'm using Haskell pseudo-code to transform the left hand side to the right hand side): -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} fmap id Nothing = { definition of fmap } Nothing @@ -223,7 +223,7 @@ backwards. I replaced the expression \code{Nothing} with in the middle --- here it was \code{Nothing}. The second case is also easy: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} fmap id (Just x) = { definition of fmap } Just (id x) @@ -239,7 +239,7 @@ fmap (g . f) = fmap g . fmap f \end{Verbatim} First the \code{Nothing} case: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} fmap (g . f) Nothing = { definition of fmap } Nothing @@ -250,7 +250,7 @@ First the \code{Nothing} case: \end{Verbatim} And then the \code{Just} case: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} fmap (g . f) (Just x) = { definition of fmap } Just ((g . f) x) @@ -266,7 +266,7 @@ And then the \code{Just} case: It's worth stressing that equational reasoning doesn't work for C++ style ``functions'' with side effects. Consider this code: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} int square(int x) { return x * x; } @@ -281,7 +281,7 @@ double y = square(counter()); Using equational reasoning, you would be able to inline \code{square} to get: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} double y = counter() * counter(); \end{Verbatim} This is definitely not a valid transformation, and it will not produce @@ -299,7 +299,7 @@ implementation is much more complex, dealing with various ways the argument may be passed, with copy semantics, and with the resource management issues characteristic of C++): -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} template class optional { bool _isValid; // the tag @@ -315,7 +315,7 @@ mapping of types. It maps any type \code{T} to a new type \code{optional}. Let's define its action on functions: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} template std::function(optional)> fmap(std::function f) { @@ -330,7 +330,7 @@ fmap(std::function f) { This is a higher order function, taking a function as an argument and returning a function. Here's the uncurried version of it: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} template optional fmap(std::function f, optional opt) { if (!opt.isValid()) @@ -428,7 +428,7 @@ template class, like \code{optional}, so by analogy, we would parameterize \code{fmap} with a \newterm{template template parameter} \code{F}. This is the syntax for it: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} template F, class A, class B> F fmap(std::function, F); \end{Verbatim} @@ -436,14 +436,14 @@ 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{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} template optional fmap(std::function f, optional opt) \end{Verbatim} Instead, we have to fall back on function overloading, which brings us back to the original definition of the uncurried \code{fmap}: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} template optional fmap(std::function f, optional opt) { if (!opt.isValid()) @@ -514,7 +514,7 @@ If you are more comfortable with C++, consider the case of a container. The implementation of \code{fmap} for \code{std::vector} is just a thin encapsulation of \code{std::transform}: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} template std::vector fmap(std::function f, std::vector v) { std::vector w; @@ -528,7 +528,7 @@ std::vector fmap(std::function f, std::vector v) { We can use it, for instance, to square the elements of a sequence of numbers: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} std::vector v{ 1, 2, 3, 4 }; auto w = fmap([](int i) { return i*i; }, v); std::copy( std::begin(w) @@ -691,7 +691,7 @@ This might be a little clearer in C++ (I never thought I would utter those words!), where there is a stronger distinction between type arguments --- which are compile-time --- and values, which are run-time: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} template struct Const { Const(C v) : _v(v) {} @@ -702,7 +702,7 @@ The C++ implementation of \code{fmap} also ignores the function argument and essentially re-casts the \code{Const} argument without changing its value: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} template Const fmap(std::function f, Const c) { return Const{c._v}; diff --git a/src/content/1.8/Functoriality.tex b/src/content/1.8/Functoriality.tex index 24de0f4..b7e1c07 100644 --- a/src/content/1.8/Functoriality.tex +++ b/src/content/1.8/Functoriality.tex @@ -249,7 +249,7 @@ arguments. The syntax is the same. If you're getting a little lost, try applying \code{BiComp} to \code{Either}, \code{Const ()}, \code{Identity}, \code{a}, and \code{b}, in this order. You will recover our bare-bone version of -\code{Maybe\ b} (\code{a} is ignored). +\code{Maybe b} (\code{a} is ignored). The new data type \code{BiComp} is a bifunctor in \code{a} and \code{b}, but only if \code{bf} is itself a \code{Bifunctor} and @@ -260,11 +260,11 @@ know that there will be a definition of \code{bimap} available for instance declaration: a set of class constraints followed by a double arrow: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{minted}[breaklines]{text} instance (Bifunctor bf, Functor fu, Functor gu) => Bifunctor (BiComp bf fu gu) where bimap f1 f2 (BiComp x) = BiComp ((bimap (fmap f1) (fmap f2)) x) -\end{Verbatim} +\end{minted} The implementation of \code{bimap} for \code{BiComp} is given in terms of \code{bimap} for \code{bf} and the two \code{fmap}s for \code{fu} and \code{gu}. The compiler automatically infers all the @@ -305,9 +305,9 @@ can't it be automated and performed by the compiler? Indeed, it can, and it is. You need to enable a particular Haskell extension by including this line at the top of your source file: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{minted}{haskell} {-# LANGUAGE DeriveFunctor #-} -\end{Verbatim} +\end{minted} and then add \code{deriving Functor} to your data structure: \begin{Verbatim}[commandchars=\\\{\}] @@ -334,7 +334,7 @@ is made into a generic template, you should be able to quickly implement Let's have a look at a tree data structure, which we would define in Haskell as a recursive sum type: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} data Tree a = Leaf a | Node (Tree a) (Tree a) deriving Functor \end{Verbatim} @@ -353,7 +353,7 @@ The base class must define at least one virtual function in order to support dynamic casting, so we'll make the destructor virtual (which is a good idea in any case): -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} template struct Tree { virtual ~Tree() {}; @@ -361,7 +361,7 @@ struct Tree { \end{Verbatim} The \code{Leaf} is just an \code{Identity} functor in disguise: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} template struct Leaf : public Tree { T _label; @@ -370,7 +370,7 @@ struct Leaf : public Tree { \end{Verbatim} The \code{Node} is a product type: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} template struct Node : public Tree { Tree * _left; @@ -386,7 +386,7 @@ is treated like a bifunctor composed with two copies of the analyzing code in these terms, but it's a good exercise in categorical thinking. -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} template Tree * fmap(std::function f, Tree * t) { Leaf * pl = dynamic_cast *>(t); @@ -405,7 +405,7 @@ issues, but in production code you would probably use smart pointers Compare it with the Haskell implementation of \code{fmap}: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} instance Functor Tree where fmap f (Leaf a) = Leaf (f a) fmap f (Node t t') = Node (fmap f t) (fmap f t') @@ -467,7 +467,7 @@ So \code{id} will take \code{Writer a} and turn it into \code{Writer a}. The fish operator will fish out the value of \code{a} and pass it as \code{x} to the lambda. There, \code{f} will turn it into a \code{b} and \code{return} will embellish it, -making it \code{Writer\ b}. Putting it all together, we end up with a +making it \code{Writer b}. Putting it all together, we end up with a function that takes \code{Writer a} and returns \code{Writer b}, exactly what \code{fmap} is supposed to produce. @@ -479,7 +479,7 @@ every functor, though, gives rise to a Kleisli category.) You might wonder if the \code{fmap} we have just defined is the same \code{fmap} the compiler would have derived for us with -\code{deriving\ Functor}. Interestingly enough, it is. This is due to +\code{deriving Functor}. Interestingly enough, it is. This is due to the way Haskell implements polymorphic functions. It's called \newterm{parametric polymorphism}, and it's a source of so called \newterm{theorems for free}. One of those theorems says that, if there is @@ -577,13 +577,13 @@ by the way --- the kind we've been studying thus far --- are called Here's the typeclass defining a contravariant functor (really, a contravariant \emph{endo}functor) in Haskell: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} class Contravariant f where contramap :: (b -> a) -> (f a -> f b) \end{Verbatim} Our type constructor \code{Op} is an instance of it: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} instance Contravariant (Op r) where -- (b -> a) -> Op r a -> Op r b contramap f g = g . f @@ -623,7 +623,7 @@ which is contra-functorial in the first argument and functorial in the second. Here's the appropriate typeclass taken from the \code{Data.Profunctor} library: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} class Profunctor p where dimap :: (a -> b) -> (c -> d) -> p b c -> p a d dimap f g = lmap f . rmap g @@ -649,7 +649,7 @@ the defaults for \code{lmap} and \code{rmap}, or implementing both Now we can assert that the function-arrow operator is an instance of a \code{Profunctor}: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} instance Profunctor (->) where dimap ab cd bc = cd . bc . ab lmap = flip (.) @@ -677,7 +677,7 @@ data Pair a b = Pair a b Show the isomorphism between the standard definition of \code{Maybe} and this desugaring: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} type Maybe' a = Either (Const () a) (Identity a) \end{Verbatim} diff --git a/src/content/1.9/Function Types.tex b/src/content/1.9/Function Types.tex index f454a5e..2d05025 100644 --- a/src/content/1.9/Function Types.tex +++ b/src/content/1.9/Function Types.tex @@ -1,7 +1,7 @@ \lettrine[lhang=0.17]{S}{o far I've} been glossing over the meaning of function types. A function type is different from other types. -\begin{wrapfigure}[13]{R}{0pt} +\begin{wrapfigure}[12]{R}{0pt} \raisebox{0pt}[\dimexpr\height-0.75\baselineskip\relax]{ \fbox{\includegraphics[width=40mm]{images/set-hom-set.jpg}}}% \caption{Hom-set in Set is just a set} @@ -322,14 +322,14 @@ initializer lists). You can partially apply a C++ function using the template \code{std::bind}. For instance, given a function of two strings: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} std::string catstr(std::string s1, std::string s2) { return s1 + s2; } \end{Verbatim} you can define a function of one string: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} using namespace std::placeholders; auto greet = std::bind(catstr, "Hello ", _1); @@ -339,7 +339,7 @@ Scala, which is more functional than C++ or Java, falls somewhere in between. If you anticipate that the function you're defining will be partially applied, you define it with multiple argument lists: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} def catstr(s1: String)(s2: String) = s1 + s2 \end{Verbatim} Of course that requires some amount of foresight or prescience on the diff --git a/src/content/3.4/Monads - Programmer's Definition.tex b/src/content/3.4/Monads - Programmer's Definition.tex index b00f407..6e55f77 100644 --- a/src/content/3.4/Monads - Programmer's Definition.tex +++ b/src/content/3.4/Monads - Programmer's Definition.tex @@ -52,7 +52,7 @@ directly from function to function. We also inline short segments of glue code rather than abstract them into helper functions. Here's an imperative-style implementation of the vector-length function in C: -\begin{Verbatim}[commandchars=\\\{\}] +\begin{Verbatim} double vlen(double * v) { double d = 0.0; int n;