// Scala Lecture 4

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

// tail-recursion

// polymorphic types

// implicits

import scala.annotation.tailrec

def fact(n: BigInt): BigInt = 

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

def factT(n: BigInt, acc: BigInt): BigInt =

  if (n == 0) acc else factT(n - 1, n * acc)

println(factT(1000000), 1)) 

def foo[A](args: List[A]) = ???

foo(List("1","2","3","4"))

// from knight1.scala

def first(xs: List[Pos], f: Pos => Option[Path]) : Option[Path] = ???

// should be

def first[A, B](xs: List[A], f: A => Option[B]) : Option[B] = ???

// expressions (essentially trees)

abstract class Exp

case class N(n: Int) extends Exp                  // for numbers

case class Plus(e1: Exp, e2: Exp) extends Exp

case class Times(e1: Exp, e2: Exp) extends Exp

def string(e: Exp) : String = e match {

  case N(n) => s"$n"

  case Plus(e1, e2) => s"(${string(e1)} + ${string(e2)})" 

  case Times(e1, e2) => s"(${string(e1)} * ${string(e2)})"

}

val e = Plus(N(9), Times(N(3), N(4)))

println(string(e))

def eval(e: Exp) : Int = e match {

  case N(n) => n

  case Plus(e1, e2) => eval(e1) + eval(e2) 

  case Times(e1, e2) => eval(e1) * eval(e2) 

}

println(eval(e))

// simplification rules:

// e + 0, 0 + e => e 

// e * 0, 0 * e => 0

// e * 1, 1 * e => e

//

// (....0  ....)

def simp(e: Exp) : Exp = e match {

  case N(n) => N(n)

  case Plus(e1, e2) => (simp(e1), simp(e2)) match {

    case (N(0), e2s) => e2s

    case (e1s, N(0)) => e1s

    case (e1s, e2s) => Plus(e1s, e2s)

  }  

  case Times(e1, e2) => (simp(e1), simp(e2)) match {

    case (N(0), _) => N(0)

    case (_, N(0)) => N(0)

    case (N(1), e2s) => e2s

    case (e1s, N(1)) => e1s

    case (e1s, e2s) => Times(e1s, e2s)

  }  

}

val e2 = Times(Plus(N(0), N(1)), Plus(N(0), N(9)))

println(string(e2))

println(string(simp(e2)))

// Tokens and Reverse Polish Notation

abstract class Token

case class T(n: Int) extends Token

case object PL extends Token

case object TI extends Token

// transfroming an Exp into a list of tokens

def rp(e: Exp) : List[Token] = e match {

  case N(n) => List(T(n))

  case Plus(e1, e2) => rp(e1) ::: rp(e2) ::: List(PL) 

  case Times(e1, e2) => rp(e1) ::: rp(e2) ::: List(TI) 

}

println(string(e2))

println(rp(e2))

def comp(ls: List[Token], st: List[Int] = Nil) : Int = (ls, st) match {

  case (Nil, st) => st.head 

  case (T(n)::rest, st) => comp(rest, n::st)

  case (PL::rest, n1::n2::st) => comp(rest, n1 + n2::st)

  case (TI::rest, n1::n2::st) => comp(rest, n1 * n2::st)

}

comp(rp(e))

def proc(s: String) : Token = s match {

  case  "+" => PL

  case  "*" => TI

  case  _ => T(s.toInt) 

}

comp("1 2 + 4 * 5 + 3 +".split(" ").toList.map(proc), Nil)

// Polymorphic Types

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

// You do not want to write functions like contains, first, 

// length and so on for every type of lists.

def length_int_list(lst: List[Int]): Int = lst match {

  case Nil => 0

  case x::xs => 1 + length_int_list(xs)

}

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

def length_string_list(lst: List[String]): Int = lst match {

  case Nil => 0

  case _::xs => 1 + length_string_list(xs)

}

length_string_list(List("1", "2", "3", "4"))

// you can make the function parametric in type(s)

def length[A](lst: List[A]): Int = lst match {

  case Nil => 0

  case x::xs => 1 + length(xs)

}

length(List("1", "2", "3", "4"))

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

length[Int](List(1, 2, 3, 4))

def map[A, B](lst: List[A], f: A => B): List[B] = lst match {

  case Nil => Nil

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

}

map(List(1, 2, 3, 4), (x: Int) => x.toString)

// from knight1.scala

def first(xs: List[Pos], f: Pos => Option[Path]) : Option[Path] = ???

// should be

def first[A, B](xs: List[A], f: A => Option[B]) : Option[B] = ???

// Type inference is local in Scala

def id[T](x: T) : T = x

val x = id(322)          // Int

val y = id("hey")        // String

val z = id(Set(1,2,3,4)) // Set[Int]

// The type variable concept in Scala can get really complicated.

//

// - variance (OO)

// - bounds (subtyping)

// - quantification

// Java has issues with this too: Java allows

// to write the following incorrect code, and

// only recovers by raising an exception

// at runtime.

// Object[] arr = new Integer[10];

// arr[0] = "Hello World";

// Scala gives you a compile-time error, which

// is much better.

var arr = Array[Int]()

arr(0) = "Hello World"

// Function definitions again

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

// variable arguments

def printAll(strings: String*) = {

  strings.foreach(println)

}

printAll()

printAll("foo")

printAll("foo", "bar")

printAll("foo", "bar", "baz")

// pass a list to the varargs field

val fruits = List("apple", "banana", "cherry")

printAll(fruits: _*)

// you can also implement your own string interpolations

import scala.language.implicitConversions

import scala.language.reflectiveCalls

implicit def sring_inters(sc: StringContext) = new {

    def i(args: Any*): String = s"${sc.s(args:_*)}\n"

}

i"add ${3+2} ${3 * 3}" 

// default arguments

def length[A](xs: List[A]) : Int = xs match {

  case Nil => 0

  case _ :: tail => 1 + length(tail)

}

def lengthT[A](xs: List[A], acc : Int = 0) : Int = xs match {

  case Nil => acc

  case _ :: tail => lengthT(tail, 1 + acc)

}

lengthT(List.fill(100000)(1))

def fact(n: BigInt, acc: BigInt = 1): BigInt =

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

fact(10)

// currying    (Haskell Curry)

def add(x: Int, y: Int) = x + y

List(1,2,3,4,5).map(x => add(3, x))

def add2(x: Int)(y: Int) = x + y

List(1,2,3,4,5).map(add2(3))

val a3 : Int => Int = add2(3)

// currying helps sometimes with type inference

def find[A](xs: List[A])(pred: A => Boolean): Option[A] = {

  xs match {

    case Nil => None

    case hd :: tl =>

      if (pred(hd)) Some(hd) else find(tl)(pred)

  }

}

find(List(1, 2, 3))(x => x % 2 == 0)

// Source.fromURL(url)(encoding)

// Source.fromFile(name)(encoding)

// Tail recursion

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

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

fact(10)          

fact(1000)        

fact(100000)       

def factB(n: BigInt): BigInt = 

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

def factT(n: BigInt, acc: BigInt): BigInt =

  if (n == 0) acc else factT(n - 1, n * acc)

factB(1000)

factT(10, 1)

println(factT(500000, 1))

// there is a flag for ensuring a function is tail recursive

import scala.annotation.tailrec

@tailrec

def factT(n: BigInt, acc: BigInt): BigInt =

  if (n == 0) acc else factT(n - 1, n * acc)

factT(100000, 1)

// for tail-recursive functions the Scala compiler

// generates loop-like code, which does not need

// to allocate stack-space in each recursive

// call; Scala can do this only for tail-recursive

// functions

// Moral: Whenever a recursive function is resource-critical

// (i.e. works with a large recursion depth), then you need to

// write it in tail-recursive fashion.

// 

// Unfortuantely, Scala because of current limitations in 

// the JVM is not as clever as other functional languages. It can 

// only optimise "self-tail calls". This excludes the cases of 

// multiple functions making tail calls to each other. Well,

// nothing is perfect. 

// Sudoku 

//========

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

def pretty(game: String): String = 

  "\n" + (game.grouped(MaxValue).mkString("\n"))

pretty(game0)

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) = {

  val e = empty(game)

  (e % MaxValue, e / 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, 0)

//get_row(game0, 1)

//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, (3, 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 search(game: String): List[String] = {

  if (isDone(game)) List(game)

  else {

    val cs = candidates(game, emptyPosition(game))

    cs.map(c => search(update(game, empty(game), c))).flatten

  }

}

pretty(game0)

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)

// a game that is in the hard category

val game2 = """8........

              |..36.....

              |.7..9.2..

              |.5...7...

              |....457..

              |...1...3.

              |..1....68

              |..85...1.

              |.9....4..""".stripMargin.replaceAll("\\n", "")

search(game2).map(pretty)

// 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(game3).map(pretty).foreach(println)

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

  s"${(end - start) / 1.0e9} secs"

}

time_needed(1, search(game2))

// tail recursive version that searches 

// for all Sudoku solutions

import scala.annotation.tailrec

@tailrec

def searchT(games: List[String], sols: List[String]): List[String] = 

 games match {

    case Nil => sols

    case game::rest => {

      if (isDone(game)) searchT(rest, game::sols)

      else {

        val cs = candidates(game, emptyPosition(game))

        searchT(cs.map(c => update(game, empty(game), c)) ::: rest, sols)

     }

   }

 }

searchT(List(game3), List()).map(pretty)

// tail recursive version that searches 

// for a single solution