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

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

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

// has no "yield"

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:

for (e <- Set(1, 2, 3, 4, 5, 6, 7, 8, 9); if e < 5) yield square(e)

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

// some operations on Option's

// use .getOrElse is for setting a default value

// error handling with Options (no exceptions)

//

//  Try(....)

Try(1 + 3)

Try(9 / 0) 

Try(9 / 3).getOrElse(42) 

Try(9 / 0).getOrElse(42) 

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)

Integer.parseInt("1234")

val sum = (for (i <- lst) yield get_me_an_int(i)).flatten.sum

// the Javadoc of get_me_an_int. If you didn't look at the Javadoc, 

// 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(x => even(x))

lst.filter(even(_))

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

Set(1, 3, 6).map(square)

// Why could functions as arguments be useful?

//

// Consider the sum between a and b:

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

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

sumInt(10, 16)

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

// You can see the pattern....can we simplify out work?

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

// ... 

// Function Composition

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

// How could Higher-Order Functions and Options be helpful?

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

// they compose nicely

valid_msg(add_footer("Hello World"))

valid_msg(duplicate(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("Hello World").map(duplicate).map(duplicate).map(valid_msg)

better_first_word("").map(duplicate)

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

// Implicits (Cool Feature)

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

// For example adding your own methods to Strings:

// Imagine you want to increment strings, like

// using implicit conversions.

// No returns in Scala

// You should not use "return" in Scala:

  ls.map(sq1).sum[Int]

sumq(List(1, 2, 3, 4))

def sumq(ls: List[Int]): Int = {

  val sqs : List[Int] = for (x <- ls) yield (return x * x)

  sqs.sum

abstract class Colour

case class Red() extends Colour 

case class Green() extends Colour 

case class Blue() extends Colour

def fav_colour(c: Colour) : Boolean = c match {

  case Red()   => false

  case Green() => true

  case Blue()  => false 

// actually this can be written with "object"

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