// Scala Lecture 4//=================// expressions (essentially trees)abstract class Expcase class N(n: Int) extends Exp // for numberscase class Plus(e1: Exp, e2: Exp) extends Expcase class Times(e1: Exp, e2: Exp) extends Expdef string(e: Exp) : String = e match { case N(n) => s"$n" case Plus(e1, e2) => s"(${string(e1)} + ${string(e2)})" case Times(e1, e2) => s"(${string(e1)} * ${string(e2)})"}val e = Plus(N(9), Times(N(3), N(4)))println(string(e))def eval(e: Exp) : Int = e match { case N(n) => n case Plus(e1, e2) => eval(e1) + eval(e2) case Times(e1, e2) => eval(e1) * eval(e2) }println(eval(e))// simplification rules:// e + 0, 0 + e => e // e * 0, 0 * e => 0// e * 1, 1 * e => e//// (....0 ....)def simp(e: Exp) : Exp = e match { case N(n) => N(n) case Plus(e1, e2) => (simp(e1), simp(e2)) match { case (N(0), e2s) => e2s case (e1s, N(0)) => e1s case (e1s, e2s) => Plus(e1s, e2s) } case Times(e1, e2) => (simp(e1), simp(e2)) match { case (N(0), _) => N(0) case (_, N(0)) => N(0) case (N(1), e2s) => e2s case (e1s, N(1)) => e1s case (e1s, e2s) => Times(e1s, e2s) } }val e2 = Times(Plus(N(0), N(1)), Plus(N(0), N(9)))println(string(e2))println(string(simp(e2)))// Tokens and Reverse Polish Notationabstract class Tokencase class T(n: Int) extends Tokencase object PL extends Tokencase object TI extends Token// transfroming an Exp into a list of tokensdef rp(e: Exp) : List[Token] = e match { case N(n) => List(T(n)) case Plus(e1, e2) => rp(e1) ::: rp(e2) ::: List(PL) case Times(e1, e2) => rp(e1) ::: rp(e2) ::: List(TI) }println(string(e2))println(rp(e2))def comp(ls: List[Token], st: List[Int] = Nil) : Int = (ls, st) match { case (Nil, st) => st.head case (T(n)::rest, st) => comp(rest, n::st) case (PL::rest, n1::n2::st) => comp(rest, n1 + n2::st) case (TI::rest, n1::n2::st) => comp(rest, n1 * n2::st)}comp(rp(e))def proc(s: String) : Token = s match { case "+" => PL case "*" => TI case _ => T(s.toInt) }comp("1 2 + 4 * 5 + 3 +".split(" ").toList.map(proc), Nil)// Polymorphic Types//===================// You do not want to write functions like contains, first, // length and so on for every type of lists.def length_int_list(lst: List[Int]): Int = lst match { case Nil => 0 case x::xs => 1 + length_int_list(xs)}length_int_list(List(1, 2, 3, 4))def length_string_list(lst: List[String]): Int = lst match { case Nil => 0 case _::xs => 1 + length_string_list(xs)}length_string_list(List("1", "2", "3", "4"))// you can make the function parametric in type(s)def length[A](lst: List[A]): Int = lst match { case Nil => 0 case x::xs => 1 + length(xs)}length(List("1", "2", "3", "4"))length(List(1, 2, 3, 4))length[Int](List(1, 2, 3, 4))def map[A, B](lst: List[A], f: A => B): List[B] = lst match { case Nil => Nil case x::xs => f(x)::map(xs, f) }map(List(1, 2, 3, 4), (x: Int) => x.toString)// from knight1.scaladef first(xs: List[Pos], f: Pos => Option[Path]) : Option[Path] = ???// should bedef first[A, B](xs: List[A], f: A => Option[B]) : Option[B] = ???// Type inference is local in Scaladef id[T](x: T) : T = xval x = id(322) // Intval y = id("hey") // Stringval z = id(Set(1,2,3,4)) // Set[Int]// The type variable concept in Scala can get really complicated.//// - variance (OO)// - bounds (subtyping)// - quantification// Java has issues with this too: Java allows// to write the following incorrect code, and// only recovers by raising an exception// at runtime.// Object[] arr = new Integer[10];// arr[0] = "Hello World";// Scala gives you a compile-time error, which// is much better.var arr = Array[Int]()arr(0) = "Hello World"// Function definitions again//============================// variable argumentsdef printAll(strings: String*) = { strings.foreach(println)}printAll()printAll("foo")printAll("foo", "bar")printAll("foo", "bar", "baz")// pass a list to the varargs fieldval fruits = List("apple", "banana", "cherry")printAll(fruits: _*)// you can also implement your own string interpolationsimport scala.language.implicitConversionsimport scala.language.reflectiveCallsimplicit def sring_inters(sc: StringContext) = new { def i(args: Any*): String = s"${sc.s(args:_*)}\n"}i"add ${3+2} ${3 * 3}" // default argumentsdef length[A](xs: List[A]) : Int = xs match { case Nil => 0 case _ :: tail => 1 + length(tail)}def lengthT[A](xs: List[A], acc : Int = 0) : Int = xs match { case Nil => acc case _ :: tail => lengthT(tail, 1 + acc)}lengthT(List.fill(100000)(1))def fact(n: BigInt, acc: BigInt = 1): BigInt = if (n == 0) acc else fact(n - 1, n * acc)fact(10)// currying (Haskell Curry)def add(x: Int, y: Int) = x + yList(1,2,3,4,5).map(x => add(3, x))def add2(x: Int)(y: Int) = x + yList(1,2,3,4,5).map(add2(3))val a3 : Int => Int = add2(3)// currying helps sometimes with type inferencedef find[A](xs: List[A])(pred: A => Boolean): Option[A] = { xs match { case Nil => None case hd :: tl => if (pred(hd)) Some(hd) else find(tl)(pred) }}find(List(1, 2, 3))(x => x % 2 == 0)// Source.fromURL(url)(encoding)// Source.fromFile(name)(encoding)// Tail recursion//================@tailrecdef fact(n: BigInt): BigInt = if (n == 0) 1 else n * fact(n - 1)fact(10) fact(1000) fact(100000) def factB(n: BigInt): BigInt = if (n == 0) 1 else n * factB(n - 1)def factT(n: BigInt, acc: BigInt): BigInt = if (n == 0) acc else factT(n - 1, n * acc)factB(1000)factT(10, 1)println(factT(500000, 1))// there is a flag for ensuring a function is tail recursiveimport scala.annotation.tailrec@tailrecdef factT(n: BigInt, acc: BigInt): BigInt = if (n == 0) acc else factT(n - 1, n * acc)factT(100000, 1)// for tail-recursive functions the Scala compiler// generates loop-like code, which does not need// to allocate stack-space in each recursive// call; Scala can do this only for tail-recursive// functions// Moral: Whenever a recursive function is resource-critical// (i.e. works with a large recursion depth), then you need to// write it in tail-recursive fashion.// // Unfortuantely, Scala because of current limitations in // the JVM is not as clever as other functional languages. It can // only optimise "self-tail calls". This excludes the cases of // multiple functions making tail calls to each other. Well,// nothing is perfect. // Sudoku //========// THE POINT OF THIS CODE IS NOT TO BE SUPER// EFFICIENT AND FAST, just explaining exhaustive// depth-first searchval game0 = """.14.6.3.. |62...4..9 |.8..5.6.. |.6.2....3 |.7..1..5. |5....9.6. |..6.2..3. |1..5...92 |..7.9.41.""".stripMargin.replaceAll("\\n", "")type Pos = (Int, Int)val EmptyValue = '.'val MaxValue = 9def pretty(game: String): String = "\n" + (game.grouped(MaxValue).mkString("\n"))pretty(game0)val allValues = "123456789".toListval indexes = (0 to 8).toListdef empty(game: String) = game.indexOf(EmptyValue)def isDone(game: String) = empty(game) == -1 def emptyPosition(game: String) = { val e = empty(game) (e % MaxValue, e / MaxValue)}def get_row(game: String, y: Int) = indexes.map(col => game(y * MaxValue + col))def get_col(game: String, x: Int) = indexes.map(row => game(x + row * MaxValue))//get_row(game0, 0)//get_row(game0, 1)//get_col(game0, 0)def get_box(game: String, pos: Pos): List[Char] = { def base(p: Int): Int = (p / 3) * 3 val x0 = base(pos._1) val y0 = base(pos._2) val ys = (y0 until y0 + 3).toList (x0 until x0 + 3).toList .flatMap(x => ys.map(y => game(x + y * MaxValue)))}//get_box(game0, (3, 1))// this is not mutable!!def update(game: String, pos: Int, value: Char): String = game.updated(pos, value)def toAvoid(game: String, pos: Pos): List[Char] = (get_col(game, pos._1) ++ get_row(game, pos._2) ++ get_box(game, pos))def candidates(game: String, pos: Pos): List[Char] = allValues.diff(toAvoid(game, pos))//candidates(game0, (0,0))def search(game: String): List[String] = { if (isDone(game)) List(game) else { val cs = candidates(game, emptyPosition(game)) cs.map(c => search(update(game, empty(game), c))).flatten }}pretty(game0)search(game0).map(pretty)val game1 = """23.915... |...2..54. |6.7...... |..1.....9 |89.5.3.17 |5.....6.. |......9.5 |.16..7... |...329..1""".stripMargin.replaceAll("\\n", "")search(game1).map(pretty)// a game that is in the hard categoryval game2 = """8........ |..36..... |.7..9.2.. |.5...7... |....457.. |...1...3. |..1....68 |..85...1. |.9....4..""".stripMargin.replaceAll("\\n", "")search(game2).map(pretty)// game with multiple solutionsval game3 = """.8...9743 |.5...8.1. |.1....... |8....5... |...8.4... |...3....6 |.......7. |.3.5...8. |9724...5.""".stripMargin.replaceAll("\\n", "")search(game3).map(pretty).foreach(println)// for measuring timedef time_needed[T](i: Int, code: => T) = { val start = System.nanoTime() for (j <- 1 to i) code val end = System.nanoTime() s"${(end - start) / 1.0e9} secs"}time_needed(1, search(game2))// tail recursive version that searches // for all Sudoku solutionsimport scala.annotation.tailrec@tailrecdef searchT(games: List[String], sols: List[String]): List[String] = games match { case Nil => sols case game::rest => { if (isDone(game)) searchT(rest, game::sols) else { val cs = candidates(game, emptyPosition(game)) searchT(cs.map(c => update(game, empty(game), c)) ::: rest, sols) } } }searchT(List(game3), List()).map(pretty)// tail recursive version that searches // for a single solutiondef search1T(games: List[String]): Option[String] = games match { case Nil => None case game::rest => { if (isDone(game)) Some(game) else { val cs = candidates(game, emptyPosition(game)) search1T(cs.map(c => update(game, empty(game), c)) ::: rest) } }}search1T(List(game3)).map(pretty)time_needed(1, search1T(List(game3)))time_needed(1, search1T(List(game2)))// game with multiple solutionsval game3 = """.8...9743 |.5...8.1. |.1....... |8....5... |...8.4... |...3....6 |.......7. |.3.5...8. |9724...5.""".stripMargin.replaceAll("\\n", "")searchT(List(game3), Nil).map(pretty)search1T(List(game3)).map(pretty)// Cool Stuff in Scala//=====================// Implicits or How to Pimp your Library//======================================//// 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 conversions.implicit class MyString(s: String) { def increment = s.map(c => (c + 1).toChar) }"HAL".increment// Abstract idea:// In that version implicit conversions were used to solve the // late extension problem; namely, given a class C and a class T, // how to have C extend T without touching or recompiling C. // Conversions add a wrapper when a member of T is requested // from an instance of C.import scala.concurrent.duration.{TimeUnit,SECONDS,MINUTES}case class Duration(time: Long, unit: TimeUnit) { def +(o: Duration) = Duration(time + unit.convert(o.time, o.unit), unit)}implicit class Int2Duration(that: Int) { def seconds = Duration(that, SECONDS) def minutes = Duration(that, MINUTES)}5.seconds + 2.minutes //Duration(125L, SECONDS )2.minutes + 60.seconds// Regular expressions - the power of DSLs in Scala//==================================================abstract class Rexpcase object ZERO extends Rexp // nothingcase object ONE extends Rexp // the empty stringcase class CHAR(c: Char) extends Rexp // a character ccase class ALT(r1: Rexp, r2: Rexp) extends Rexp // alternative r1 + r2case class SEQ(r1: Rexp, r2: Rexp) extends Rexp // sequence r1 . r2 case class STAR(r: Rexp) extends Rexp // star r*// writing (ab)* in the format above is // tediousval r0 = STAR(SEQ(CHAR('a'), CHAR('b')))// some convenience for typing in regular expressionsimport scala.language.implicitConversions import scala.language.reflectiveCalls def charlist2rexp(s: List[Char]): Rexp = s match { case Nil => ONE case c::Nil => CHAR(c) case c::s => SEQ(CHAR(c), charlist2rexp(s))}implicit def string2rexp(s: String): Rexp = charlist2rexp(s.toList)val r1 = STAR("hello")val r2 = STAR("hello") | STAR("world")implicit def RexpOps (r: Rexp) = new { def | (s: Rexp) = ALT(r, s) def % = STAR(r) def ~ (s: Rexp) = SEQ(r, s)}implicit def stringOps (s: String) = new { def | (r: Rexp) = ALT(s, r) def | (r: String) = ALT(s, r) def % = STAR(s) def ~ (r: Rexp) = SEQ(s, r) def ~ (r: String) = SEQ(s, r)}//example regular expressionsval digit = ("0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9")val sign = "+" | "-" | ""val number = sign ~ digit ~ digit.% // In mandelbrot.scala I used complex (imaginary) numbers // and implemented the usual arithmetic operations for complex // numbers.case class Complex(re: Double, im: Double) { // represents the complex number re + im * i def +(that: Complex) = Complex(this.re + that.re, this.im + that.im) def -(that: Complex) = Complex(this.re - that.re, this.im - that.im) def *(that: Complex) = Complex(this.re * that.re - this.im * that.im, this.re * that.im + that.re * this.im) def *(that: Double) = Complex(this.re * that, this.im * that) def abs = Math.sqrt(this.re * this.re + this.im * this.im)}val test = Complex(1, 2) + Complex (3, 4)// ...to allow the notation n + m * iimport scala.language.implicitConversions val i = Complex(0, 1)implicit def double2complex(re: Double) = Complex(re, 0)val inum1 = -2.0 + -1.5 * ival inum2 = 1.0 + 1.5 * i