// Scala Lecture 2//=================// 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 NoneList(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.flattenSome(1).getSome(1).isDefinedNone.isDefinedval 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)}// getOrElse is to set a default valueval lst = List(None, Some(1), Some(2), None, Some(3))for (x <- lst) yield x getOrElse 0import 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/""").mkStringTry(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 numbersval 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 conveniencetype 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 * xdef sq2(x: Int): Int = return x * xdef sumq(ls: List[Int]): Int = { (for (x <- ls) yield (return x * x)).sum[Int]}sumq(List(1,2,3,4))// last expression in a function is the return statementdef 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// }// rememberval lst = List(None, Some(1), Some(2), None, Some(3)).flattendef 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 exampledef 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 argumentsval lst = (1 to 10).toListdef even(x: Int): Boolean = x % 2 == 0def odd(x: Int): Boolean = x % 2 == 1lst.filter(x => even(x))lst.filter(even(_))lst.filter(even)lst.find(_ > 8)def square(x: Int): Int = x * xlst.map(square)lst.map(square).filter(_ > 4)// Sudoku//========//sorting, higher-order functions//lexicographic ordering// Implicits//===========//// for example adding your own methods to Strings:// imagine you want to increment strings, like//// "HAL".increment//// you can avoid ugly fudges, like a MyString, by// using implicit conversionsimplicit class MyString(s: String) { def increment = for (c <- s) yield (c + 1).toChar }"HAL".increment