// Scala Lecture 5

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

// Laziness with style

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

// The concept of lazy evaluation doesn’t really 

// exist in non-functional languages, but it is 

// pretty easy to grasp. Consider first 

def square(x: Int) = x * x

square(42 + 8)

// this is called strict evaluation

// say we have a pretty expensive operation

def peop(n: BigInt): Boolean = peop(n + 1) 

val a = "foo"

val b = "bar"

if (a == b || peop(0)) println("true") else println("false")

// this is called lazy evaluation

// you delay compuation until it is really 

// needed; once calculated though, does not 

// need to be re-calculated

// a useful example is

def time_needed[T](i: Int, code: => T) = {

  val start = System.nanoTime()

  for (j <- 1 to i) code

  val end = System.nanoTime()

  f"${(end - start) / (i * 1.0e9)}%.6f secs"

}

// streams (I do not care how many)

// primes: 2, 3, 5, 7, 9, 11, 13 ....

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

  s.head #:: generatePrimes(s.tail.filter(_ % s.head != 0))

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

// the first 10 primes

primes.take(10).par.toList

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

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

// a stream of successive numbers

Stream.from(2).print

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

Stream.from(2).take(10).print

Stream.from(10).take(10).print

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

// iterative version of the Fibonacci numbers

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

  a #:: fibIter(b, a + b)

fibIter(1, 1).take(10).force

fibIter(8, 13).take(10).force

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

// good for testing

// Regular expressions - the power of DSLs in Scala

//                                     and Laziness

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

abstract class Rexp

case object ZERO extends Rexp                     // nothing

case object ONE extends Rexp                      // the empty string

case class CHAR(c: Char) extends Rexp             // a character c

case class ALT(r1: Rexp, r2: Rexp) extends Rexp   // alternative  r1 + r2

case class SEQ(r1: Rexp, r2: Rexp) extends Rexp   // sequence     r1 . r2  

case class STAR(r: Rexp) extends Rexp             // star         r*

// some convenience for typing in regular expressions

import scala.language.implicitConversions    

import scala.language.reflectiveCalls 

def charlist2rexp(s: List[Char]): Rexp = s match {

  case Nil => ONE

  case c::Nil => CHAR(c)

  case c::s => SEQ(CHAR(c), charlist2rexp(s))

}

implicit def string2rexp(s: String): Rexp = 

  charlist2rexp(s.toList)

implicit def RexpOps (r: Rexp) = new {

  def | (s: Rexp) = ALT(r, s)

  def % = STAR(r)

  def ~ (s: Rexp) = SEQ(r, s)

}

implicit def stringOps (s: String) = new {

  def | (r: Rexp) = ALT(s, r)

  def | (r: String) = ALT(s, r)

  def % = STAR(s)

  def ~ (r: Rexp) = SEQ(s, r)

  def ~ (r: String) = SEQ(s, r)

}

def depth(r: Rexp) : Int = r match {

  case ZERO => 0

  case ONE => 0

  case CHAR(_) => 0

  case ALT(r1, r2) => Math.max(depth(r1), depth(r2)) + 1

  case SEQ(r1, r2) => Math.max(depth(r1), depth(r2)) + 1 

  case STAR(r1) => depth(r1) + 1

}

//example regular expressions

val digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"

val sign = "+" | "-" | ""

val number = sign ~ digit ~ digit.% 

// task: enumerate exhaustively regular expression

// starting from small ones towards bigger ones.

// 1st idea: enumerate them all in a Set

// up to a level

def enuml(l: Int, s: String) : Set[Rexp] = l match {

  case 0 => Set(ZERO, ONE) ++ s.map(CHAR).toSet

  case n =>  

    val rs = enuml(n - 1, s)

    rs ++

    (for (r1 <- rs; r2 <- rs) yield ALT(r1, r2)) ++

    (for (r1 <- rs; r2 <- rs) yield SEQ(r1, r2)) ++

    (for (r1 <- rs) yield STAR(r1))

}

enuml(1, "a")

enuml(1, "a").size

enuml(2, "a").size

enuml(3, "a").size 

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

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

  rs #::: enum( (for (r1 <- rs; r2 <- rs) yield ALT(r1, r2)) #:::

                (for (r1 <- rs; r2 <- rs) yield SEQ(r1, r2)) #:::

                (for (r1 <- rs) yield STAR(r1)) )

enum(ZERO #:: ONE #:: "ab".toStream.map(CHAR)).take(200).force

enum(ZERO #:: ONE #:: "ab".toStream.map(CHAR)).take(5000000)

val is = 

  (enum(ZERO #:: ONE #:: "ab".toStream.map(CHAR))

    .dropWhile(depth(_) < 3)

    .take(10).foreach(println))

// Parsing - The Solved Problem That Isn't

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

//

// https://tratt.net/laurie/blog/entries/parsing_the_solved_problem_that_isnt.html

//

// Or, A topic of endless "fun"(?)

// input type: String

// output type: Int

/* Note, in the previous lectures I did not show the type consraint

 * I <% Seq[_] , which means that the input type I can be

 * treated, or seen, as a sequence. */

abstract class Parser[I <% Seq[_], T] {

  def parse(ts: I): Set[(T, I)]

  def parse_all(ts: I) : Set[T] =

    for ((head, tail) <- parse(ts); 

        if (tail.isEmpty)) yield head

}

// the idea is that a parser can parse something

// from the input and leaves something unparsed => pairs

class AltParser[I <% Seq[_], T](

  p: => Parser[I, T], 

  q: => Parser[I, T]) extends Parser[I, T] {

  def parse(sb: I) = p.parse(sb) ++ q.parse(sb)   

}

class SeqParser[I <% Seq[_], T, S](

  p: => Parser[I, T], 

  q: => Parser[I, S]) extends Parser[I, (T, S)] {

  def parse(sb: I) = 

    for ((head1, tail1) <- p.parse(sb); 

         (head2, tail2) <- q.parse(tail1)) yield ((head1, head2), tail2)

}

class FunParser[I <% Seq[_], T, S](

  p: => Parser[I, T], 

  f: T => S) extends Parser[I, S] {

  def parse(sb: I) = 

    for ((head, tail) <- p.parse(sb)) yield (f(head), tail)

}

// atomic parsers  

case class CharParser(c: Char) extends Parser[String, Char] {

  def parse(sb: String) = 

    if (sb != "" && sb.head == c) Set((c, sb.tail)) else Set()

}

import scala.util.matching.Regex

case class RegexParser(reg: Regex) extends Parser[String, String] {

  def parse(sb: String) = reg.findPrefixMatchOf(sb) match {

    case None => Set()

    case Some(m) => Set((m.matched, m.after.toString))  

  }

}

val NumParser = RegexParser("[0-9]+".r)

def StringParser(s: String) = RegexParser(Regex.quote(s).r)

println(NumParser.parse_all("12u45"))

// convenience

implicit def string2parser(s: String) = StringParser(s)

implicit def char2parser(c: Char) = CharParser(c)

implicit def ParserOps[I<% Seq[_], T](p: Parser[I, T]) = new {

  def | (q : => Parser[I, T]) = new AltParser[I, T](p, q)

  def ==>[S] (f: => T => S) = new FunParser[I, T, S](p, f)

  def ~[S] (q : => Parser[I, S]) = new SeqParser[I, T, S](p, q)

}

implicit def StringOps(s: String) = new {

  def | (q : => Parser[String, String]) = new AltParser[String, String](s, q)

  def | (r: String) = new AltParser[String, String](s, r)

  def ==>[S] (f: => String => S) = new FunParser[String, String, S](s, f)

  def ~[S] (q : => Parser[String, S]) = 

    new SeqParser[String, String, S](s, q)

  def ~ (r: String) = 

    new SeqParser[String, String, String](s, r)

}

NumParser.parse_all("12345")

NumParserInt.parse_all("12345")

NumParserInt.parse_all("12u45")

// grammar for arithmetic expressions

//

//  E ::= T + E | T - E | T

//  T ::= F * T | F

//  F ::= ( E ) | Number

lazy val E: Parser[String, Int] = 

  (T ~ "+" ~ E) ==> { case ((x, y), z) => x + z } |

  (T ~ "-" ~ E) ==> { case ((x, y), z) => x - z } | T 

lazy val T: Parser[String, Int] = 

  (F ~ "*" ~ T) ==> { case ((x, y), z) => x * z } | F

lazy val F: Parser[String, Int] = 

  ("(" ~ E ~ ")") ==> { case ((x, y), z) => y } | NumParserInt

println(E.parse_all("4*2+3"))

println(E.parse_all("4*(2+3)"))

println(E.parse_all("(4)*((2+3))"))

println(E.parse_all("4/2+3"))

println(E.parse_all("(1+2)+3"))

println(E.parse_all("1+2+3")) 

// The End ... Almost Christmas

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

// I hope you had fun!

// A function should do one thing, and only one thing.

// Make your variables immutable, unless there's a good 

// reason not to.

// I did it, but this is actually not a good reason:

// generating new labels:

var counter = -1

def Fresh(x: String) = {

  counter += 1

  x ++ "_" ++ counter.toString()

}

Fresh("x")

Fresh("x")

// You can be productive on Day 1, but the language is deep.

//

// http://scalapuzzlers.com

//

// http://www.latkin.org/blog/2017/05/02/when-the-scala-compiler-doesnt-help/

// I like best about Scala that it lets me often write

// concise, readable code. And it hooks up with the 

// Isabelle theorem prover.