LaTeX-examples/documents/Programmierparadigmen/Scala.tex

%!TEX root = Programmierparadigmen.tex
\chapter{Scala}
\index{Scala|(}

Scala ist eine objektorientierte und funktionale Programmiersprache, die auf der JVM aufbaut und in Java Bytecode kompiliert wird. Scala bedeutet \underline{sca}lable
\underline{la}nguage.

Mit sog. \enquote{actors} bietet Scala eine Unterstützung für die Entwicklung
prallel ausführender Programme.

Weitere Materialien sind unter \url{http://www.scala-lang.org/} und
\url{http://www.simplyscala.com/} zu finden.

\section{Erste Schritte}
Scala kann auf Debian-basierten Systemen durch das Paket \texttt{scala} installiert
werden. Für andere Systeme stehen auf \url{http://www.scala-lang.org/download/}
verschiedene Binärdateien bereit.

\subsection{Hello World}
\subsubsection{Interaktiv}
\inputminted[numbersep=5pt, tabsize=4]{bash}{scripts/scala/scala-test.scala}
Es kann mit \texttt{./scala-test.scala Scala funktioniert} ausgeführt werden.

\subsubsection{Kompiliert}
\inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=hello-world.scala]{scala}{scripts/scala/hello-world.scala}

Dieses Beispiel kann mit \texttt{scalac hello-world.scala} kompiliert und mit
\texttt{scala HelloWorld} ausgeführt werden.

\section{Vergleich mit Java}
Scala und Java haben einige Gemeinsamkeiten, wie den Java Bytecode, aber auch
einige Unterschiede.

\noindent\parbox[t]{2.4in}{\raggedright%
\textbf{\textit{Gemeinsamkeiten}}
\begin{itemize}[topsep=0pt,itemsep=-2pt,leftmargin=13pt]
    \item Java Bytecode
    \item Keine Mehrfachvererbung
    \item Statische Typisierung
    \item Scopes
\end{itemize}
}%
\parbox[t]{2.4in}{\raggedright%
\textbf{\textit{Unterschiede}}
\begin{itemize}[topsep=0pt,itemsep=-2pt,leftmargin=13pt]
    \item Java hat Interfaces, Scala hat traits.
    \item Java hat primitive Typen, Scala ausschließlich Objekte.
    \item Scala benötigt kein \texttt{;} am Ende von Anweisungen.
    \item Scala ist kompakter.
    \item Java hat \texttt{static}, Scala hat \texttt{object} (Singleton)
\end{itemize}
}

Weitere Informationen hat Graham Lea unter \url{http://tinyurl.com/scala-hello-world} zur Verfügung gestellt.

\section{Syntax}
In Scala gibt es sog. \textit{values}, die durch das Schlüsselwort \texttt{val}\xindex{val (Scala)@\texttt{val} (Scala)}
angezeigt werden. Diese sind Konstanten. Die Syntax ist der UML-Syntax ähnlich.

\inputminted[numbersep=5pt, tabsize=4]{scala}{scripts/scala/val-syntax.scala}

Variablen werden durch das Schlüsselwort \texttt{var}\xindex{var (Scala)@\texttt{var} (Scala)} angezeigt:

\inputminted[numbersep=5pt, tabsize=4]{scala}{scripts/scala/var-syntax.scala}

Methoden werden mit dem Schlüsselwort \texttt{def}\xindex{def (def)@\texttt{def} (Scala)} erzeugt:

\inputminted[numbersep=5pt, tabsize=4]{scala}{scripts/scala/method-syntax.scala}

Klassen werden wie folgt erstellt:
\inputminted[numbersep=5pt, tabsize=4]{scala}{scripts/scala/simple-class-example.scala}

und so instanziiert:
\inputminted[numbersep=5pt, tabsize=4]{scala}{scripts/scala/simple-class-instanciation.scala}

\subsection{Schleifen}\xindex{for (Scala)@\texttt{for} (Scala)}
Eine einfache \texttt{for}-Schleife sieht wie folgt aus:

\inputminted[numbersep=5pt, tabsize=4]{scala}{scripts/scala/extended-for.scala}

Listen können erstellt und durchgegangen werden:

\inputminted[numbersep=5pt, tabsize=4]{scala}{scripts/scala/extended-for.scala}

\subsection{Logische Operatoren}
\begin{table}[H]
    \centering 
    \begin{tabular}{CCCC}
    UND    & ODER     & Wahr  & Falsch \\ \hline\hline
    \&\&   & ||       & true  & false \\[4ex]
    GLEICH & UNGLEICH & NICHT & ~     \\ \hline\hline
    ==     & !=       & !     & ~     \\ 
    \end{tabular}
    \caption{Logische Operatoren in Scala}\xindex{Logische Operatoren!Scala}
\end{table}

\section{Datenstrukturen}
\subsection{Listen}

\begin{itemize}
    \item Erstellt man mit \verb+var myList = List();+
    \item Zugriff auf das \verb+i+-te Element mit \verb+myList(i)+
\end{itemize}

\subsection{Tupel}

\begin{itemize}
    \item Erstellt man mit \verb+var myTuple = (el1, el2, el3)+
    \item Zugriff auf das \verb+i+-te Element mit \verb+myTuple._i+
\end{itemize}

\section{Companion Object}\xindex{Companion Object}
Ein Companion Object ist ein Objekt mit dem Namen einer Klasse oder eines Traits.
Im Gegensatz zu anderen Objekten / Traits hat das Companion Object zugriff auf
die Klasse.

\section{actor}
\begin{definition}[Aktor]\xindex{Aktor}\index{actor|see{Aktor}}
    Ein \textit{Aktor} ist ein Prozess, der Nebenläufig zu anderen Aktoren
    läuft. Er kommuniziert mit anderen Aktoren, indem er Nachrichten austauscht.
\end{definition}

Das folgende Wetter-Beispiel zeigt, wie man Aktoren benutzen kann.

\subsection{Message Passing}\xindex{"! (Scala)}%
Prozesse können nach dem Schema \texttt{adresse ! Nachricht} Nachrichten austauschen.
Dieses Schema ist asynchron.

Prozesse können mit \texttt{receive{case x => print(x)}} Nachrichten empfangen,
wobei in diesem Beispiel \texttt{x} alles matcht. Wenn eine gesendete Nachricht
vom Empfänger nicht gematcht wird, bleibt sie dennoch gespeichert.

\section{Weiteres}
\texttt{def awaitAll(timeout: Long, fts: Future[Any]*):}\\
\-\hspace{1.8cm}\texttt{List[Option[Any]]}\xindex{awaitAll}\\
\-\hspace{0.8cm}$\leftharpoonup$ \texttt{scala.actors.Futures.\_}

Waits until either all futures are resolved or a given time span has passed. Results are collected in a list of options. The result of a future that resolved during the time span is its value wrapped in Some. The result of a future that did not resolve during the time span is None.

Note that some of the futures might already have been awaited, in which case their value is returned wrapped in Some. Passing a timeout of 0 causes awaitAll to return immediately.


\section{Beispiele}
\subsection{Wetter}
Das folgende Script sendet parallel Anfragen über verschiedene ZIP-Codes an
die Yahoo-Server, parst das XML und extrahiert die Stadt sowie die Temperatur:

\inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=weather.scala]{scala}{scripts/scala/weather.scala}

\subsection{High Product}
Das folgende Skript berechnet folgendes: Wenn man aus den Ziffern 0 - 9 zwei
Zahlen $a$, $b$ bilden darf, welche Zahlen muss man dann bilden um das größte Produkt
$a \cdot b$ zu erhalten?

\inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=main.scala]{scala}{scripts/scala/HighProduct.scala}

\subsection{Potenzierung}
Will man Zweierpotenzen bilden, so kann man die Berechnung beschleunigen, in dem
man immer wieder Quadriert:

\inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=power-futures.scala]{scala}{scripts/scala/power-futures.scala}

\section{Weitere Informationen}
\begin{itemize}
    \item \url{http://www.scala-lang.org/api}
    \item \url{http://docs.scala-lang.org/style/naming-conventions.html}
\end{itemize}

\index{Scala|)}