afl-material: comparison handouts/scala-ho.tex

equal deleted inserted replaced

-:68d98140b90b
+:de4f6382590a
 \begin{document}
 \section*{A Crash-Course on Scala}
 Scala is a programming language that combines functional and
-object-oriented programming-styles, and has received in the
+object-oriented programming-styles. It has received in the
 last five years or so quite a bit of attention. 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 for
 Why do I use Scala in the AFL module? Actually, you can do
 \emph{any} part of the coursework in \emph{any} programming
 language you like. I use Scala for showing you code during the
 lectures because its functional programming-style allows me to
 implement the functions we will discuss with very small
-code-snippets. If I had to do this in Java, for example, I
+code-snippets. If I had to do this in Java, I would first have
-would first have to go through heaps of boilerplate code and
+to go through heaps of boilerplate code and the code-snippets
-the code-snippets would not look pretty. Since the Scala
+would not look pretty. Since the Scala compiler is free, you
-compiler is free, you can download the code-snippets and run
+can download the code-snippets and run every example I give.
-every example I give. But if you prefer, you can also easily
+But if you prefer, you can also easily translate them into any
-translate them into any other functional language, for example
+other functional language, for example Haskell, Standard ML,
-Haskell, Standard ML, F$^\#$, Ocaml and so on.
+F$^\#$, Ocaml and so on.
 Developing programs in Scala can be done with the Eclipse IDE
 and also with IntelliJ IDE, but for the small programs I will
 develop the good old Emacs-editor is adequate for me and I
 will run the programs on the command line. One advantage of
 \noindent The precise response may vary due to the 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}[language=Scala,numbers=none]
+\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. Another classic
 example you can try out is
-\begin{lstlisting}[language=Scala,numbers=none]
+\begin{lstlisting}[numbers=none]
 scala> print("hello world")
 hello world
 \end{lstlisting}
 \noindent Note that in this case there is no result. The
 \code{Unit}.
 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}[language=Scala,numbers=none]
+\begin{lstlisting}[numbers=none]
 object Hello extends App {
-println ("hello world")
+println("hello world")
 }
 \end{lstlisting}
 \noindent save it in a file, say {\tt hello-world.scala}, and
 then run the compiler and runtime environment:
 clause in the grammar. The cases for $\varnothing$ and
 $\epsilon$ do not have any arguments, while in all the other
 cases we do have arguments. For example the character regular
 expression needs to take as an argument the character it is
 supposed to recognise. In Scala, the cases without arguments
-are called \emph{case objects}, while the ones with arguments
+are called \emph{case objects}, whereas the ones with
-are \emph{case classes}. The corresponding Scala code is as
+arguments are \emph{case classes}. The corresponding Scala
-follows:
+code is as follows:
-\begin{lstlisting}[language=Scala,numbers=none]
+\begin{lstlisting}[numbers=none]
 abstract class Rexp
 case object NULL extends Rexp
 case object EMPTY extends Rexp
 case class CHAR (c: Char) extends Rexp
 case class SEQ (r1: Rexp, r2: Rexp) extends Rexp
 later section we will see how we can support the more
 mathematical infix notation for regular expression operators
 in Scala. If you want to assign this regular expression to a
 variable, you can use the keyword \code{val} and type
-\begin{lstlisting}[language=Scala,numbers=none]
+\begin{lstlisting}[numbers=none]
 scala> val r = ALT(CHAR('a'), CHAR('b'))
 r: ALT = ALT(CHAR(a),CHAR(b))
 \end{lstlisting}
 \noindent As you can see, in order to make such assignments,
 abstract class. But in this case there is no need to give
 \code{r} the more general type of \code{Rexp}. This is
 different if you want to form a list of regular expressions,
 for example
-\begin{lstlisting}[language=Scala,numbers=none]
+\begin{lstlisting}[numbers=none]
 scala> val ls = List(ALT(CHAR('a'), CHAR('b')), NULL)
 ls: List[Rexp] = List(ALT(CHAR(a),CHAR(b)), NULL)
 \end{lstlisting}
 \noindent In this case, Scala needs to assign a common type to
 easily in Scala. To show you this, lets first consider a
 problem from number theory, called the \emph{Collatz-series},
 which corresponds to a famous unsolved problem in
 mathematics.\footnote{See for example
 \url{http://mathworld.wolfram.com/CollatzProblem.html}.}
-Mathematician define this series as:
+Mathematicians define this series as:
 \[
 collatz_{n + 1} \dn
 \begin{cases}
 \frac{1}{2} * collatz_n & \text{if $collatz_n$ is even}\\
 3 * collatz_n + 1 & \text{if $collatz_n$ is odd}
 \end{cases}
 \]
 \noindent The famous unsolved question is whether this
-series started with any $n > 0$ as $collaz_0$ will always
+series started with any $n > 0$ as $collatz_0$ will always
 return to $1$. This is obvious when started with $1$, and also
 with $2$, but already needs a bit of head-scratching for the
 case of $3$.
 If we want to avoid the head-scratching, we could implement
 this as the following function in Scala:
+\lstinputlisting[numbers=none]{../progs/collatz.scala}
-\lstinputlisting[language=Scala,numbers=none]{../progs/collatz.scala}
 \noindent The keyword for function definitions is \code{def}
 followed by the name of the function. After that you have a
 list of arguments (enclosed in parentheses and separated by
-commas). Each argument in this list needs its type annotated.
+commas). Each argument in this list needs its type to be
-In this case we only have one argument, which is of type
+annotated. In this case we only have one argument, which is of
-\code{BigInt}. This type stands in Scala for arbitrary precision
+type \code{BigInt}. This type stands in Scala for arbitrary
-integers (in case you want to try out the function on really
+precision integers (in case you want to try out the function
-big numbers). After the arguments comes the type of what the
+on really big numbers). After the arguments comes the type of
-function returns---a Boolean in this case for indicating that
+what the function returns---a Boolean in this case for
-the function has reached 1. Finally, after the \code{=}
+indicating that the function has reached 1. Finally, after the
-comes the \emph{body} of the function implementing what the
+\code{=} comes the \emph{body} of the function implementing
-function is supposed to do. What the \code{collatz} function
+what the function is supposed to do. What the \code{collatz}
-does should be pretty self-explanatory: the function first
+function does should be pretty self-explanatory: the function
-tests whether \code{n} is equal to 1 in which case it returns
+first tests whether \code{n} is equal to 1 in which case it
-\code{true} and so on.
+returns \code{true} and so on.
 Notice a quirk in Scala's syntax for \code{if}s: The condition
 needs to be enclosed in parentheses and the then-case comes
 right after the condition---there is no \code{then} keyword in
 Scala.
 define functions by \emph{pattern matching}. In the
 \code{collatz} function above we need to test each case using a
 sequence of \code{if}s. This can be very cumbersome and brittle
 if there are many cases. If we wanted to define a function
 over regular expressions in Java, for example, which does not
-have pattern-matching, the resulting code would be just
+have pattern-matching, the resulting code would just be
 awkward.
 Mathematicians already use the power of pattern-matching when
 they define the function that takes a regular expression and
 produces another regular expression that can recognise the
-reversed strings. The resulting recursive function is often
+reversed strings. They define this function as follows:
-defined as follows:
 \begin{center}
 \begin{tabular}{r@{\hspace{2mm}}c@{\hspace{2mm}}l}
 $rev(\varnothing)$   & $\dn$ & $\varnothing$\\
 $rev(\epsilon)$      & $\dn$ & $\epsilon$\\
 $rev(r_1 \cdot r_2)$ & $\dn$ & $rev(r_2) \cdot rev(r_1)$\\
 $rev(r^*)$                   & $\dn$ & $rev(r)^*$\\
 \end{tabular}
 \end{center}
-\noindent This function is defined by recursion analysing each
+\noindent It is defined by recursion analysing each pattern of
-pattern of what the regular expression could look like. The
+what the regular expression might look like. The corresponding
-corresponding Scala code looks very similar to this
+Scala code looks very similar to this definition, thanks to
-definition, thanks to pattern-matching.
+pattern-matching.
 \lstinputlisting[language=Scala]{../progs/rev.scala}
 \noindent The keyword for starting a pattern-match is
-\code{match} followed by a list of \code{case}s. Before the match
+\code{match} followed by a list of \code{case}s. Before the
-keyword can be another pattern, but often as in the case
+match keyword can be another pattern, but often, as in the
-above, it is just a variable you want to pattern-match
+case above, it is just a variable you want to pattern-match
 (the \code{r} after \code{=} in Line 1).
 Each case in this definition follows the structure of how we
 defined regular expressions as inductive datatype. For example
 the case in Line 3 you can read as: if the regular expression
 \code{rev} produces $ba + ca$, which can recognise the reversed
 strings $ba$ and $ca$.
 In Scala each pattern-match can also be guarded as in
-\begin{lstlisting}[language=Scala, numbers=none]
+\begin{lstlisting}[ numbers=none]
 case Pattern if Condition => Do_Something
 \end{lstlisting}
 \noindent This allows us, for example, to re-write the
 \code{collatz}-function from above as follows:
 \lstinputlisting[language=Scala]{../progs/collatz2.scala}
 \noindent Although in this particular case the pattern-match
-does not improve the code in any way. In cases like \code{rev}
+does not improve the code in any way. In cases like
-it is really crucial. The underscore in Line 4 indicates that
+\code{rev}, however, it is really crucial. The underscore in
-we do not care what the patter8n looks like. Thus this case
+Line 4 indicates that we do not care what the pattern looks
-acts like a default case whenever the cases above did not
+like. Thus this case acts like a default case whenever the
-match. Cases are always tried out from top to bottom.
+cases above did not match. Cases are always tried out from top
+to bottom.
 \subsection*{Loops, or the Absence of}
 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,
+programming called ,\emph{maps}. To illustrate how they work,
 lets 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}[language=Scala,numbers=none]
+\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
+\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.
 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 in this form as follows:
-\begin{lstlisting}[language=Scala,numbers=none]
+\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
 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}[language=Scala,numbers=none]
+\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-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}[language=Scala,numbers=none]
+\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}[language=Scala,numbers=none]
+\begin{lstlisting}[numbers=none]
 scala> (1 to 8).toSet[Int].map(n => n % 3)
 res5 = Set(2, 1, 0)
 \end{lstlisting}
 \noindent This is the correct result for sets, as there are
 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}[language=Scala,numbers=none]
+\begin{lstlisting}[numbers=none]
 scala> for (n <- (1 to 8).toSet[Int]) yield n % 3
 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
 the numbers 1 to 4 with the letters a to c, we can write
-\begin{lstlisting}[language=Scala,numbers=none]
+\begin{lstlisting}[numbers=none]
 scala> for (n <- (1 to 4).toList;
-l <- ('a' to 'c').toList) yield (n, l)
+m <- ('a' to 'c').toList) yield (n, m)
 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
 Or if we want to find all pairs of numbers between 1 and 3
 where the sum is an even number, we can write
-\begin{lstlisting}[language=Scala,numbers=none]
+\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))
 \end{lstlisting}
 guessed it, does not produce any result, but only produces
 what is in the functional-programming-lingo called a
 side-effect. Printing out the list of numbers from 1 to 5
 would look as follows
-\begin{lstlisting}[language=Scala,numbers=none]
+\begin{lstlisting}[numbers=none]
 scala> for (n <- (1 to 5).toList) print(n)
 12345
 \end{lstlisting}
 \noindent
 where you need to omit the keyword \code{yield}. You can
 also do more elaborate calculations such as
-\begin{lstlisting}[language=Scala,numbers=none]
+\begin{lstlisting}[numbers=none]
 scala> for (n <- (1 to 5).toList) {
 val square_n = n * n
 println(s"$n * $n = $square_n")
 }
 1 * 1 = 1
 4 * 4 = 16
 5 * 5 = 25
 \end{lstlisting}
 \noindent In this code I use a variable assignment (\code{val
-square_n = ...} ) and what is called a
+square_n = ...} ) and also what is called in Scala a
-\emph{string interpolation}, written \code{s"..."}, in order to
+\emph{string interpolation}, written \code{s"..."}. The latter
-print out an equation. The string interpolation allows me to
+is for printing out an equation. It allows me to refer to the
-refer to the integer values \code{n} and \code{square\_n} inside
+integer values \code{n} and \code{square\_n} inside a string.
-a string. This is very convenient for printing out ``things''.
+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
 could also write
-\begin{lstlisting}[language=Scala,numbers=none]
+\begin{lstlisting}[numbers=none]
 scala> (1 to 5).toList.foreach(n => print(n))
 12345
 \end{lstlisting}
 \noindent or even just
-\begin{lstlisting}[language=Scala,numbers=none]
+\begin{lstlisting}[numbers=none]
 scala> (1 to 5).toList.foreach(print)
 12345
 \end{lstlisting}
 \noindent Again I hope this reminds you a bit of your
 above. Scala will still allow \code{map} with side-effect
 functions, but then reacts with a slightly interesting result.
 \subsection*{Types}
-In most functional programming languages types play an
+In most functional programming languages, types play an
 important 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}. Unfortunately, types can be a thorny
 subject, especially in Scala. For example, why do we need to
 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}[language=Scala, numbers=none]
+\begin{lstlisting}[ numbers=none]
 (Int, Int, String)
 \end{lstlisting}
 \noindent is for a triple (a tuple with three components---two
 integers and a string). Tuples are helpful if you want to
 define functions with multiple results, say the function
 returning the quotient and reminder of two numbers. For this
 you might define:
-\begin{lstlisting}[language=Scala, numbers=none]
+\begin{lstlisting}[ numbers=none]
 def quo_rem(m: Int, n: Int) : (Int, Int) = (m / n, m % n)
 \end{lstlisting}
 \noindent Since this function returns a pair of integers, its
 Notice this function takes \emph{two} arguments, namely
 \code{m} and \code{n}, both of which are integers. They are
 ``packaged'' in a pair. Consequently the complete type of
 \code{quo_rem} is
-\begin{lstlisting}[language=Scala, numbers=none]
+\begin{lstlisting}[ numbers=none]
 (Int, Int) => (Int, Int)
 \end{lstlisting}
 Another special type-constructor is for functions, written
 as the arrow \code{=>}. For example, the type
 \code{Int => String} is for a function that takes an integer as argument
 and produces a string. A function of this type is for instance
-\begin{lstlisting}[language=Scala,numbers=none]
+\begin{lstlisting}[numbers=none]
 def mk_string(n: Int) : String = n match {
 case 0 => "zero"
 case 1 => "one"
 case 2 => "two"
 case _ => "many"
 taking an integer as first argument and a string as second,
 and the result of the function is a boolean. Though silly, a
 function of this type would be
-\begin{lstlisting}[language=Scala,numbers=none]
+\begin{lstlisting}[numbers=none]
 def chk_string(n: Int)(s: String) : Boolean =
 mk_string(n) == s
 \end{lstlisting}
 arguments of this function: the arguments are given one after
 the other, instead of being in a pair (what would be the type
 of this function then?). This way of specifying the arguments
 can be useful, for example in situations like this
-\begin{lstlisting}[language=Scala,numbers=none]
+\begin{lstlisting}[numbers=none]
 scala> List("one", "two", "three", "many").map(chk_string(2))
 res4 = List(false, true, false, false)
 scala> List("one", "two", "three", "many").map(chk_string(3))
 res5 = List(false, false, false, true)
 boolean. More interestingly, though, it only takes a single
 argument (because of the parentheses). The single argument
 happens to be another function (taking an integer as input and
 returning a string). Remember that \code{mk_string} is just
 such a function. So how can we use it? For this define
-the somewhat silly function \code{apply_3}
+the somewhat silly function \code{apply_3}:
-\begin{lstlisting}[language=Scala,numbers=none]
+\begin{lstlisting}[numbers=none]
 def apply_3(f: Int => String): Bool = f(3) == "many"
 scala> apply_3(mk_string)
 res6 = true
 \end{lstlisting}
-You might ask, apart from silly functions like above, what is
+You might ask: Apart from silly functions like above, what is
 the point of having function as arguments to other functions?
 In Java there is indeed no need of this kind of feature. But
 in all functional programming languages, including Scala, it
 is really essential. Above you already seen \code{map} and
 \code{foreach} which need this. Consider the functions
 but the latter adds a line break. You can call \code{foreach}
 with either of them and thus changing how, for example, five
 numbers are printed.
-\begin{lstlisting}[language=Scala,numbers=none]
+\begin{lstlisting}[numbers=none]
 scala> (1 to 5).toList.foreach(print)
 12345
 scala> (1 to 5).toList.foreach(println)
 1
 2
 The first wow-moment I had with Scala was when I came across
 the following code-snippet for reading a web-page.
-\begin{lstlisting}[language=Scala, numbers=none]
+\begin{lstlisting}[ numbers=none]
 import io.Source
 val url = """http://www.inf.kcl.ac.uk/staff/urbanc/"""
 Source.fromURL(url).take(10000).mkString
 \end{lstlisting}
 \noindent These three lines return a string containing the
 HTML-code of my webpage. It actually already does something
 more sophisticated, namely only returns the first 10000
-characters of a webpage in case a ``webpage'' is too large.
+characters of a webpage in case it is too large. Why is that
-Why is that code-snippet of any interest? Well, try
+code-snippet of any interest? Well, try implementing
-implementing reading-from-a-webpage in Java. I also like the
+reading-from-a-webpage in Java. I also like the possibility of
-possibility of triple-quoting strings, which I have only seen
+triple-quoting strings, which I have only seen in Scala so
-in Scala so far. The idea behind this is that in such a string
+far. The idea behind this is that in such a string all
-all characters are interpreted literally---there are no
+characters are interpreted literally---there are no escaped
-escaped characters, like \verb|\n| for newlines.
+characters, like \verb|\n| for newlines.
 My second wow-moment I had with a feature of Scala that other
-functional programming languages also do not have. This
+functional programming languages do not have. This feature is
-feature is about implicit type conversions. If you have
+about implicit type conversions. If you have regular
-regular expressions and want to use them for language
+expressions and want to use them for language processing you
-processing you often want to recognise keywords in a language,
+often want to recognise keywords in a language, for example
-for example \code{for},{} \code{if},{} \code{yield} and so on. But
+\code{for},{} \code{if},{} \code{yield} and so on. But the
-the basic regular expression, \code{CHAR}, can only recognise
+basic regular expression \code{CHAR} can only recognise a
-a single character. In order to recognise a whole string, like
+single character. In order to recognise a whole string, like
-\code{ for}, you have to put many of those together using
+\code{for}, you have to put many of those together using
 \code{SEQ}:
-\begin{lstlisting}[language=Scala,numbers=none]
+\begin{lstlisting}[numbers=none]
 SEQ(CHAR('f'), SEQ(CHAR('o'), CHAR('r')))
 \end{lstlisting}
 \noindent This gets quickly unreadable when the strings and
 regular expressions get more complicated. In other functional
 programming language, you can explicitly write a conversion
-function that takes a string, say \code{for}, and generates the
+function that takes a string, say \dq{\pcode{for}}, and
-regular expression above. But then your code is littered with
+generates the regular expression above. But then your code is
-such conversion function.
+littered with such conversion functions.
 In Scala you can do better by ``hiding'' the conversion
 functions. The keyword for doing this is \code{implicit} and
 it needs a built-in library called
-\begin{lstlisting}[language=Scala,numbers=none]
+\begin{lstlisting}[numbers=none]
 scala.language.implicitConversions
 \end{lstlisting}
 \noindent
 Consider the code
 \noindent where the first seven lines implement a function
 that given a list of characters generates the corresponding
 regular expression. In Lines 9 and 10, this function is used
 for transforming a string into a regular expression. Since the
-\code{string2rexp}-function is declared as \code{implicit} the
+\code{string2rexp}-function is declared as \code{implicit},
-effect will be that whenever Scala expects a regular
+the effect will be that whenever Scala expects a regular
 expression, but I only give it a string, it will automatically
 insert a call to the \code{string2rexp}-function. I can now
 write for example
-\begin{lstlisting}[language=Scala,numbers=none]
+\begin{lstlisting}[numbers=none]
 scala> ALT("ab", "ac")
 res9 = ALT(SEQ(CHAR(a),CHAR(b)),SEQ(CHAR(a),CHAR(c)))
 \end{lstlisting}
-\noindent \code{ALT} expects two regular expressions
+\noindent Recall that \code{ALT} expects two regular
-as arguments, but I only supply two strings. The implicit
+expressions as arguments, but I only supply two strings. The
-conversion function will transform the string into
+implicit conversion function will transform the string into a
-a regular expression.
+regular expression.
 Using implicit definitions, Scala allows me to introduce
 some further syntactic sugar for regular expressions:
-\begin{lstlisting}[language=Scala, numbers=none]
+\begin{lstlisting}[ numbers=none]
 implicit def RexpOps(r: Rexp) = new {
 def | (s: Rexp) = ALT(r, s)
 def ~ (s: Rexp) = SEQ(r, s)
 def % = STAR(r)
 }
 \noindent This might seem a bit overly complicated, but its effect is
 that I can now write regular expressions such as $ab + ac$
 even simpler as
-\begin{lstlisting}[language=Scala,numbers=none]
+\begin{lstlisting}[numbers=none]
 scala> "ab" | "ac"
 res10 = ALT(SEQ(CHAR(a),CHAR(b)),SEQ(CHAR(a),CHAR(c)))
 \end{lstlisting}
 \noindent I leave you to figure out what the other
 syntactic sugar in the code above stands for.
 One more useful feature of Scala is the ability to define
-functions with variable argument lists. This is a feature that
+functions with varying argument lists. This is a feature that
 is already present in old languages, like C, but seems to have
 been forgotten in the meantime---Java does not have it. In the
 context of regular expressions this feature comes in handy:
 Say you are fed up with writing many alternatives as
-\begin{lstlisting}[language=Scala,numbers=none]
+\begin{lstlisting}[numbers=none]
 ALT(..., ALT(..., ALT(..., ...)))
 \end{lstlisting}
 \noindent To make it difficult, you do not know how deep such
 function which uses the feature of varying argument lists. The
 effect of this code  is that I can write the regular
 expression for keywords as
-\begin{lstlisting}[language=Scala,numbers=none]
+\begin{lstlisting}[numbers=none]
 ALTS("for", "def", "yield", "implicit", "if", "match", "case")
 \end{lstlisting}
-\noindent Again I leave you to it to find out how much this
+\noindent Again I leave it to you to find out how much this
-simplifies the regular expression in comparison if I had to
+simplifies the regular expression in comparison with if I had
-write this by hand using only the ``plain'' regular
+to write this by hand using only the ``plain'' regular
 expressions from the inductive datatype.
 \subsection*{More Info}
 There is much more to Scala than I can possibly describe in
 also many ``deep'' ideas about types in Scala, which even to
 me as seasoned functional programmer are puzzling. Whilst
 implicits are great, they can also be a source of great
 headaches, for example consider the code:
+\begin{lstlisting}[numbers=none]
-\begin{lstlisting}[language=Scala,numbers=none]
 scala>  List (1, 2, 3) contains "your mom"
 res1: Boolean = false
 \end{lstlisting}
 \noindent Rather than returning \code{false}, this code should
 throw a typing-error. There are also many limitations Scala
 inherited from the JVM that can be really annoying. For
 example a fixed stack size. One can work around this
 Even if Scala has been a success in several high-profile
 companies, there is also a company (Yammer) that first used
 Scala in their production code, but then moved away from it.
 Allegedly they did not like the steep learning curve of Scala
 and also that new versions of Scala often introduced
-incompatibilities in old code.
+incompatibilities in old code. In the past two months
+there have also been two forks of the Scala compiler.
+It needs to be seen what the future brings for Scala.
 So all in all, Scala might not be a great teaching language,
 but I hope this is mitigated by the fact that I never require
 you to write any Scala code. You only need to be able to read
 it. In the coursework you can use any programming language you

changeset 240	de4f6382590a
parent 239	68d98140b90b
child 242	35104ee14f87