// Scala Lecture 2

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

// - Options

// - Higher-Order Functions (short-hand notation)

// - maps (behind for-comprehensions)

// - Pattern-Matching

// - Recursion

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

// Int:      ..., 0, 1, 2,...

// Boolean:  true false

//

// List[Int]: Nil, List(_) 

//

// Option[Int]: None, Some(0), Some(1), ...

// Option[Boolean]: None, Some(true), Some(false)

// Option[...]: None, Some(_)

def div(x: Int, y: Int) : Int = 

  x / y

def safe_div(x: Int, y: Int) : Option[Int] = 

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

def foo_calculation(x: Int) = 

  if (safe_div(x, x) == None) 24 else safe_div(x, x).get

foo_calculation(3)

foo_calculation(0)

safe_div(10 + 5, 3)  

List(1,2,3,4,5,6).indexOf(7)

// better error handling with Options (no exceptions)

//

//  Try(something).getOrElse(what_to_do_in_case_of_an_exception)

//

import scala.util._      // Try,...

import io.Source         // fromURL

// the same for files

// how to implement a function for reading 

// (lines) from files...

//

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

get_contents("text.txt")

get_contents("test.txt")

// slightly better - return Nil

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

get_contents("text.txt")

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

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

get_contents("text.txt")

get_contents("test.txt")

// operations on options

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

for (x <- lst) yield {

  if (x == None) None

  else Some(x.get + 1)

}

lst.flatten

Some(1).get

None.get

Some(1).isDefined

None.isDefined

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

val ps = List((3, 0), (4, 2), (6, 2), 

              (2, 0), (1, 0), (1, 1))

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

// a function that turns strings into numbers 

// (similar to .toInt)

Integer.parseInt("1234")

def get_me_an_int(s: String) : Option[Int] = 

 Try(Some(Integer.parseInt(s))).getOrElse(None)

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

// you might not know that get_me_an_int could return null, and your 

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

Try({

  val x = 3

  val y = 0

  Some(x / y)

}).getOrElse(None)

// minOption 

// maxOption 

// minByOption 

// maxByOption

// Higher-Order Functions

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

// functions can take functions as arguments

// and produce functions as result

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

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

def inc(x: Int) : Int = x + 1

val lst = (1 to 10).toList

lst.filter(odd)

lst.count(odd)

lst.filter(_ % 2 == 0)

lst.find(_ < 4)

lst.filter(_ < 4) 

val x = 3 < 4

def less4(x: Int) : Boolean = x < 4

lst.find(less4)

lst.find(x => !(x < 4))

lst.filter(x => x % 2 == 0)

lst.filter(_ % 2 == 0)

lst.sortWith((x, y) => x > y)

lst.sortWith(_ < _)

// but this only works when the arguments are clear, but 

// not with multiple occurences

lst.find(n => odd(n) && n > 2)

// lexicographic ordering

val ps = List((3, 0), (3, 2), (4, 2), (2, 2), 

              (2, 0), (1, 1), (1, 0))

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(x => x._1)

ps.sortBy(_._2)

ps.maxBy(x => x._2)

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(square)

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

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

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

// works also for strings

def tweet(c: Char) = c.toUpper

"Hello\nWorld".map(tweet)

// this can be iterated

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

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

lst.map(square).find(_ > 4).map(double)

lst.map(square)

   .find(_ > 4)

   .map(double)

// Option Type and maps

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

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

Integer.parseInt("12u34")

// maps on Options

import scala.util._

def get_me_an_int(s: String) : Option[Int] = 

 Try(Some(Integer.parseInt(s))).getOrElse(None)

get_me_an_int("12345").map(_ % 2 == 0)

get_me_an_int("12u34").map(_ % 2 == 0)

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

// this is actually how for-comprehensions are

// defined in Scala

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

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

// lets define our own higher-order functions

// type of functions is for example Int => Int

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)

  }

val biglst = (1 to 10000).toList

my_map_int(biglst, double)

(1 to 10000000).toList.map(double)

// other function types

//

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

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

// ... 

// Map type (upper-case)

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

// Note the difference between map and Map

val m = Map(1 -> "one", 2 -> "two", 10 -> "many")

List((1, "one"), (2, "two"), (10, "many")).toMap

m.get(1)

m.get(4)

m.getOrElse(1, "")

m.getOrElse(4, "")

val new_m = m + (10 -> "ten")

new_m.get(10)

val m2 = for ((k, v) <- m) yield (k, v.toUpperCase)

// groupBy function on Maps

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

lst.groupBy(_.head)

lst.groupBy(_.length)

lst.groupBy(_.length).get(3)

val grps = lst.groupBy(_.length)

grps.keySet

// naive quicksort with "On" function

def sortOn(f: Int => Int, xs: List[Int]) : List[Int] = {

  if (xs.size < 2) xs

  else {

   val pivot = xs.head

   val (left, right) = xs.partition(f(_) < f(pivot))

   sortOn(f, left) ::: pivot :: sortOn(f, right.tail)

  }

} 

sortOn(identity, List(99,99,99,98,10,-3,2)) 

sortOn(n => - n, List(99,99,99,98,10,-3,2))

// Pattern Matching

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

// A powerful tool which has even landed in Java during 

// the last few years (https://inside.java/2021/06/13/podcast-017/).

// ...Scala already has it for many years and the concept is

// older than your friendly lecturer, that is stone old  ;o)

// The general schema:

//

//    expression match {

//       case pattern1 => expression1

//       case pattern2 => expression2

//       ...

//       case patternN => expressionN

//    }

// recall

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)

  }

def my_map_option(opt: Option[Int], f: Int => Int) : Option[Int] = 

  opt match {

    case None => None