// Scala Lecture 2

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

// the pain with overloaded math operations

(100 / 4)

(100 / 3)

(100.toDouble / 3.toDouble)

// For-Comprehensions again

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

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

for (n <- (1 to 10).toList) yield {

  val res = square(n)

  res

}

// like in functions, the "last" item inside the yield

// will be returned; the last item is not necessarily 

// the last line

for (n <- (1 to 10).toList) yield {

  if (n % 2 == 0) n 

  else square(n)

}

// ...please, please do not write:

val lst = List(1, 2, 3, 4, 5, 6, 7, 8, 9)

for (i <- (0 until lst.length).toList) yield square(lst(i))

// this is just so prone to off-by-one errors;

// write instead

//this works for sets as well

val st = Set(1, 2, 3, 4, 5, 6, 7, 8, 9)

for (e <- st) yield {

  if (e < 5) e else square(e)

}

// Side-Effects

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

// with only a side-effect (no list is produced),

for (n <- (1 to 10)) println(n)

for (n <- (1 to 10)) {

  print("The number is: ")

  print(n)

  print("\n")

}

// know when to use yield and when not:

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

List(5,6,7,8,9).find(_ < 4)

// some operations on Option's

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

lst.flatten

Some(1).isDefined

None.isDefined

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

}

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

// error handling with Options (no exceptions)

//

//  Try(....)

//

//  Try(something).getOrElse(what_to_do_in_an_exception)

//

import scala.util._

Try(1 + 3)

Try(9 / 0) 

Try(9 / 3).getOrElse(42) 

Try(9 / 0).getOrElse(42) 

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)

// a function that turns strings into numbers

Integer.parseInt("1234")

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 numbers

val sum = (for (i <- lst) yield get_me_an_int(i)).flatten.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 get_me_an_int. If you didn't look at the Javadoc, 

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

// code could potentially throw a NullPointerException.

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

// Higher-Order Functions

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

// functions can take functions as arguments

val lst = (1 to 10).toList

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

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

lst.filter(even(_))

lst.find(_ > 8)

// map applies a function to each element of a list

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

lst.map(square)

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

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

// map works for most collection types, including sets

//

// Consider the sum between a and b:

def sumInts(a: Int, b: Int) : Int = 

  if (a > b) 0 else a + sumInts(a + 1, b)

// sum squares

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

def sumSquares(a: Int, b: Int) : Int = 

  if (a > b) 0 else square(a) + sumSquares(a + 1, b)

sumSquares(2, 6)

// sum factorials

def fact(n: Int) : Int =  

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

def sumFacts(a: Int, b: Int) : Int = 

  if (a > b) 0 else fact(a) + sumFacts(a + 1, b)

sumFacts(2, 6)

// The type of functions from ints to ints: Int => Int

def sum(f: Int => Int, a: Int, b: Int) : Int = {

  if (a > b) 0 

  else f(a) + sum(f, a + 1, b)

}

def sumSquares(a: Int, b: Int) : Int = sum(square, a, b)

def sumFacts(a: Int, b: Int) : Int = sum(fact, a, b)

// What should we do for sumInts?

def id(n: Int) : Int = n

def sumInts(a: Int, b: Int) : Int = sum(id, a, b)

// Anonymous Functions: You can also write:

def sumCubes(a: Int, b: Int) : Int =   sum(x => x * x * x, a, b)

def sumSquares(a: Int, b: Int) : Int = sum(x => x * x, a, b)

def sumInts(a: Int, b: Int) : Int    = sum(x => x, a, b)

// other function types

//

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

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

// ... 

// an aside: partial application

def add(a: Int)(b: Int) : Int = a + b

sum(add(2), 0, 2)

sum(add(10), 0, 2)

// Function Composition

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

def add_footer(msg: String) : String = msg ++ " - Sent from iOS"

def valid_msg(msg: String) : Boolean = msg.size <= 140

def duplicate(s: String) : String = s ++ s

valid_msg(add_footer("Hello World"))

// first_word: let's first do it the ugly Java way using null:

def first_word(msg: String) : String = {

  val words = msg.split(" ")

  if (words(0) != "") words(0) else null

}

duplicate(first_word("Hello World"))

duplicate(first_word(""))

def extended_duplicate(s: String) : String = 

  if (s != null) s ++ s else null

extended_duplicate(first_word(""))

// Avoid always null!

def better_first_word(msg: String) : Option[String] = {

  val words = msg.split(" ")

  if (words(0) != "") Some(words(0)) else None

}

better_first_word("Hello World").map(duplicate)

better_first_word("").map(duplicate)

better_first_word("").map(duplicate).map(valid_msg)