diff -r 0e60e6c24b99 -r 9f8751912560 progs/lecture2.scala
--- a/progs/lecture2.scala	Wed Nov 16 15:05:40 2016 +0000
+++ b/progs/lecture2.scala	Wed Nov 16 23:34:05 2016 +0000
@@ -2,25 +2,187 @@
 //=================
 
 
+
 // Option type
 //=============
+
+//in Java if something unusually happens, you return null
+//in Scala you use Option
+//   - if the value is present, you use Some(value)
+//   - if no value is present, you use None
+
+
+List(7,2,3,4,5,6).find(_ < 4)
+List(5,6,7,8,9).find(_ < 4)
+
 val lst = List(None, Some(1), Some(2), None, Some(3))
 
 lst.flatten
+
 Some(1).get
 
+Some(1).isDefined
+None.isDefined
+
 val ps = List((3, 0), (3, 2), (4, 2), (2, 0), (1, 0), (1, 1))
 
 for ((x, y) <- ps) yield {
   if (y == 0) None else Some(x / y)
 }
 
-// sudoku
-// some none
-// pattern matching
+// getOrElse is to set a default value
+
+val lst = List(None, Some(1), Some(2), None, Some(3))
+for (x <- lst) yield x getOrElse 0
+
+
+import scala.util._
+import io.Source
+// error handling with option
+//
+//  Try(something).getOrElse(what_to_do_in_an_exception)
+
+Source.fromURL("""http://www.inf.kcl.ac.uk/staff/urbanccc/""").mkString
+
+Try(Source.fromURL("""http://www.inf.kcl.ac.uk/staff/urbanc/""").mkString).getOrElse("")
+
+Try(Some(Source.fromURL("""http://www.inf.kcl.ac.uk/staff/urbanc/""").mkString)).getOrElse(None)
+
+
+Integer.parseInt("12u34")
+
+def get_me_an_int(s: String): Option[Int] = 
+ Try(Some(Integer.parseInt(s))).getOrElse(None)
+
+val lst = List("12345", "foo", "5432", "bar", "x21")
+for (x <- lst) yield get_me_an_int(x)
+
+// summing all the numbers
+val sum = lst.flatMap(get_me_an_int(_)).sum
+
+
+// This may not look any better than working with null in Java, but to
+// see the value, you have to put yourself in the shoes of the
+// consumer of the get_me_an_int function, and imagine you didn't
+// write that function.
+//
+// In Java, if you didn't write this function, you'd have to depend on
+// the Javadoc of the get_me_an_int. If you didn't look at the Javadoc
+// for the Java, you might not know that get_me_an_int could return a
+// null, and your code could potentially throw a NullPointerException.
+
+
+
+
+
+// Type abbreviations
+//====================
+
+// some syntactic convenience
+type Pos = (int, Int)
+
+type Board = List[List[Int]]
+
+
+
+
+// No return in Scala
+//====================
+
+//You should not use "return" in Scala:
+//
+// A return expression, when evaluated, abandons the 
+// current computation and returns to the caller of the 
+// function in which return appears."
+
+def sq1(x: Int): Int = x * x
+def sq2(x: Int): Int = return x * x
+
+def sumq(ls: List[Int]): Int = {
+  (for (x <- ls) yield (return x * x)).sum[Int]
+}
+
+sumq(List(1,2,3,4))
 
-//type abbreviations
-type Pos = (int, Int)
+// last expression in a function is the return statement
+def square(x: Int): Int = {
+  println(s"The argument is ${x}.")
+  x * x
+}
+
+// Pattern Matching
+//==================
+
+// A powerful tool which is supposed to come to Java in a few years
+// time (https://www.youtube.com/watch?v=oGll155-vuQ)...Scala already
+// has it for many years ;o)
+
+// The general schema:
+//
+//    expression match {
+//       case pattern1 => expression1
+//       case pattern2 => expression2
+//       ...
+//       case patternN => expressionN
+//    }
+
+
+// remember
+val lst = List(None, Some(1), Some(2), None, Some(3)).flatten
+
+
+def my_flatten(xs: List[Option[Int]]): List[Int] = {
+  ...
+}
+
+
+def my_flatten(lst: List[Option[Int]]): List[Int] = lst match {
+  case Nil => Nil
+  case None::xs => my_flatten(xs)
+  case Some(n)::xs => n::my_flatten(xs)
+}
+
+
+// another example
+def get_me_a_string(n: Int): String = n match {
+  case 0 => "zero"
+  case 1 => "one"
+  case 2 => "two"
+  case _ => "many"
+}
+
+
+// Higher-Order Functions
+//========================
+
+// functions can take functions as arguments
+
+val lst = (1 to 10).toList
+
+def even(x: Int): Boolean = x % 2 == 0
+def odd(x: Int): Boolean = x % 2 == 1
+
+lst.filter(x => even(x))
+lst.filter(even(_))
+lst.filter(even)
+
+lst.find(_ > 8)
+
+def square(x: Int): Int = x * x
+
+lst.map(square)
+
+lst.map(square).filter(_ > 4)
+
+
+
+
+// Sudoku
+//========
+
+
+
+
 
 //sorting, higher-order functions
 //lexicographic ordering