// 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 * xsquare(42 + 8)// this is called strict evaluation// say we have a pretty expensive operationdef 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 isdef 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 primesprimes.take(10).par.toListtime_needed(1, primes.filter(_ > 100).take(3000).toList)time_needed(1, primes.filter(_ > 100).take(1000).toList)// a stream of successive numbersStream.from(2).printStream.from(2).take(10).forceStream.from(2).take(10).printStream.from(10).take(10).printStream.from(2).take(10).force// iterative version of the Fibonacci numbersdef fibIter(a: BigInt, b: BigInt): Stream[BigInt] = a #:: fibIter(b, a + b)fibIter(1, 1).take(10).forcefibIter(8, 13).take(10).forcefibIter(1, 1).drop(10000).take(1).print// good for testing// Regular expressions - the power of DSLs in Scala// and Laziness//==================================================abstract class Rexpcase object ZERO extends Rexp // nothingcase object ONE extends Rexp // the empty stringcase class CHAR(c: Char) extends Rexp // a character ccase class ALT(r1: Rexp, r2: Rexp) extends Rexp // alternative r1 + r2case 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 expressionsimport 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 expressionsval 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 leveldef 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").sizeenuml(2, "a").sizeenuml(3, "a").size enuml(4, "a").size // out of heap spacedef 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).forceenum(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: IntInteger.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 => pairsclass 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.Regexcase 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"))// convenienceimplicit 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 ) | Numberlazy 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 } | Flazy val F: Parser[String, Int] = ("(" ~ E ~ ")") ==> { case ((x, y), z) => y } | NumParserIntprintln(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 = -1def 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.