pep-material: comparison handouts/pep-ho.tex

equal deleted inserted replaced

-:b9eaa5cdec4a
+:48e12e7aee6e
 % nice example for map and reduce using Harry potter characters
 % https://www.matthewgerstman.com/map-filter-reduce/
 \begin{document}
-\fnote{\copyright{} Christian Urban, King's College London, 2017, 2018}
+\fnote{\copyright{} Christian Urban, King's College London, 2017, 2018, 2019}
 \section*{A Crash-Course in Scala}
 \mbox{}\hfill\textit{``Scala --- \underline{S}lowly \underline{c}ompiled
 \underline{a}cademic \underline{la}nguage''}\smallskip\\
 is critical because you do not want that conflicting writes mess about
 with \texttt{i}. Take my word: an untold amount of misery has arisen
 from this problem. The catch is that if you try to solve this problem in
 C++ or Java, and be as defensive as possible about reads and writes to
 \texttt{i}, then you need to synchronise access to it. The result is that
-your program more often than not waits more than it runs, thereby
+very often your program waits more than it runs, thereby
 defeating the point of trying to run the program in parallel in the
 first place. If you are less defensive, then usually all hell breaks
 loose by seemingly obtaining random results. And forget the idea of
 being able to debug such code.
 programs. Once you installed Scala, you can start the interpreter by
 typing on the command line:
 \begin{lstlisting}[language={},numbers=none,basicstyle=\ttfamily\small]
 $ scala
-Welcome to Scala 2.12.7 (Java HotSpot(TM) 64-Bit Server VM, Java 9).
+Welcome to Scala 2.13.0 (Java HotSpot(TM) 64-Bit Server VM, Java 9).
 Type in expressions for evaluation. Or try :help.
 scala>
 \end{lstlisting}%$
 \subsection*{Values}
 In the lectures I will try to avoid as much as possible the term
 \emph{variables} familiar from other programming languages. The reason
 is that Scala has \emph{values}, which can be seen as abbreviations of
-larger expressions. For example
+larger expressions. The keyword for defining values is \code{val}.
+For example
 \begin{lstlisting}[numbers=none]
 scala> val x = 42
 x: Int = 42
 scala> val z = x / y
 z: Int = 6
 \end{lstlisting}
 \noindent
-Why the kerfuffle about values? Well, values are \emph{immutable}. You
+As can be seen we first define \code{x} and {y} with some silly
-cannot change their value after you defined them. If you try to reassign
+expressions, and then reuse these values in the definition of \code{z}.
-\code{z} above, Scala will yell at you:
+All easy, no? Why the kerfuffle about values? Well, values are
+\emph{immutable}. You cannot change their value after you defined them.
+If you try to reassign \code{z} above, Scala will yell at you:
 \begin{lstlisting}[numbers=none]
 scala> z = 9
 error: reassignment to val
 z = 9
 \noindent but try to guess what Scala will print out
 for \code{z}?  Will it be \code{6} or \code{10}? A final word about
 values: Try to stick to the convention that names of values should be
 lower case, like \code{x}, \code{y}, \code{foo41} and so on. Upper-case
-names you should reserve for what is called \emph{constructors}.
+names you should reserve for what is called \emph{constructors}. And
+forgive me when I call values as variables\ldots{}it is just something that
+has been in imprinted into my developer-DNA during my early days and
+difficult to get rid of.~\texttt{;o)}
 \subsection*{Function Definitions}
 We do functional programming! So defining functions will be our main occupation.
 def f(x: Int) : String = ...EXPR...
 \end{lstlisting}
 \noindent
 This function returns the value resulting from evaluating the expression
-\code{EXPR} (whatever is substituted for this). The result will be
+\code{EXPR} (whatever is substituted for this). Since we declared
-of type \code{String}. It is a good habit to always include this information
+\code{String}, the result of this function will be of type
+\code{String}. It is a good habit to always include this information
 about the return type. Simple examples of Scala functions are:
 \begin{lstlisting}[numbers=none]
 def incr(x: Int) : Int = x + 1
 def double(x: Int) : Int = x + x
 \noindent
 The general scheme for a function is
 \begin{lstlisting}[numbers=none]
 def fname(arg1: ty1, arg2: ty2,..., argn: tyn): rty = {
-BODY
+...BODY...
 }
 \end{lstlisting}
 \noindent
 where each argument, \texttt{arg1}, \texttt{arg2} and so on, requires
 is just a simple expression, like \code{x + 1}, you can omit the
 braces. Very often functions are recursive (that is call themselves),
 like the venerable factorial function:
 \begin{lstlisting}[numbers=none]
-def fact(n: Int): Int =
+def fact(n: Int) : Int =
 if (n == 0) 1 else n * fact(n - 1)
 \end{lstlisting}
 \noindent
+We could also have written this as
+\begin{lstlisting}[numbers=none]
+def fact(n: Int) : Int = {
+if (n == 0) 1
+else n * fact(n - 1)
+}
+\end{lstlisting}
+\noindent
+but this seems a bit over-kill for a small function like \code{fact}.
 Note that Scala does not have a \code{then}-keyword in an \code{if}-statement.
+Note also that there are a few other ways of how to define a function. We
+will see some in the next sections.
 \subsection*{Loops, or better the Absence thereof}
 Coming from Java or C++, you might be surprised that Scala does
 not really have loops. It has instead, what is in functional
 programming called, \emph{maps}. To illustrate how they work,
 \end{lstlisting}
 \noindent The \code{if}-condition in the for-comprehension
 filters out all pairs where the sum is not even.
-While hopefully this all looks reasonable, there is one
+\subsection*{Results and Side-Effects}
+While hopefully this all about maps looks reasonable, there is one
 complication: In the examples above we always wanted to
 transform one list into another list (e.g.~list of squares),
 or one set into another set (set of numbers into set of
 remainders modulo 3). What happens if we just want to print out
 a list of integers? Then actually the for-comprehension
 If you want to find out more about maps and functions with
 side-effects, you can ponder about the response Scala gives if
 you replace \code{foreach} by \code{map} in the expression
 above. Scala will still allow \code{map} with side-effect
 functions, but then reacts with a slightly interesting result.
+\subsection*{Higher-Order Functions}
 \subsection*{Types}
 In most functional programming languages, types play an
 important role. Scala is such a language. You have already

changeset 271	48e12e7aee6e
parent 270	b9eaa5cdec4a
child 272	da3d30ae67ec