diff -r 9e7897f25e13 -r e52cc402caee progs/lecture4.scala --- a/progs/lecture4.scala Thu Nov 29 17:15:11 2018 +0000 +++ b/progs/lecture4.scala Fri Nov 30 03:44:27 2018 +0000 @@ -1,3 +1,54 @@ +// Scala Lecture 4 +//================= + + +// 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)) + +//----- +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 * x) + + +// Remember? +def first[A, B](xs: List[A], f: A => Option[B]) : Option[B] = ... + + +// distinct / distinctBy + +val ls = List(1,2,3,3,2,4,3,2,1) +ls.distinct + + def distinctBy[B, C](xs: List[B], f: B => C, acc: List[C] = Nil): List[B] = xs match { case Nil => Nil case (x::xs) => { @@ -7,5 +58,383 @@ } } +distinctBy(ls, (x: Int) => x) + + +val cs = List('A', 'b', 'a', 'c', 'B', 'D', 'd') + +distinctBy(cs, (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, but raises an exception +// at runtime + +//Object[] arr = new Integer[10]; +//arr[0] = "Hello World"; + + +// Scala gives you a compile-time error + +var arr = Array[Int]() +arr(0) = "Hello World" + + + + + + +// +// Object Oriented Programming in Scala +// +// ===================================== + +abstract class Animal +case class Bird(name: String) extends Animal +case class Mammal(name: String) extends Animal +case class Reptile(name: String) extends Animal + +println(new Bird("Sparrow")) +println(Bird("Sparrow").toString) + + +// you can override methods +case class Bird(name: String) extends Animal { + override def toString = name +} + + +// There is a very convenient short-hand notation +// for constructors + +class Fraction(x: Int, y: Int) { + def numer = x + def denom = y +} + + +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 +object i extends 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 +// 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 IMMUTABLE, this is virtually of not +// concern to us. + + + + + +// 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 + + 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 + +// another DFA test with a Sink state +abstract class S +case object S0 extends S +case object S1 extends S +case object S2 extends S +case object Sink extends S + +// transition function with a sink state +val sigma : (S, Char) :=> S = + { case (S0, 'a') => S1 + case (S1, 'a') => S2 + case _ => Sink + } + +val dfa2 = DFA(S0, sigma, Set[S](S2)) + +dfa2.accepts("aa".toList) // true +dfa2.accepts("".toList) // false +dfa2.accepts("ab".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 + + +// Q: Why the kerfuffle about the polymorphic types in DFAs/NFAs +// A: Subset construction + +def subset[A, C](nfa: NFA[A, C]) : DFA[Set[A], C] = { + DFA(nfa.starts, + { case (qs, c) => nfa.nexts(qs, c) }, + _.exists(nfa.fins)) +} + +subset(nfa1).accepts("aa".toList) // false +subset(nfa1).accepts("aaaaa".toList) // false +subset(nfa1).accepts("aaaaab".toList) // true +subset(nfa1).accepts("aaaaabbb".toList) // true +subset(nfa1).accepts("aaaaabbbaaa".toList) // false +subset(nfa1).accepts("ac".toList) // false + + + + + + + +// Cool Stuff in Scala +//===================== + + +// Implicits or How to Pimp my Library +//===================================== +// +// For example adding your own methods to Strings: +// Imagine you want to increment strings, like +// +// "HAL".increment +// +// you can avoid ugly fudges, like a MyString, by +// using implicit conversions. + + +implicit class MyString(s: String) { + def increment = for (c <- s) yield (c + 1).toChar +} + +"HAL".increment + + + + +// Regular expressions - the power of DSLs in Scala +//================================================== + +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* + + + +// (ab)* +val r0 = STAR(SEQ(CHAR('a'), CHAR('b'))) + + +// 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) + + +val r1 = STAR("ab") +val r2 = STAR(ALT("ab", "baa baa black sheep")) +val r3 = STAR(SEQ("ab", ALT("a", "b"))) + +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) +} + +//example regular expressions +val digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" +val sign = "+" | "-" | "" +val number = sign ~ digit ~ digit.% + + + +// Lazy Evaluation +//================= +// +// do not evaluate arguments just yet + +def time_needed[T](i: Int, code: => T) = { + val start = System.nanoTime() + for (j <- 1 to i) code + val end = System.nanoTime() + (end - start)/(i * 1.0e9) +} + +// same examples using the internal regexes +val evil = "(a*)*b" + +("a" * 10 ++ "b").matches(evil) +("a" * 10).matches(evil) +("a" * 10000).matches(evil) +("a" * 20000).matches(evil) + +time_needed(2, ("a" * 10000).matches(evil))