// 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+
−
Integer.parseInt("123u456")+
−
+
−
/* 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)+
−
+
−
NumParser.parse_all("12u345")+
−
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)+
−
}+
−
+
−
+
−
val NumParserInt = NumParser ==> (s => 2 * s.toInt)+
−
+
−
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/+
−
+
−
List(1, 2, 3).contains("your mom")+
−
+
−
// I like best about Scala that it lets me often write+
−
// concise, readable code. And it hooks up with the +
−
// Isabelle theorem prover.+
−
+
−