// Scala Lecture 3

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

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

// Recursion Again ;o)

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

def move(from: Char, to: Char) =

  println(s"Move disc from $from to $to!")

def hanoi(n: Int, from: Char, via: Char, to: Char) : Unit = {

  if (n == 0) ()

  else {

    hanoi(n - 1, from, to, via)

    move(from, to)

    hanoi(n - 1, via, from, to)

  }

} 

hanoi(4, 'A', 'B', 'C')

// User-defined Datatypes

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

abstract class Tree

case class Leaf(x: Int) extends Tree

case class Node(s: String, left: Tree, right: Tree) extends Tree 

case object Red extends Colour 

case object Green extends Colour 

case object Blue extends Colour

case object Yellow extends Colour

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

  case Green => true

  case _  => false 

}

// ... a tiny bit more useful: Roman Numerals

sealed abstract class RomanDigit 

case object I extends RomanDigit 

case object V extends RomanDigit 

case object X extends RomanDigit 

case object L extends RomanDigit 

case object C extends RomanDigit 

case object D extends RomanDigit 

case object M extends RomanDigit 

type RomanNumeral = List[RomanDigit] 

/*

I    -> 1

II   -> 2

III  -> 3

IV   -> 4

V    -> 5

VI   -> 6

VII  -> 7

VIII -> 8

IX   -> 9

X    -> 10

*/

def RomanNumeral2Int(rs: RomanNumeral): Int = rs match { 

  case Nil => 0

  case M::r    => 1000 + RomanNumeral2Int(r)  

  case C::M::r => 900 + RomanNumeral2Int(r)

  case D::r    => 500 + RomanNumeral2Int(r)

  case C::D::r => 400 + RomanNumeral2Int(r)

  case C::r    => 100 + RomanNumeral2Int(r)

  case X::C::r => 90 + RomanNumeral2Int(r)

  case L::r    => 50 + RomanNumeral2Int(r)

  case X::L::r => 40 + RomanNumeral2Int(r)

  case X::r    => 10 + RomanNumeral2Int(r)

  case I::X::r => 9 + RomanNumeral2Int(r)

  case V::r    => 5 + RomanNumeral2Int(r)

  case I::V::r => 4 + RomanNumeral2Int(r)

  case I::r    => 1 + RomanNumeral2Int(r)

}

RomanNumeral2Int(List(I,V))             // 4

RomanNumeral2Int(List(I,I,I,I))         // 4 (invalid Roman number)

RomanNumeral2Int(List(V,I))             // 6

RomanNumeral2Int(List(I,X))             // 9

RomanNumeral2Int(List(M,C,M,L,X,X,I,X)) // 1979

RomanNumeral2Int(List(M,M,X,V,I,I))     // 2017

// String interpolations as patterns

val date = "2019-11-26"

val s"$year-$month-$day" = date

def parse_date(date: String) : Option[(Int, Int, Int)]= date match {

  case s"$year-$month-$day" => Some((day.toInt, month.toInt, year.toInt))

  case s"$day/$month/$year" => Some((day.toInt, month.toInt, year.toInt))

  case s"$day.$month.$year" => Some((day.toInt, month.toInt, year.toInt))

  case _ => None

} 

parse_date("2019-11-26")

parse_date("26/11/2019")

parse_date("26.11.2019")

// Tail recursion

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

def fact(n: Long): Long = 

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

def factB(n: BigInt): BigInt = 

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

factB(100000)

fact(10)              //ok

fact(10000)           // produces a stackoverflow

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

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

factT(10, 1)

println(factT(100000, 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)

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

// tail recursive version that searches 

// for all solutions

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

def search1T(games: List[String]): Option[String] = games match {

  case Nil => None

  case game::rest => {

    if (isDone(game)) Some(game)

    else {

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

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

    }

  }

}

search1T(List(game3)).map(pretty)

time_needed(10, search1T(List(game3)))

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

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

search1T(List(game3)).map(pretty)

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

// (i.e. works with 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.