\documentclass{article}

\usepackage{../style}

\usepackage{../langs}

\usepackage{marvosym}

%cheat sheet

%http://worldline.github.io/scala-cheatsheet/

% case class, apply, unapply

% see https://medium.com/@thejasbabu/scala-pattern-matching-9c9e73ba9a8a

\begin{document}

\fnote{\copyright{} Christian Urban, King's College London, 2017, 2018}

\section*{A Crash-Course in Scala}

\mbox{}\hfill\textit{``Scala --- \underline{S}lowly \underline{c}ompiled 

\underline{a}cademic \underline{la}nguage''}\smallskip\\

\noindent

Scala is a programming language that combines functional and

object-oriented programming-styles. It has received quite a bit of

attention in the last five or so years. One reason for this attention is

that, like the Java programming language, Scala compiles to the Java

Virtual Machine (JVM) and therefore Scala programs can run under MacOSX,

Linux and Windows.\footnote{There are also experimental backends of

Scala for producing code under Android (\url{http://scala-android.org});

have a native Scala compiler generating X86-code

(\url{http://www.scala-native.org}).} Because of this it has also access to

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, LinkedIn,

Netflix to name a few---either use Scala exclusively in production code,

job-interviews (especially in Data Science) according to this anecdotal

report

\begin{quote}

\url{http://techcrunch.com/2016/06/14/scala-is-the-new-golden-child}

\end{quote}

\noindent

The official Scala compiler can be downloaded from

\begin{quote}

\url{http://www.scala-lang.org}

\end{quote}

\noindent

I found a convenient IDE for Scala programming is Microsoft's

\textit{Visual Studio Code} (VS Code) which runs under MacOSX, Linux and

obviously Windows. It can be downloaded for free from

\begin{quote}

\url{https://code.visualstudio.com}

\end{quote}

\noindent

and should already come pre-installed in the Department (together with

the Scala compiler). VS Code is 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 easier (see

Figure~\ref{vscode} for my own setup).

\begin{figure}[t]

\begin{center}  

\includegraphics[scale=0.15]{../pics/vscode.png}\\[-10mm]\mbox{}

\end{center}

\caption{My personal installation of VS Code includes the following

packages from Marketplace: Scala Syntax (official), Code Runner, Code

Spell Checker, Rewrap and Subtle Match Brackets. I have also bound keys

\keys{\^{}} \keys{Ret} to the action

``Run-Selected-Text-In-Active-Terminal'' in order to quickly evaluate

small code snippets in the Scala REPL.\label{vscode}}

\end{figure}  

What I like most about VS Code is that it provides an easy access to the

Scala REPL. But if you prefer your own editor for coding, it

is also painless to work with Scala completely on the command line (like you

might have done with \texttt{g++} in the earlier part of PEP). For the

lazybones among us, there is even an online editor and environment for

developing and running Scala programs called \textit{ScalaFiddle}, which

requires zero setup (assuming you have a browser handy). You can access

it from:

\begin{quote}

\url{https://scalafiddle.io}

\end{quote}

A ready-made Scala bundle for Eclipse is available from

\begin{quote}

\url{http://scala-ide.org/download/sdk.html}

\end{quote}

\noindent

Also IntelliJ includes plugins for Scala. \textbf{BUT}, I do 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 we will write in this module. They are really meant to be used

when you have a million-lines codebase, rather than our

``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? ;o)

\subsection*{Why Functional Programming?}

Before we go on, let me explain a bit more why we want to inflict

upon you another programming language. You hopefully have mastered Java and

C++\ldots{}the world should be your oyster, no? Well, it is not that

easy. We require Scala in PEP, but actually we do not deeply care

whether you learn Scala---after all it is just a programming language

(albeit a nifty one IMHO). What we do care about is that you learn about

\textit{functional programming}. Scala is just the vehicle for that.

Very likely writing programs in a functional programming language is

\begin{lstlisting}[language=C,numbers=none]

  for (int i = 10; i < 20; i++) { 

      ...Do something interesting with i...

   }

\end{lstlisting}

\noindent Here the variable \texttt{i} embodies the state, which is

first set to \texttt{10} and then increased by one in each

\noindent

\ldots{}Well, it is perfectly benign if you have a sequential program

that gets run instruction by instruction...nicely one after another.

This kind of running code uses a single core of your CPU and goes as

fast as your CPU frequency (or clock-speed) allows. Unfortunately, this

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 core you have available (typically 4 in modern laptops and

The idea of functional programming is to eliminate any state from

\begin{figure}[p]

\end{figure}  

\subsection*{The Very Basics}

One advantage of Scala over Java is that it 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. This is really my preferred way of writing small Scala

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.6 (Java HotSpot(TM) 64-Bit Server VM, Java 9).

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

prompt you can type things like \code{2 + 3}\;\keys{Ret} and

the output will be

\begin{lstlisting}[numbers=none]

scala> 2 + 3

res0: Int = 5

\end{lstlisting}

\noindent indicating that the 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. 

\begin{lstlisting}[numbers=none]

scala> res0 + 4

res1: Int = 9

\end{lstlisting}

\noindent

Another classic example you can try out is

\begin{lstlisting}[numbers=none]

scala> print("hello world")

hello world

\end{lstlisting}

\noindent Note that in this case there is no result. The

reason is that \code{print} does not actually produce a result

(there is no \code{resX} and no type), rather it is a

function that causes the \emph{side-effect} of printing out a

string. Once you are more familiar with the functional

programming-style, you will know what the difference is

between a function that returns a result, like addition, and a

function that causes a side-effect, like \code{print}. We

shall come back to this point later, but if you are curious

now, the latter kind of functions always has \code{Unit} as

return type. It is just not printed.

You can try more examples with the Scala REPL, but feel free to

first guess what the result is (not all answers by Scala are obvious):

\begin{lstlisting}[numbers=none]

scala> 2 + 2

scala> 1 / 2

scala> 1.0 / 2

scala> 1 / 2.0

scala> 1 / 0

scala> 1.0 / 0.0

scala> true == false

scala> true && false

scala> 1 > 1.0

scala> "12345".length

scala> List(1,2,1).size

scala> Set(1,2,1).size

\end{lstlisting}\smallskip

\noindent

Please take the Scala REPL seriously: If you want to take advantage of my

reference implementation for the assignments, you will need to be

able to ``play around'' with it!

\subsection*{Standalone Scala Apps}

If you want to write a stand-alone app in Scala, you can

implement an object that is an instance of \code{App}, say

\begin{lstlisting}[numbers=none]

object Hello extends App {

    println("hello world")

}

\end{lstlisting}

\noindent save it in a file, for example {\tt hello-world.scala}, and

then run the compiler (\texttt{scalac}) and followed by the runtime

environment (\texttt{scala}):

\begin{lstlisting}[language={},numbers=none,basicstyle=\ttfamily\small]

$ scalac hello-world.scala

$ scala Hello

hello world

\end{lstlisting}

\noindent

Like Java, Scala targets the JVM and consequently

Scala programs can also be executed by the bog-standard Java

Runtime. This only requires the inclusion of {\tt

scala-library.jar}, which on my computer can be done as

follows:

\begin{lstlisting}[language={},numbers=none,basicstyle=\ttfamily\small]

$ scalac hello-world.scala

$ java -cp /usr/local/src/scala/lib/scala-library.jar:. Hello

hello world

\end{lstlisting}

\noindent You might need to adapt the path to where you have

installed Scala.

\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

\begin{lstlisting}[numbers=none]

scala> val x = 42

x: Int = 42

scala> val y = 3 + 4

y: Int = 7

scala> val z = x / y

z: Int = 6

\end{lstlisting}

\noindent

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

         ^

\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 re-assign them like

\begin{lstlisting}[numbers=none]

scala> val x = 42

scala> val z = x / 7

scala> val x = 70

scala> println(z) 

\end{lstlisting}

\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.

\subsection*{Function Definitions}

We do functional programming! So defining functions will be our main occupation.

As an example, a function named \code{f} taking a single argument of type 

\code{Int} can be defined in Scala as follows:

\begin{lstlisting}[numbers=none]

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

of type \code{String}. It is a good habit to include this information

about the return type always. Simple examples of Scala functions are:

\begin{lstlisting}[numbers=none]

def incr(x: Int) : Int = x + 1

def double(x: Int) : Int = x + x

def square(x: Int) : Int = x * x

\end{lstlisting}

\noindent

The general scheme for a function is

\begin{lstlisting}[numbers=none]

def fname(arg1: ty1, arg2: ty2,..., argn: tyn): rty = {

  BODY

}

\end{lstlisting}

\noindent

where each argument requires its type and the result type of the

function, \code{rty}, should be given. If the body of the function is

more complex, then it can be enclosed in braces, like above. If it it

is just a simple expression, like \code{x + 1}, you can omit the

braces. Very often functions are recursive (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}

\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,

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]

scala> (1 to 8).toList

res1: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8)

\end{lstlisting}

\noindent Generating from this list, the list of 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,

an index over this array and replace each entry in the array

by the square. Right? In Scala, and in other functional

programming languages, you use maps to achieve the same. 

A map essentially takes a function that describes how each

element is transformed (for example squared) and a list over

which this function should work. There are two forms to

express such maps in Scala. The first way is called a

\emph{for-comprehension}. Squaring the numbers from 1 to 8

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)

\end{lstlisting}

\noindent The important keywords are \code{for} and

\code{yield}. This for-comprehension roughly states that from

the list of numbers we draw \code{n}s and compute the result

of \code{n * n}. As you can see, we specified the list where

each \code{n} comes from, namely \code{(1 to 8).toList}, and

how each element needs to be transformed. This can also be

expressed in a second way in Scala by using directly

\code{map}s as follows:

\begin{lstlisting}[numbers=none]

scala> (1 to 8).toList.map(n => n * n)

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). This expression for functions

might remind you of your lessons about the lambda-calculus

where this would have been written as $\lambda n.\,n * n$. It

might not be obvious, but for-comprehensions are just

syntactic sugar: when compiling, Scala translates

for-comprehensions into equivalent maps. This even works

when for-comprehensions get more complicated (see below).

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 reminders modulo 3 of

this list, we can write

\begin{lstlisting}[numbers=none]

scala> (1 to 8).toList.map(n => n % 3)

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 reminders

modulo 3 we obtain

\begin{lstlisting}[numbers=none]

scala> (1 to 8).toSet[Int].map(n => n % 3)

res5 = Set(2, 1, 0)

\end{lstlisting}