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

equal deleted inserted replaced

-:48de09728447
+:86a456f8cb92
 \definecolor{cellbackground}{HTML}{F7F7F7}
 \begin{document}
-\fnote{\copyright{} Christian Urban, King's College London, 2017, 2018, 2019, 2020, 2021, 2022}
+\fnote{\copyright{} Christian Urban, King's College London, 2017, 2018, 2019, 2020, 2021, 2022, 2023}
 %\begin{tcolorbox}[breakable,size=fbox,boxrule=1pt,pad at break*=1mm,colback=cellbackground,colframe=cellborder]
 %  abd
 %\end{tcolorbox}
 \section*{A Crash-Course in Scala}
 \mbox{}\hfill\textit{``Scala --- \underline{S}lowly \underline{c}ompiled
 \underline{a}cademic \underline{la}nguage''}\smallskip\\
 \mbox{}\hfill\textit{ --- a joke(?) found on Twitter}\bigskip
+\mbox{}\hfill\textit{``Life is too short for \texttt{malloc}.''}\smallskip\\
+\mbox{}\hfill\textit{ --- said Neal Ford at Oscon'13}\;\hr{https://www.youtube.com/watch?v=7aYS9PcAITQ}\bigskip\\
 \subsection*{Introduction}
 \noindent
 Scala is a programming language that combines functional and
 the myriads of Java libraries. Unlike Java, however, Scala often allows
 programmers to write very concise and elegant code.  Some therefore say
 ``Scala is the better Java''.\footnote{from
 \url{https://www.slideshare.net/maximnovak/joy-of-scala}}
-A number of companies---the Guardian, Twitter, Coursera, FourSquare,
+A number of companies---the Guardian, Dualingo, Coursera, FourSquare,
 Netflix, LinkedIn, ITV to name a few---either use Scala exclusively in
 production code, or at least to some substantial degree. Scala seems
 also useful in job-interviews (especially in data science) according to
 this anecdotal report
 \begin{quote}
 \url{http://www.scala-lang.org}\medskip
 \end{quote}
 \noindent\alert
-Just make sure you are downloading the ``battle tested'' version of
+Just make sure you are using the version 3(!) of Scala. This is
-Scala \textbf{2.13} This is the one I am going to use in the lectures and
+the version I am going to use in the lectures and in the coursework. This
-in the coursework. The newer Scala 3.1 \& 3.2 still have some
+can be any version of Scala 3.X where $X=\{1,2,3\}$. Also the minor
-features not fully implemented.\bigskip
+number does not matter. Note that this will be the first year I am
+using this version -- so some hiccups are bound to happen. Apologies
-\noindent
+in advance!\bigskip
-If you are interested, there are also experimental backends of Scala
-for producing code under Android (\url{http://scala-android.org}); for
+\noindent
-generating JavaScript code (\url{https://www.scala-js.org}); and there
+If you are interested, there are also experimental backend of Scala
-is work under way to have a native Scala compiler generating X86-code
+for generating JavaScript code (\url{https://www.scala-js.org}), and
-(\url{http://www.scala-native.org}). Though be warned these backends
+there is work under way to have a native Scala compiler generating
-are still rather beta or even alpha.
+X86-code (\url{http://www.scala-native.org}). There are also some
+tricks you can play with Scala programms running as native
+GraalVM~\hr{https://scala-cli.virtuslab.org/docs/cookbooks/native-images/}
+images.  Though be warned these backends are still rather beta or even
+alpha.
 \subsection*{VS Code and Scala}
 I found a convenient IDE for writing Scala programs is Microsoft's
 \textit{Visual Studio Code} (VS Code) which runs under MacOSX, Linux and
 \end{quote}
 \noindent
 and should already come pre-installed in the Department (together with
 the Scala compiler). Being a project that just started in 2015, VS Code is
-relatively new and thus far from perfect. However it includes a
+relatively new and therefore far from perfect. However it includes a
 \textit{Marketplace} from which a multitude of extensions can be
 downloaded that make editing and running Scala code a little easier (see
 Figure~\ref{vscode} for my setup).
 \begin{figure}[t]
 evaluate small code snippets in the Scala REPL. I use the internal
 terminal to run Scala 2.13.6.\label{vscode}}
 \end{boxedminipage}
 \end{figure}
-Actually \alert last year I switched to VS Codium, which is VS Code minus
+Actually \alert last year I switched to VS Codium, which is VS Code
-all the telemetry that is normally sent to Microsoft. Apart from the
+minus all the telemetry that is normally sent to Microsoft. Apart from
-telemetry,  it works pretty much the same as the original but is driven
+the telemetry (and Copilot, which you are not supposed to use anyway),
-by a dedicated community, rather than a big company. You can download
+it works pretty much the same way as the original but is driven by a
-VS Codium from
+dedicated community, rather than a big company. You can download VS
+Codium from
 \begin{quote}
 \url{https://vscodium.com}
 \end{quote}
 \noindent
 Also IntelliJ includes plugins for Scala. \underline{\textbf{BUT}},
 I do \textbf{not} recommend the usage of either Eclipse or IntelliJ for PEP: these IDEs
 seem to make your life harder, rather than easier, for the small
 programs that we will write in this module. They are really meant to be used
-when you have a million-lines codebase than with our small
+when you have a million-lines codebase instead of our small
 ``toy-programs''\ldots{}for example why on earth am I required to create a
 completely new project with several subdirectories when I just want to
 try out 20-lines of Scala code? Your mileage may vary though.~\texttt{;o)}
 \subsection*{Why Functional Programming?}
 %Your friendly lecturer just
 %happens to like Scala and the Department agreed that it is a good idea
 %to inflict Scala upon you.
 Very likely writing programs in a functional programming language is
-quite different from what you are  used to in your study so far. It
+quite different from what you are used to in your study so far. It
 might even be totally alien to you. The reason is that functional
 programming seems to go against the core principles of
-\textit{imperative programming} (which is what you do in Java and C/C++
+\textit{imperative programming} (which is what you do in Java and
-for example). The main idea of imperative programming  is that you have
+C/C++ for example). The main idea of imperative programming is that
-some form of \emph{state} in your program and you continuously change
+you have some form of \emph{state} in your program and you
-this state by issuing some commands---for example for updating a field
+continuously change this state by issuing some commands---for example
-in an array or for adding one to a variable and so on. The classic
+for updating a field in an array or for adding one to a variable
-example for this style of programming is a \texttt{for}-loop in C/C++.
+stored in memory and so on. The classic example for this style of
-Consider the snippet:
+programming is a \texttt{for}-loop in C/C++.  Consider the snippet:
 \begin{lstlisting}[language=C,numbers=none]
 for (int i = 10; i < 20; i++) {
 //...do something with i...
 }
 \end{lstlisting}
-\noindent Here the integer variable \texttt{i} embodies the state, which
+\noindent Here the integer variable \texttt{i} embodies part of the
-is first set to \texttt{10} and then increased by one in each
+state of the program, which is first set to \texttt{10} and then
-loop-iteration until it reaches \texttt{20} at which point the loop
+increased by one in each loop-iteration until it reaches \texttt{20}
-exits. When this code is compiled and actually runs, there will be some
+at which point the loop exits. When this code is compiled and actually
-dedicated space reserved for \texttt{i} in memory. This space of
+runs, there will be some dedicated space reserved for \texttt{i} in
-typically 32 bits contains \texttt{i}'s current value\ldots\texttt{10}
+memory. This space of typically 32 bits contains \texttt{i}'s current
-at the beginning, and then the content will be overwritten with
+value\ldots\texttt{10} at the beginning, and then the content will be
-new content in every iteration. The main point here is that this kind of
+overwritten with new content in every iteration. The main point here
-updating, or overwriting, of memory is 25.806\ldots or \textbf{THE ROOT OF
+is that this kind of updating, or overwriting, of memory is
-ALL EVIL}!!
+25.806\ldots or \textbf{THE ROOT OF ALL EVIL}!!
 \begin{center}
 \includegraphics[scale=0.25]{../pics/root-of-all-evil.png}
 \end{center}
 Unfortunately this does not happen any more nowadays. To get you out of
 this dreadful situation, CPU producers pile more and more cores into
 CPUs in order to make them more powerful and potentially make software
 faster. The task for you as developer is to take somehow advantage of
 these cores by running as much of your code as possible in parallel on
-as many cores you have available (typically 4 or more in modern laptops
+as many cores you have available (typically 4-8 or even more in modern laptops
 and sometimes much more on high-end machines). In this situation
 \textit{mutable} variables like \texttt{i} in the C-code above are evil,
 or at least a major nuisance: Because if you want to distribute some of
 the loop-iterations over several cores that are currently idle in your
 system, you need to be extremely careful about who can read and
 interest, borrows many ideas from functional programming from
 yesteryear.}\medskip
 \noindent
 If you need any after-work distractions, you might have fun reading
-this about FP (functional programming) --- you
+the following article about FP (functional programming) --- you
 might have to disable your browser cookies though if you want to read
 it for free. And spoiler alert: This is tongue-in-cheek \texttt{;o)}
 \begin{quote}
-\url{https://betterprogramming.pub/fp-toy-7f52ea0a947e}
+\url{https://archive.ph/vrofC}
 \end{quote}
 \subsection*{The Very Basics}
-One advantage of Scala over Java is that it includes an interpreter (a
+Let us get back to Scala: One advantage of Scala over Java is that it
-REPL, or
+includes an interpreter (a REPL, or
 \underline{R}ead-\underline{E}val-\underline{P}rint-\underline{L}oop)
 with which you can run and test small code snippets without the need
 of a compiler. This helps a lot with interactively developing
-programs. It is my preferred way of writing small Scala
+programs. It is my preferred way of writing small Scala programs. Once
-programs. Once you installed Scala, you can start the interpreter by
+you installed Scala, you can start the interpreter by typing on the
-typing on the command line:
+command line:
 \begin{lstlisting}[language={},numbers=none,basicstyle=\ttfamily\small]
 $ scala
-Welcome to Scala 2.13.9 (OpenJDK 64-Bit Server VM, Java 17.0.1).
+Welcome to Scala 3.3.1 (17.0.8.1, Java OpenJDK 64-Bit Server VM).
 Type in expressions for evaluation. Or try :help.
 scala>
 \end{lstlisting}%$
 \noindent The precise response may vary depending
-on the version and platform where you installed Scala. At the Scala
+on the version and platform where you installed Scala. Make sure
+you have installed Scala version 3. At the Scala
 prompt you can type things like \code{2 + 3}\;\keys{Ret} and
 the output will be
-\begin{lstlisting}[numbers=none]
+\begin{lstlisting}[numbers=none,language={}]
 scala> 2 + 3
-res0: Int = 5
+val res0: Int = 5
 \end{lstlisting}
 \noindent The answer means that he result of the addition is of type
 \code{Int} and the actual result is 5; \code{res0} is a name that
 Scala gives automatically to the result. You can reuse this name later
 on, for example
-\begin{lstlisting}[numbers=none]
+\begin{lstlisting}[numbers=none,language={}]
 scala> res0 + 4
-res1: Int = 9
+val res1: Int = 9
 \end{lstlisting}
 \noindent
 Another classic example you can try out is
-\begin{lstlisting}[numbers=none]
+\begin{lstlisting}[numbers=none,language={}]
 scala> print("hello world")
 hello world
 \end{lstlisting}
 \noindent Note that in this case there is no result. The
 \noindent You might need to adapt the path to where you have
 installed Scala.
 \subsection*{Values}
+\begin{tcolorbox}[colback=red!5!white,colframe=red!75!black]
+Do not use \code{var} in your code for PEP! This declares a mutable variable.
+Only use \code{val}!
+\end{tcolorbox}\medskip
+\noindent
 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. The keyword for defining values is \code{val}.
 For example
 \begin{lstlisting}[numbers=none]
 scala> val x = 42
-x: Int = 42
+val x: Int = 42
 scala> val y = 3 + 4
-y: Int = 7
+val y: Int = 7
 scala> val z = x / y
-z: Int = 6
+val z: Int = 6
 \end{lstlisting}
 \noindent
 As can be seen, we first define \code{x} and {y} with admittedly some silly
 expressions, and then reuse these values in the definition of \code{z}.
 \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
+-- [E052] Type Error: -----------------------------------
-z = 9
+1 |z = 9
-^
+|^^^^^
+|Reassignment to val z
+| ...
+1 error found
 \end{lstlisting}
 \noindent
 So it would be a bit absurd to call values as variables...you cannot
 change them; they cannot vary. You might think you can reassign them like
 \noindent
 where each argument, \texttt{arg1}, \texttt{arg2} and so on, requires
 its type and the result type of the
 function, \code{rty}, should also be given. If the body of the function is
-more complex, then it can be enclosed in braces, like above. If it it
+more complex, then it can be enclosed in braces, like above. If it
 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 =
 if (n == 0) 1 else n * fact(n - 1)
 \end{lstlisting}
 \noindent
-We could also have written this with braces as
+where we have to give the return type \code{Int}. Note we could also
+have written this with braces 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 overkill for a small function like \code{fact}.
-Note that Scala does not have a \code{then}-keyword in an
+Notice that Scala does not have a \code{then}-keyword in an
 \code{if}-statement. Also important is that there should be always an
 \code{else}-branch. Never write an \code{if} without an \code{else},
 unless you know what you are doing! While \code{def} is the main
 mechanism for defining functions, there are a few other ways for doing
 this. We will see some of them in the next sections.
 So in the absence of \code{return}, what value does a Scala function
 actually produce? A rule-of-thumb is whatever is in the last line of the
 function is the value that will be returned. Consider the following
 example:\footnote{We could have written this function in just one line,
-but for the sake of argument lets keep the two intermediate values.}
+but for the sake of argument let's keep the two intermediate values.}
 \begin{lstlisting}[numbers=none]
 def average(xs: List[Int]) : Int = {
 val s = xs.sum
 val n = xs.length
 s / n
 }
 \end{lstlisting}
 \noindent
-Here the function still only returns the expression in the last line.
+Here the function still only returns the expression \code{s / n} in
-The \code{println} before just prints out some information about the
+the last line.  The \code{println} before just prints out some
-input of this function, but does not contribute to the result of the
+information about the input of this function, but does not contribute
-function. Similarly, the value \code{h} is used in the \code{println}
+to the result of the function. Similarly, the value \code{h} is used
-but does not contribute to what integer is returned.
+in the \code{println} but does not contribute to what integer is
+returned by the function.
 A caveat is that the idea with the ``last line'' is only a rough
 rule-of-thumb. A better rule might be: the last expression that is
 evaluated in the function. Consider the following version of
 \code{average}:
 \end{lstlisting}
 \noindent
 which still satisfies the rule-of-thumb.
+\begin{tcolorbox}[colback=red!5!white,colframe=red!75!black]
+Do not use \code{return} in your code to indicate what a function
+produces as a result! It has a different meaning in Scala than in
+Java. It can change the meaning of your program, and you should
+never use it.
+\end{tcolorbox}
 \subsection*{Loops, or Better the Absence Thereof}
 Coming from Java or C/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,
 let us assume you have a list of numbers from 1 to 8 and want to
 build the list of squares. The list of numbers from 1 to 8
 can be constructed in Scala as follows:
-\begin{lstlisting}[numbers=none]
+\begin{lstlisting}[numbers=none,language={}]
 scala> (1 to 8).toList
-res1: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8)
+val res1: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8)
 \end{lstlisting}
 \noindent Generating from this list the list of corresponding
 squares in a programming language such as Java, you would assume
 the list is given as a kind of array. You would then iterate, or loop,
 \code{yield}. Squaring the numbers from 1 to 8 with a for-comprehension
 would look as follows:
 \begin{lstlisting}[numbers=none]
 scala> for (n <- (1 to 8).toList) yield n * n
-res2: List[Int] = List(1, 4, 9, 16, 25, 36, 49, 64)
+val res2: List[Int] = List(1, 4, 9, 16, 25, 36, 49, 64)
 \end{lstlisting}
 \noindent  This for-comprehension states that from the list of numbers
 we draw some elements. We use the name \code{n} to range over these
 elements (whereby the name is arbitrary; we could use something more
 scala> for (n <- (1 to 8).toList) yield {
 val i = n + 1
 val j = n - 1
 i * j + 1
 }
-res3: List[Int] = List(1, 4, 9, 16, 25, 36, 49, 64)
+val res3: List[Int] = List(1, 4, 9, 16, 25, 36, 49, 64)
 \end{lstlisting}
-As you can see in for-comprehensions above, we specified the list where
+Let us come back to the simple example of squaring a list of numbers.
-each \code{n} comes from, namely \code{(1 to 8).toList}, and how each
+As you can see in the for-comprehensions above, we specified the list
-element needs to be transformed. This can also be expressed in a second
+where each \code{n} comes from, namely \code{(1 to 8).toList}, and how
-way in Scala by using directly the function \code{map} as follows:
+each element needs to be transformed, the expression after the
+\code{yield}. This can also be expressed in a second way in Scala by
-\begin{lstlisting}[numbers=none]
+using directly the function \code{map} as follows:
+\begin{lstlisting}[numbers=none,language={}]
 scala> (1 to 8).toList.map(n => n * n)
-res3 = List(1, 4, 9, 16, 25, 36, 49, 64)
+val res3 = List(1, 4, 9, 16, 25, 36, 49, 64)
 \end{lstlisting}
 \noindent In this way, the expression \code{n => n * n} stands for the
 function that calculates the square (this is how the \code{n}s are
 transformed by the map).  It might not be obvious, but
 The very charming feature of Scala is that such maps or
 for-comprehensions can be written for any kind of data collection, such
 as lists, sets, vectors, options and so on. For example if we instead
 compute the remainders modulo 3 of this list, we can write
-\begin{lstlisting}[numbers=none]
+\begin{lstlisting}[numbers=none,language={}]
 scala> (1 to 8).toList.map(n => n % 3)
-res4 = List(1, 2, 0, 1, 2, 0, 1, 2)
+val res4 = List(1, 2, 0, 1, 2, 0, 1, 2)
 \end{lstlisting}
 \noindent If we, however, transform the numbers 1 to 8 not
 into a list, but into a set, and then compute the remainders
 modulo 3 we obtain
-\begin{lstlisting}[numbers=none]
+\begin{lstlisting}[numbers=none,language={}]
-scala> (1 to 8).toSet[Int].map(n => n % 3)
+scala> (1 to 8).toSet.map(n => n % 3)
-res5 = Set(2, 1, 0)
+val res5 = Set(2, 1, 0)
 \end{lstlisting}
-\noindent This\footnote{This returns actually \code{HashSet(2, 1, 3)},
+\noindent This\footnote{This returns actually \code{HashSet(1, 2, 3)},
 but this is just an implementation detail of how sets are implemented in
 Scala.} is the correct result for sets, as there are only three
-equivalence classes of integers modulo 3. Note that in this example we
+equivalence classes of integers modulo 3.  Since maps and
-need to ``help'' Scala to transform the numbers into a set of integers
-by explicitly annotating the type \code{Int}. Since maps and
 for-comprehensions are just syntactic variants of each other, the latter
 can also be written as
 \begin{lstlisting}[numbers=none]
-scala> for (n <- (1 to 8).toSet[Int]) yield n % 3
+scala> for (n <- (1 to 8).toSet) yield n % 3
-res5 = Set(2, 1, 0)
+val res5 = Set(2, 1, 0)
 \end{lstlisting}
 For-comprehensions can also be nested and the selection of
-elements can be guarded. For example if we want to pair up
+elements can be guarded (or filtered). For example if we want to pair up
 the numbers 1 to 4 with the letters a to c, we can write
 \begin{lstlisting}[numbers=none]
 scala> for (n <- (1 to 4).toList;
 m <- ('a' to 'c').toList) yield (n, m)
-res6 = List((1,a), (1,b), (1,c), (2,a), (2,b), (2,c),
+val res6 = List((1,a), (1,b), (1,c), (2,a), (2,b), (2,c),
 (3,a), (3,b), (3,c), (4,a), (4,b), (4,c))
 \end{lstlisting}
 \noindent
 In this example the for-comprehension ranges over two lists, and
 produces a list of pairs as output. Or, if we want to find all pairs of
 \begin{lstlisting}[numbers=none]
 scala> for (n <- (1 to 3).toList;
 m <- (1 to 3).toList;
 if (n + m) % 2 == 0) yield (n, m)
-res7 = List((1,1), (1,3), (2,2), (3,1), (3,3))
+val res7 = List((1,1), (1,3), (2,2), (3,1), (3,3))
 \end{lstlisting}
 \noindent The \code{if}-condition in this for-comprehension filters out
 all pairs where the sum is not even (therefore \code{(1, 2)}, \code{(2,
 1)} and \code{(3, 2)} are not in the result because their sum is odd).
 \begin{lstlisting}[numbers=none]
 scala> val cs = ('a' to 'h').toList
 scala> for (n <- (0 until cs.length).toList)
 yield cs(n).capitalize
-res8: List[Char] = List(A, B, C, D, E, F, G, H)
+val res8: List[Char] = List(A, B, C, D, E, F, G, H)
 \end{lstlisting}
 \noindent
 This is accepted Scala-code, but utterly bad style (it is more like
 Java). It can be written much clearer as:
 \begin{lstlisting}[numbers=none]
 scala> val cs = ('a' to 'h').toList
 scala> for (c <- cs) yield c.capitalize
-res9: List[Char] = List(A, B, C, D, E, F, G, H)
+val res9: List[Char] = List(A, B, C, D, E, F, G, H)
 \end{lstlisting}
 \subsection*{Results and Side-Effects}
 While hopefully all this about maps looks reasonable, there is one
 12345
 \end{lstlisting}
 \noindent
 where you need to omit the keyword \code{yield}. You can
-also do more elaborate calculations such as
+also do more elaborate calculations before printingh such as
 \begin{lstlisting}[numbers=none]
 scala> for (n <- (1 to 5).toList) {
 val square = n * n
 println(s"$n * $n = $square")
 \end{lstlisting}%$
 \noindent In this code I use a value assignment (\code{val
 square = ...} ) and also what is called in Scala a
 \emph{string interpolation}, written \code{s"..."}. The latter
-is for printing out an equation. It allows me to refer to the
+is for printing out formatted strings. It allows me to refer to the
 integer values \code{n} and \code{square} inside a string.
 This is very convenient for printing out ``things''.
 The corresponding map construction for functions with
 side-effects is in Scala called \code{foreach}. So you
 \noindent
 As said, this is example is a bit contrived---I was not able to think
 of anything simple, but for example in the Compiler module next year I
 show a compilation functions that needs to generate functions as
 intermediate result. Anyway, notice the interesting type we had to
-annotate to \code{mkfn}. Types of Scala are described next.
+annotate to \code{mkfn}. The types in Scala are described next.
 \subsection*{Types}
 In most functional programming languages, types play an
-important role. Scala is such a language. You have already
+essential role. Scala is such a language. You have already
 seen built-in types, like \code{Int}, \code{Boolean},
 \code{String} and \code{BigInt}, but also user-defined ones,
 like \code{Rexp} (see coursework). Unfortunately, types can be a thorny
 subject, especially in Scala. For example, why do we need to
 give the type to \code{toSet[Int]}, but not to \code{toList}?
 and \code{String}. Compound types take one or more arguments,
 which as seen earlier need to be given in angle-brackets, for
 example \code{List[Int]} or \code{Set[List[String]]} or
 \code{Map[Int, Int]}.
+Scala provides a basic mechanism to check the type of a (closed)
+expression---closed means that all parts are already known to Scala.
+Then you can use the command \code{:type} and check in the REPL:
+\begin{lstlisting}[ numbers=none]
+scala> :type (1, List(3), Set(4,5), "hello")
+(Int, List[Int], Set[Int], String)
+\end{lstlisting}
+\noindent
+If Scala can calculate the type of the given expression, then it
+will print it. Unfortunately, this way of finding out a type is almost
+unusable: for `things' where the type is pretty obvious, it gives an
+answer; but for `things' that are actually of interest (such as
+what is the type of a pre-defined function), it gives up with
+an error message.
 There are a few special type-constructors that fall outside
 this pattern. One is for tuples, where the type is written
 with parentheses. For example
 \begin{lstlisting}[ numbers=none]
 res6 = true
 \end{lstlisting}
 You might ask: Apart from silly functions like above, what is
 the point of having functions as input arguments to other
-functions? In Java there is indeed no need of this kind of
+functions?
-feature: at least in the past it did not allow such
+%In Java there is indeed no need of this kind of
-constructions. I think, the point of Java 8 and successors was to lift this
+%feature: at least in the past it did not allow such
-restriction. But in all functional programming languages,
+%constructions. I think, the point of Java 8 and successors was to lift this
+%restriction.
+Well, in all functional programming languages,
 including Scala, it is really essential to allow functions as
 input argument. Above you have already seen \code{map} and
 \code{foreach} which need this feature. Consider the functions
 \code{print} and \code{println}, which both print out strings,
 but the latter adds a line break. You can call \code{foreach}
 \begin{lstlisting}[language=Scala]
 def output(s: String): Unit = println(s)/*!\annotation{Scala}!*/
 \end{lstlisting}\bigskip
 \noindent
-Type for list of Strings:
+Compound types, say the type for list of Strings:
 \begin{lstlisting}[language=Java]
 List<String>/*!\annotation{Java}!*/
 \end{lstlisting}
 \subsection*{More Info}
 There is much more to Scala than I can possibly describe in
-this document and teach in the lectures. Fortunately there are a
+this short document and teach in the lectures. Fortunately there are a
 number of free books
 about Scala and of course lots of help online. For example
 \begin{itemize}
 %%\item \url{http://www.scala-lang.org/docu/files/ScalaByExample.pdf}
 \begin{itemize}
 \item \small\url{http://docs.scala-lang.org/tutorials/scala-for-java-programmers.html}
 \end{itemize}
 While I am quite enthusiastic about Scala, I am also happy to
-admit that it has more than its fair share of faults. The
+admit that it has more than its fair share of faults.
-problem seen earlier of having to give an explicit type to
+%The
-\code{toSet}, but not \code{toList} is one of them. There are
+%problem seen earlier of having to give an explicit type to
-also many ``deep'' ideas about types in Scala, which even to
+%\code{toSet}, but not \code{toList} is one of them. There are
-me as seasoned functional programmer are puzzling. Whilst
+%also many ``deep'' ideas about types in Scala, which even to
+%me as seasoned functional programmer are puzzling.
+For example, whilst
 implicits are great, they can also be a source of great
 headaches, for example consider the code:
 \begin{lstlisting}[numbers=none]
 scala>  List (1, 2, 3) contains "your mom"
 like the steep learning curve of Scala and also that new versions of
 Scala often introduced incompatibilities in old code. Also the Java
 language is lately developing at lightening speed (in comparison to the past)
 taking on many
 features of Scala and other languages, and it seems it even introduces
-new features on its own.
+new features on its own. So there is seemingly even more incentive to
+stick with the old stuff you know.
 Scala is deep: After many years, I still continue to learn new technique
-for writing more elegant code. Unfortunately, I have not yet managed to
+for writing more elegant code.
-switch over my code to Scala 3.0 due to time constraints. Scala 3 seems
+%Unfortunately, I have not yet managed to
+%switch over my code to Scala 3.0 due to time constraints.
+Scala 3 seems
 to iron out a number of snags from Scala 2, but why on earth are they
 introducing Python-esque indentation and why on earth are they
 re-introducing the \texttt{then}-keyword in Scala 3, when I just about got
 comfortable without it?

changeset 470	86a456f8cb92
parent 442	c86e7dd198bf
child 471	135bf034ac30