// exist in non-functional languages. C-like languages

// are strict. To see the difference, consider

// This is called "strict evaluation".

// In contrast, say we have a pretty expensive operation:

val b = "foo"

// This is called "lazy evaluation":

// needed. Once calculated though, the result

// does not need to be re-calculated.

// A useful example is

// A slightly less obvious example: Prime Numbers.

// (I do not care how many) primes: 2, 3, 5, 7, 9, 11, 13 ....

def generatePrimes (s: LazyList[Int]): LazyList[Int] =

val primes = generatePrimes(LazyList.from(2))

primes.take(10).toList

time_needed(1, primes.filter(_ > 100).take(3000).toList)

// A Stream (LazyList) of successive numbers:

LazyList.from(2).take(10)

LazyList.from(2).take(10).force

// An Iterative version of the Fibonacci numbers

def fibIter(a: BigInt, b: BigInt): LazyList[BigInt] =

fibIter(1, 1).drop(10000).take(1)

fibIter(1, 1).drop(10000).take(1).force

// LazyLists are good for testing

// Task: enumerate exhaustively regular expressions

enuml(3, "a").size // out of heap space

def enum(rs: LazyList[Rexp]) : LazyList[Rexp] = 

enum(LazyList(ZERO, ONE, CHAR('a'), CHAR('b'))).take(200).force

enum(LazyList(ZERO, ONE, CHAR('a'), CHAR('b'))).take(5000000)

  (enum(LazyList(ZERO, ONE, CHAR('a'), CHAR('b')))

// Polymorphic Types

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

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

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

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

  case Nil => 0

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

}

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

  case Nil => 0

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

}

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

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

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)

// distinct / distinctBy

val ls = List(1,2,3,3,2,4,3,2,1)

ls.distinct

// .minBy(_._2)

// .sortBy(_._1)

def distinctBy[B, C](xs: List[B], 

                     f: B => C, 

                     acc: List[C] = Nil): List[B] = xs match {

  case Nil => Nil

  case x::xs => {

    val res = f(x)

    if (acc.contains(res)) distinctBy(xs, f, acc)  

    else x::distinctBy(xs, f, res::acc)

  }

} 

val cs = List('A', 'b', 'a', 'c', 'B', 'D', 'd')

distinctBy(cs, (c:Char) => c.toUpper)

// since 2.13

cs.distinctBy((c:Char) => c.toUpper)

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

// (Immutable)

// Object Oriented Programming in Scala

//

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

abstract class Animal

case class Bird(name: String) extends Animal {

   override def toString = name

}

case class Mammal(name: String) extends Animal

case class Reptile(name: String) extends Animal

Mammal("Zebra")

println(Mammal("Zebra"))

println(Mammal("Zebra").toString)

Bird("Sparrow")

println(Bird("Sparrow"))

println(Bird("Sparrow").toString)

// There is a very convenient short-hand notation

// for constructors:

class Fraction(x: Int, y: Int) {

  def numer = x

  def denom = y

val half = new Fraction(1, 2)

case class Fraction(numer: Int, denom: Int)

val half = Fraction(1, 2)

half.denom

// In mandelbrot.scala I used complex (imaginary) numbers 

// and implemented the usual arithmetic operations for complex 

// numbers.

case class Complex(re: Double, im: Double) { 

  // represents the complex number re + im * i

  def +(that: Complex) = Complex(this.re + that.re, this.im + that.im)

  def -(that: Complex) = Complex(this.re - that.re, this.im - that.im)

  def *(that: Complex) = Complex(this.re * that.re - this.im * that.im,

                                 this.re * that.im + that.re * this.im)

  def *(that: Double) = Complex(this.re * that, this.im * that)

  def abs = Math.sqrt(this.re * this.re + this.im * this.im)

}

val test = Complex(1, 2) + Complex (3, 4)

// this could have equally been written as

val test = Complex(1, 2).+(Complex (3, 4))

// this applies to all methods, but requires

import scala.language.postfixOps

List(5, 2, 3, 4).sorted

List(5, 2, 3, 4) sorted

// ...to allow the notation n + m * i

import scala.language.implicitConversions   

val i = Complex(0, 1)

implicit def double2complex(re: Double) = Complex(re, 0)

val inum1 = -2.0 + -1.5 * i

val inum2 =  1.0 +  1.5 * i

// All is public by default....so no public is needed.

// You can have the usual restrictions about private 

// values and methods, if you are MUTABLE !!!

case class BankAccount(init: Int) {

  private var balance = init

  def deposit(amount: Int): Unit = {

    if (amount > 0) balance = balance + amount

  }

  def withdraw(amount: Int): Int =

    if (0 < amount && amount <= balance) {

      balance = balance - amount

      balance

    } else throw new Error("insufficient funds")

// BUT since we are completely IMMUTABLE, this is 

// virtually of not concern to us.

// another example about Fractions

import scala.language.implicitConversions

import scala.language.reflectiveCalls

case class Fraction(numer: Int, denom: Int) {

  override def toString = numer.toString + "/" + denom.toString

  def +(other: Fraction) = Fraction(numer + other.numer, denom + other.denom)

  def /(other: Fraction) = Fraction(numer * other.denom, denom * other.numer)

 }

implicit def Int2Fraction(x: Int) = Fraction(x, 1)

val half = Fraction(1, 2)

val third = Fraction (1, 3)

half + third

half / third

(1 / 3) + half

(1 / 2) + third

// DFAs in Scala  

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

import scala.util.Try

// A is the state type

// C is the input (usually characters)

case class DFA[A, C](start: A,              // starting state

                     delta: (A, C) => A,    // transition function

                     fins:  A => Boolean) { // final states (Set)

  def deltas(q: A, s: List[C]) : A = s match {

    case Nil => q

    case c::cs => deltas(delta(q, c), cs)

  }

  def accepts(s: List[C]) : Boolean = 

    Try(fins(deltas(start, s))) getOrElse false

// the example shown in the handout 

abstract class State

case object Q0 extends State

case object Q1 extends State

case object Q2 extends State

case object Q3 extends State

case object Q4 extends State

val delta : (State, Char) => State = 

  { case (Q0, 'a') => Q1

    case (Q0, 'b') => Q2

    case (Q1, 'a') => Q4

    case (Q1, 'b') => Q2

    case (Q2, 'a') => Q3

    case (Q2, 'b') => Q2

    case (Q3, 'a') => Q4

    case (Q3, 'b') => Q0

    case (Q4, 'a') => Q4

    case (Q4, 'b') => Q4 

    case _ => throw new Exception("Undefined") }

val dfa = DFA(Q0, delta, Set[State](Q4))

dfa.accepts("abaaa".toList)     // true

dfa.accepts("bbabaab".toList)   // true

dfa.accepts("baba".toList)      // false

dfa.accepts("abc".toList)       // false

// NFAs (Nondeterministic Finite Automata)

case class NFA[A, C](starts: Set[A],          // starting states

                     delta: (A, C) => Set[A], // transition function

                     fins:  A => Boolean) {   // final states 

  // given a state and a character, what is the set of 

  // next states? if there is none => empty set

  def next(q: A, c: C) : Set[A] = 

    Try(delta(q, c)) getOrElse Set[A]() 

  def nexts(qs: Set[A], c: C) : Set[A] =

    qs.flatMap(next(_, c))

  // depth-first version of accepts

  def search(q: A, s: List[C]) : Boolean = s match {

    case Nil => fins(q)

    case c::cs => next(q, c).exists(search(_, cs))

  }

  def accepts(s: List[C]) : Boolean =

    starts.exists(search(_, s))

// NFA examples

val nfa_trans1 : (State, Char) => Set[State] = 

  { case (Q0, 'a') => Set(Q0, Q1) 

    case (Q0, 'b') => Set(Q2) 

    case (Q1, 'a') => Set(Q1) 

    case (Q2, 'b') => Set(Q2) }

val nfa = NFA(Set[State](Q0), nfa_trans1, Set[State](Q2))

nfa.accepts("aa".toList)             // false

nfa.accepts("aaaaa".toList)          // false

nfa.accepts("aaaaab".toList)         // true

nfa.accepts("aaaaabbb".toList)       // true

nfa.accepts("aaaaabbbaaa".toList)    // false

nfa.accepts("ac".toList)             // false