// Scala Lecture 2

//=================

// For-Comprehensions Again

//==========================

// the first produces a result, while the second does not

for (n <- List(1, 2, 3, 4, 5)) yield n * n

for (n <- List(1, 2, 3, 4, 5)) println(n)

// String Interpolations

//=======================

val n = 3

// helpful for debugging purposes

//

//         "The most effective debugging tool is still careful thought, 

//          coupled with judiciously placed print statements."

//                   — Brian W. Kernighan, in Unix for Beginners (1979)

def gcd_db(a: Int, b: Int) : Int = {

  println(s"Function called with ${a} and ${b}.")

  if (b == 0) a else gcd_db(b, a % b)

}

gcd_db(48, 18)

// The Option Type

//=================

// in Java, if something unusually happens, you return null or 

// raise an exception

//

//in Scala you use Options instead

//   - 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)

// better error handling with Options (no exceptions)

//

//  Try(something).getOrElse(what_to_do_in_case_of_an_exception)

//

import scala.util._

import io.Source

val my_url = "https://nms.kcl.ac.uk/christian.urban/"

Source.fromURL(my_url).mkString

Try(Source.fromURL(my_url).mkString).getOrElse("")

Try(Some(Source.fromURL(my_url).mkString)).getOrElse(None)

// the same for files

Try(Some(Source.fromFile("text.txt").mkString)).getOrElse(None)

// how to implement a function for reading something from files...

def get_contents(name: String) : List[String] = 

  Source.fromFile(name).getLines.toList

get_contents("test.txt")

// slightly better - return Nil

def get_contents(name: String) : List[String] = 

  Try(Source.fromFile(name).getLines.toList).getOrElse(List())

get_contents("text.txt")

// much better - you record in the type that things can go wrong 

def get_contents(name: String) : Option[List[String]] = 

  Try(Some(Source.fromFile(name).getLines.toList)).getOrElse(None)

get_contents("text.txt")

get_contents("test.txt")

// operations on options

val lst = List(None, Some(1), Some(2), None, Some(3))

lst.flatten

Some(1).get

None.get

Some(1).isDefined

None.isDefined

// division where possible

for ((x, y) <- ps) yield {

  if (y == 0) None else Some(x / y)

}

// getOrElse is for setting a default value

val lst = List(None, Some(1), Some(2), None, Some(3))

for (x <- lst) yield x.getOrElse(0)

// 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, 

// code could potentially throw a NullPointerException.

// even Scala is not immune to problems like this:

List(5,6,7,8,9).indexOf(7)

List(5,6,7,8,9).indexOf(10)

List(5,6,7,8,9)(-1)

// Higher-Order Functions

//========================

// functions can take functions as arguments

def even(x: Int) : Boolean = x % 2 == 0

def odd(x: Int) : Boolean = x % 2 == 1

val lst = (1 to 10).toList

lst.filter(even)

lst.count(even)

lst.find(even)

lst.sortWith(_ > _)

lst.sortWith(_ < _)

def lex(x: (Int, Int), y: (Int, Int)) : Boolean = 

  if (x._1 == y._1) x._2 < y._2 else x._1 < y._1

ps.sortWith(lex)

ps.sortBy(_._1)

ps.sortBy(_._2)

ps.maxBy(_._1)

ps.maxBy(_._2)

// maps (lower-case)

//===================

def double(x: Int): Int = x + x

def square(x: Int): Int = x * x

val lst = (1 to 10).toList

lst.map(x => (double(x), square(x)))

lst.map(square)

// this is actually how for-comprehensions 

// defined as in Scala

lst.map(n => square(n))

for (n <- lst) yield square(n)

// this can be iterated

lst.map(square).filter(_ > 4)

lst.map(square).filter(_ > 4).map(square)

def my_map_int(lst: List[Int], f: Int => Int) : List[Int] = {

  if (lst == Nil) Nil

  else f(lst.head) :: my_map_int(lst.tail, f)

}

my_map_int(lst, square)

// same function using pattern matching: a kind

// of switch statement on steroids (see more later on)

def my_map_int(lst: List[Int], f: Int => Int) : List[Int] = lst match {

  case Nil => Nil

  case x::xs => f(x)::my_map_int(xs, f)

}

// other function types

//

// f1: (Int, Int) => Int

// f2: List[String] => Option[Int]

// ... 

val lst = (1 to 10).toList

def sumOf(f: Int => Int, lst: List[Int]): Int = lst match {

  case Nil => 0

  case x::xs => f(x) + sumOf(f, xs)

}

def sum_squares(lst: List[Int]) = sumOf(square, lst)

def sum_cubes(lst: List[Int])   = sumOf(x => x * x * x, lst)

sum_squares(lst)

sum_cubes(lst)

def fact(n: Int) : Int = 

  if (n == 0) 1 else n * fact(n - 1)

def sum_fact(lst: List[Int]) = sumOf(fact, lst)

sum_fact(lst)

(1 to 100).filter((x: Int) => x % 2 == 0).sum 

(1 to 100).filter(x => x % 2 == 0).sum

// As each parameter (only x in this case) is passed only once

// you can use the wizardy placeholder syntax

(1 to 100).filter(_ % 2 == 0).sum

// a function that turns strings into numbers (similar to .toInt)

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", "456")

for (x <- lst) yield get_me_an_int(x)

// summing up all the numbers

lst.map(get_me_an_int).flatten.sum

lst.map(get_me_an_int).flatten.sum

lst.flatMap(get_me_an_int).sum

// Map type (upper-case)

//=======================

// Note the difference between map and Map

def factors(n: Int) : List[Int] =

var ls = (1 to 10).toList

val facs = ls.map(n => (n, factors(n)))

facs.find(_._1 == 4)

// works for lists of pairs

facs.toMap

facs.toMap.get(4)

facs.toMap.getOrElse(42, Nil)

val facsMap = facs.toMap

val facsMap0 = facsMap + (0 -> List(1,2,3,4,5))

facsMap.get(1)

val ls = List("one", "two", "three", "four", "five")

ls.groupBy(_.length)

// 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] = xs match {

  case Nil => Nil 

  case None::rest => my_flatten(rest)

}

def get_me_a_string(n: Int): String = n match {

  case 0 | 1 | 2 => "small"

  case _ => "big"

}

get_me_a_string(0)

// you can also have cases combined

def season(month: String) : String = month match {

  case "March" | "April" | "May" => "It's spring"

  case "June" | "July" | "August" => "It's summer"

  case "September" | "October" | "November" => "It's autumn"

  case "December" => "It's winter"

  case "January" | "February" => "It's unfortunately winter"

}

println(season("November"))

// What happens if no case matches?

println(season("foobar"))

def days(month: String) : Int = month match {

  case "March" | "April" | "May" => 31

  case "June" | "July" | "August" => 30

}

// Silly: fizz buzz

def fizz_buzz(n: Int) : String = (n % 3, n % 5) match {

  case (0, 0) => "fizz buzz"

  case (0, _) => "fizz"

  case (_, 0) => "buzz"

  case _ => n.toString  

}

for (n <- 0 to 20) 

 println(fizz_buzz(n))

// Recursion

//===========

*/

  if (l == 0) List("")

}

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)

  }

} 

//

// the idea is to look for links using the

// regular expression "https?://[^"]*" and for

// email addresses using 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