// Scala Lecture 3+
−
//=================+
−
+
−
// - last week+
−
//+
−
// option type +
−
// higher-order function+
−
+
−
+
−
def add(x: Int, y: Int) : Int = x + y+
−
+
−
def plus5(x: Int) : Int = add(5, x)+
−
+
−
plus5(6)+
−
+
−
def add2(x: Int)(y: Int) : Int = x + y+
−
+
−
def plus3(y: Int) : Int => Int = add2(3)(y)+
−
+
−
plus3(9)+
−
+
−
List(1,2,3,4,5).map(add2(3))+
−
List(1,2,3,4,5).map(add(3, _))+
−
+
−
type Pos = (Int, Int)+
−
+
−
def test(p: Pos) = {+
−
  if (p._1 < 5 && p._2 < 5) {+
−
    Some(p)+
−
  }+
−
}+
−
+
−
val l = List((1,2), (5,3), (2,5), (1,3))+
−
+
−
l.map(test).flatten+
−
+
−
// Recursion Again ;o)+
−
//====================+
−
+
−
+
−
// A Web Crawler / Email Harvester+
−
//=================================+
−
//+
−
// the idea is to look for links using the+
−
// regular expression "https?://[^"]*" and for+
−
// email addresses using yet another regex.+
−
+
−
import io.Source+
−
import scala.util._+
−
+
−
// gets the first 10K of a web-page+
−
def get_page(url: String) : String = {+
−
  Try(Source.fromURL(url)("ISO-8859-1").take(10000).mkString).+
−
    getOrElse { println(s" Problem with: $url"); ""}+
−
}+
−
+
−
// regex for URLs and emails+
−
val http_pattern = """"https?://[^"]*"""".r+
−
val email_pattern = """([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})""".r+
−
+
−
//  val s = "foo bla christian@kcl.ac.uk 1234567"+
−
//  email_pattern.findAllIn(s).toList+
−
+
−
// drops the first and last character from a string+
−
def unquote(s: String) = s.drop(1).dropRight(1)+
−
+
−
def get_all_URLs(page: String): Set[String] = +
−
  http_pattern.findAllIn(page).map(unquote).toSet+
−
+
−
// a naive version of crawl - searches until a given depth,+
−
// visits pages potentially more than once+
−
def crawl(url: String, n: Int) : Unit = {+
−
  if (n == 0) ()+
−
  else {+
−
    println(s"  Visiting: $n $url")+
−
    val page = get_page(url)+
−
    for (u <- get_all_URLs(page)) crawl(u, n - 1)+
−
  }+
−
}+
−
+
−
// some starting URLs for the crawler+
−
val startURL = """https://nms.kcl.ac.uk/christian.urban/"""+
−
+
−
crawl(startURL, 2)+
−
+
−
for (x <- List(1,2,3,4,5,6)) println(x)+
−
+
−
// a primitive email harvester+
−
def emails(url: String, n: Int) : Set[String] = {+
−
  if (n == 0) Set()+
−
  else {+
−
    println(s"  Visiting: $n $url")+
−
    val page = get_page(url)+
−
    val new_emails = email_pattern.findAllIn(page).toSet+
−
    new_emails ++ (for (u <- get_all_URLs(page).par) yield emails(u, n - 1)).flatten+
−
  }+
−
}+
−
+
−
emails(startURL, 3)+
−
+
−
+
−
// if we want to explore the internet "deeper", then we+
−
// first have to parallelise the request of webpages:+
−
//+
−
// scala -cp scala-parallel-collections_2.13-0.2.0.jar +
−
// import scala.collection.parallel.CollectionConverters._+
−
+
−
+
−
+
−
// another well-known example+
−
//============================+
−
+
−
def move(from: Char, to: Char) =+
−
  println(s"Move disc from $from to $to!")+
−
+
−
def hanoi(n: Int, from: Char, via: Char, to: Char) : Unit = {+
−
  if (n == 0) ()+
−
  else {+
−
    hanoi(n - 1, from, to, via)+
−
    move(from, to)+
−
    hanoi(n - 1, via, from, to)+
−
  }+
−
} +
−
+
−
hanoi(4, 'A', 'B', 'C')+
−
+
−
+
−
+
−
// Jumping Towers+
−
//================+
−
+
−
+
−
// the first n prefixes of xs+
−
// for 1 => include xs+
−
+
−
def moves(xs: List[Int], n: Int) : List[List[Int]] = (xs, n) match {+
−
  case (Nil, _) => Nil+
−
  case (_, 0) => Nil+
−
  case (y::ys, n) => xs :: moves(ys, n - 1)+
−
}+
−
+
−
+
−
moves(List(5,1,0), 1)+
−
moves(List(5,1,0), 2)+
−
moves(List(5,1,0), 5)+
−
+
−
// checks whether a jump tour exists at all+
−
+
−
def search(xs: List[Int]) : Boolean = xs match {+
−
  case Nil => true+
−
  case x::xs =>+
−
    if (xs.length < x) true +
−
    else moves(xs, x).exists(search(_))+
−
}+
−
+
−
+
−
search(List(5,3,2,5,1,1))+
−
search(List(3,5,1,0,0,0,1))+
−
search(List(3,5,1,0,0,0,0,1))+
−
search(List(3,5,1,0,0,0,1,1))+
−
search(List(3,5,1))+
−
search(List(5,1,1))+
−
search(Nil)+
−
search(List(1))+
−
search(List(5,1,1))+
−
search(List(3,5,1,0,0,0,0,0,0,0,0,1))+
−
+
−
// generates *all* jump tours+
−
//    if we are only interested in the shortest one, we could+
−
//    shortcircut the calculation and only return List(x) in+
−
//    case where xs.length < x, because no tour can be shorter+
−
//    than 1+
−
// +
−
+
−
def jumps(xs: List[Int]) : List[List[Int]] = xs match {+
−
  case Nil => Nil+
−
  case x::xs => {+
−
    val children = moves(xs, x)+
−
    val results = children.map(cs => jumps(cs).map(x :: _)).flatten+
−
    if (xs.length < x) List(x)::results else results+
−
  }+
−
}+
−
+
−
jumps(List(5,3,2,5,1,1)).minBy(_.length)+
−
jumps(List(3,5,1,2,1,2,1))+
−
jumps(List(3,5,1,2,3,4,1))+
−
jumps(List(3,5,1,0,0,0,1))+
−
jumps(List(3,5,1))+
−
jumps(List(5,1,1))+
−
jumps(Nil)+
−
jumps(List(1))+
−
jumps(List(5,1,2))+
−
moves(List(1,2), 5)+
−
jumps(List(1,5,1,2))+
−
jumps(List(3,5,1,0,0,0,0,0,0,0,0,1))+
−
+
−
jumps(List(5,3,2,5,1,1)).minBy(_.length)+
−
jumps(List(1,3,5,8,9,2,6,7,6,8,9)).minBy(_.length)+
−
jumps(List(1,3,6,1,0,9)).minBy(_.length)+
−
jumps(List(2,3,1,1,2,4,2,0,1,1)).minBy(_.length)+
−
+
−
+
−
+
−
+
−
+
−
+
−
// User-defined Datatypes+
−
//========================+
−
+
−
abstract class Tree+
−
case class Leaf(x: Int) extends Tree+
−
case class Node(s: String, left: Tree, right: Tree) extends Tree +
−
+
−
List(Leaf(20), Node("foo", Leaf(1), Leaf(2)))+
−
+
−
sealed abstract class Colour+
−
case object Red extends Colour +
−
case object Green extends Colour +
−
case object Blue extends Colour+
−
case object Yellow extends Colour+
−
+
−
+
−
def fav_colour(c: Colour) : Boolean = c match {+
−
  case Green => true+
−
  case _  => false +
−
}+
−
+
−
fav_colour(Green)+
−
+
−
// ... a tiny bit more useful: Roman Numerals+
−
+
−
sealed abstract class RomanDigit +
−
case object I extends RomanDigit +
−
case object V extends RomanDigit +
−
case object X extends RomanDigit +
−
case object L extends RomanDigit +
−
case object C extends RomanDigit +
−
case object D extends RomanDigit +
−
case object M extends RomanDigit +
−
+
−
type RomanNumeral = List[RomanDigit] +
−
+
−
List(X,I,M,D)+
−
+
−
/*+
−
I    -> 1+
−
II   -> 2+
−
III  -> 3+
−
IV   -> 4+
−
V    -> 5+
−
VI   -> 6+
−
VII  -> 7+
−
VIII -> 8+
−
IX   -> 9+
−
X    -> 10+
−
*/+
−
+
−
def RomanNumeral2Int(rs: RomanNumeral): Int = rs match { +
−
  case Nil => 0+
−
  case M::r    => 1000 + RomanNumeral2Int(r)  +
−
  case C::M::r => 900 + RomanNumeral2Int(r)+
−
  case D::r    => 500 + RomanNumeral2Int(r)+
−
  case C::D::r => 400 + RomanNumeral2Int(r)+
−
  case C::r    => 100 + RomanNumeral2Int(r)+
−
  case X::C::r => 90 + RomanNumeral2Int(r)+
−
  case L::r    => 50 + RomanNumeral2Int(r)+
−
  case X::L::r => 40 + RomanNumeral2Int(r)+
−
  case X::r    => 10 + RomanNumeral2Int(r)+
−
  case I::X::r => 9 + RomanNumeral2Int(r)+
−
  case V::r    => 5 + RomanNumeral2Int(r)+
−
  case I::V::r => 4 + RomanNumeral2Int(r)+
−
  case I::r    => 1 + RomanNumeral2Int(r)+
−
}+
−
+
−
RomanNumeral2Int(List(I,V))             // 4+
−
RomanNumeral2Int(List(I,I,I,I))         // 4 (invalid Roman number)+
−
RomanNumeral2Int(List(V,I))             // 6+
−
RomanNumeral2Int(List(I,X))             // 9+
−
RomanNumeral2Int(List(M,C,M,L,X,X,I,X)) // 1979+
−
RomanNumeral2Int(List(M,M,X,V,I,I))     // 2017+
−
+
−
+
−
// String interpolations as patterns+
−
+
−
val date = "2019-11-26"+
−
val s"$year-$month-$day" = date+
−
+
−
def parse_date(date: String) : Option[(Int, Int, Int)]= date match {+
−
  case s"$year-$month-$day" => Some((day.toInt, month.toInt, year.toInt))+
−
  case s"$day/$month/$year" => Some((day.toInt, month.toInt, year.toInt))+
−
  case s"$day.$month.$year" => Some((day.toInt, month.toInt, year.toInt))+
−
  case _ => None+
−
} +
−
+
−
parse_date("2019-11-26")+
−
parse_date("26/11/2019")+
−
parse_date("26.11.2019")+
−
+
−
+
−
// User-defined Datatypes and Pattern Matching+
−
//=============================================+
−
+
−
+
−
+
−
+
−
// Tail recursion+
−
//================+
−
+
−
+
−
def fact(n: Long): Long = +
−
  if (n == 0) 1 else n * fact(n - 1)+
−
+
−
def factB(n: BigInt): BigInt = +
−
  if (n == 0) 1 else n * factB(n - 1)+
−
+
−
factB(100000)+
−
+
−
fact(10)              //ok+
−
fact(10000)           // produces a stackoverflow+
−
+
−
def factT(n: BigInt, acc: BigInt): BigInt =+
−
  if (n == 0) acc else factT(n - 1, n * acc)+
−
+
−
factT(10, 1)+
−
println(factT(100000, 1))+
−
+
−
// there is a flag for ensuring a function is tail recursive+
−
import scala.annotation.tailrec+
−
+
−
@tailrec+
−
def factT(n: BigInt, acc: BigInt): BigInt =+
−
  if (n == 0) acc else factT(n - 1, n * acc)+
−
+
−
+
−
+
−
// 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+
−
+
−
// tail recursive version that searches +
−
// for all solutions+
−
+
−
def 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 solution+
−
+
−
def 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(10, search1T(List(game3)))+
−
+
−
+
−
// game with multiple solutions+
−
val 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)+
−
+
−
// Moral: Whenever a recursive function is resource-critical+
−
// (i.e. works with 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. +
−
+
−
+
−
+
−
+
−
+
−
+
−
+
−
+
−
+
−
+
−
//************+
−
// Either+
−
val either1 : Either[Exception,Int] = Right(1)+
−
val either2: Either[Exception, Int] = Right(2)+
−
+
−
for{+
−
  one <- either1+
−
  two <- either2+
−
} yield one + two+
−