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

for (e <- lst; if (e % 2) == 0; if (e != 4)) 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),
// for 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:

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



// 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(7,24,3,4,5,6).find(_ < 4)
List(5,6,7,8,9).find(_ < 4)

List(7,2,3,4,5,6).filter(_ < 4)

// some operations on Option's

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

lst.flatten

Some(10).get
None.get

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"""
//val my_url = """https://nms.kcl.ac.uk/christan.urban"""  // misspelled

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:

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


// ... how are we supposed to know that this returns -1


// 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) && odd(x))
lst.filter(even(_))
lst.filter(odd && even)

lst.find(_ > 8)

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

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

val lst = (1 to 10).toList
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).filter(_ > 4)


val l = List((1, 3),(2, 4),(4, 1),(6, 2))

l.map(square(_._1))


// Why are functions as arguments 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)


sumInts(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 our 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)

sumInts(10, 12)


// 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
def add_abc(a: Int)(b: Int)(c: Int) : Int = a + b + c

val add2 : Int => Int = add(2)
add2(5)

val add2_bc : Int => Int => Int = add_abc(2) 
val add2_9_c : Int => Int = add2_bc(9) 

add2_9_c(10)

sum(add(2), 0, 2)
sum(add(10), 0, 2)


// Function Composition
//======================

// How can be 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 very nicely, e.g

valid_msg(add_footer("Hello World"))
valid_msg(duplicate(duplicate(add_footer("Helloooooooooooooooooo World"))))

// but not all functions do
// 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(""))

// but this is against the rules of the game: we do not want
// to change duplicate, because first_word might return null


// 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)
better_first_word("").map(duplicate).map(duplicate).map(valid_msg)

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





// Problems with mutability and parallel computations
//====================================================

def count_intersection(A: Set[Int], B: Set[Int]) : Int = {
  var count = 0
  for (x <- A; if (B contains x)) count += 1 
  count
}

val A = (1 to 1000).toSet
val B = (1 to 1000 by 4).toSet

count_intersection(A, B)

// but do not try to add .par to the for-loop above,
// otherwise you will be caught in race-condition hell.


//propper parallel version
def count_intersection2(A: Set[Int], B: Set[Int]) : Int = 
  A.par.count(x => B contains x)

count_intersection2(A, B)


//for measuring time
def time_needed[T](n: Int, code: => T) = {
  val start = System.nanoTime()
  for (i <- (0 to n)) code
  val end = System.nanoTime()
  (end - start) / 1.0e9
}

val A = (1 to 1000000).toSet
val B = (1 to 1000000 by 4).toSet

time_needed(10, count_intersection(A, B))
time_needed(10, count_intersection2(A, B))






// No returns in Scala
//====================

// You should not use "return" in Scala:
//
// A return expression, when evaluated, abandons the 
// current computation and returns to the caller of the 
// function in which return appears."

def sq1(x: Int): Int = x * x
def sq2(x: Int): Int = return x * x

def sumq(ls: List[Int]): Int = {
  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
}




// Type abbreviations
//====================

// some syntactic convenience

type Pos = (int, Int)
type Board = List[List[Int]]




// Sudoku in Scala
//=================

// THE POINT OF THIS CODE IS NOT TO BE SUPER
// EFFICIENT AND FAST, just explaining exhaustive
// depth-first search


val game0 = """.14.6.3..
              |62...4..9
              |.8..5.6..
              |.6.2....3
              |.7..1..5.
              |5....9.6.
              |..6.2..3.
              |1..5...92
              |..7.9.41.""".stripMargin.replaceAll("\\n", "")

type Pos = (Int, Int)
val EmptyValue = '.'
val MaxValue = 9

val allValues = "123456789".toList
val indexes = (0 to 8).toList


def empty(game: String) = game.indexOf(EmptyValue)
def isDone(game: String) = empty(game) == -1 
def emptyPosition(game: String) = 
  (empty(game) % MaxValue, empty(game) / MaxValue)


def get_row(game: String, y: Int) = 
  indexes.map(col => game(y * MaxValue + col))
def get_col(game: String, x: Int) = 
  indexes.map(row => game(x + row * MaxValue))

get_row(game0, 3)
get_col(game0, 0)

def get_box(game: String, pos: Pos): List[Char] = {
    def base(p: Int): Int = (p / 3) * 3
    val x0 = base(pos._1)
    val y0 = base(pos._2)
    val ys = (y0 until y0 + 3).toList
    (x0 until x0 + 3).toList.flatMap(x => ys.map(y => game(x + y * MaxValue)))
}

get_box(game0, (0, 0))
get_box(game0, (1, 1))
get_box(game0, (2, 1))

// this is not mutable!!
def update(game: String, pos: Int, value: Char): String = 
  game.updated(pos, value)

def toAvoid(game: String, pos: Pos): List[Char] = 
  (get_col(game, pos._1) ++ get_row(game, pos._2) ++ get_box(game, pos))

def candidates(game: String, pos: Pos): List[Char] = 
  allValues.diff(toAvoid(game,pos))

//candidates(game0, (0,0))

def pretty(game: String): String = 
  "\n" + (game sliding (MaxValue, MaxValue) mkString "\n")

def search(game: String): List[String] = {
  if (isDone(game)) List(game)
  else {
    val cs = candidates(game, emptyPosition(game))
    cs.par.map(c => search(update(game, empty(game), c))).toList.flatten
  }
}

search(game0).map(pretty)

val game1 = """23.915...
              |...2..54.
              |6.7......
              |..1.....9
              |89.5.3.17
              |5.....6..
              |......9.5
              |.16..7...
              |...329..1""".stripMargin.replaceAll("\\n", "")

search(game1).map(pretty)

// game that is in the hard(er) category
val game2 = """8........
              |..36.....
              |.7..9.2..
              |.5...7...
              |....457..
              |...1...3.
              |..1....68
              |..85...1.
              |.9....4..""".stripMargin.replaceAll("\\n", "")

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


search(game2).map(pretty)
search(game3).map(pretty)

// for measuring time
def time_needed[T](i: Int, code: => T) = {
  val start = System.nanoTime()
  for (j <- 1 to i) code
  val end = System.nanoTime()
  ((end - start) / i / 1.0e9) + " secs"
}

search(game2).map(pretty)
search(game3).distinct.length
time_needed(1, search(game2))
time_needed(1, search(game3))




//===================
// the end for today