pep-material: comparison progs/lecture4.scala

equal deleted inserted replaced

-:ec9cbf969edf
+:417df5986615
 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 {
+def distinctBy[B, C](xs: List[B],
+f: B => C,
+acc: List[C] = Nil): List[B] = xs match {
 case Nil => Nil
-case (x::xs) => {
+case x::xs => {
 val res = f(x)
 if (acc.contains(res)) distinctBy(xs, f, acc)
 else x::distinctBy(xs, f, res::acc)
 }
 }
+// distinctBy  with the identity function is
+// just distinct
 distinctBy(ls, (x: Int) => x)
 val cs = List('A', 'b', 'a', 'c', 'B', 'D', 'd')
 // 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]
 // - variance (OO)
 // - bounds (subtyping)
 // - quantification
 // Java has issues with this too: Java allows
-// to write the following, but raises an exception
+// to write the following incorrect code, and
-// at runtime
+// only recovers by raising an exception
+// at runtime.
-//Object[] arr = new Integer[10];
-//arr[0] = "Hello World";
+// Object[] arr = new Integer[10];
+// arr[0] = "Hello World";
 // Scala gives you a compile-time error
 var arr = Array[Int]()
 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"))
 println(Bird("Sparrow").toString)
 // you can override methods
 case class Bird(name: String) extends Animal {
 val half = Fraction(1, 2)
 half.denom
-// in mandelbrot.scala I used complex (imaginary) numbers and implemented
+// In mandelbrot.scala I used complex (imaginary) numbers
-// the usual arithmetic operations for complex 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)
 List(5, 2, 3, 4).sorted
 List(5, 2, 3, 4) sorted
-// to allow the notation n + m * i
+// ...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
+// All is public by default....so no public is needed.
-// you can have the usual restrictions about private values
+// You can have the usual restrictions about private
-// and methods, if you are MUTABLE(!!!)
+// values and methods, if you are MUTABLE !!!
 case class BankAccount(init: Int) {
 private var balance = init
 balance = balance - amount
 balance
 } else throw new Error("insufficient funds")
 }
-// BUT since we are IMMUTABLE, this is virtually of not
+// BUT since we are completely IMMUTABLE, this is
-// concern to us.
+// virtually of not concern to us.
 // A is the state type
 // C is the input (usually characters)
-case class DFA[A, C](start: A,               // starting state
+case class DFA[A, C](start: A,              // starting state
-delta: (A, C) => A,     // transition function
+delta: (A, C) => A,    // transition function
-fins:  A => Boolean) {  // final states
+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)
 }
 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
+// another DFA 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 =
+val sigma : (S, Char) => S =
 { case (S0, 'a') => S1
 case (S1, 'a') => S2
 case _ => Sink
 }
 dfa2.accepts("aa".toList)        // true
 dfa2.accepts("".toList)          // false
 dfa2.accepts("ab".toList)        // false
+//  we could also have a dfa for numbers
+val sigmai : (S, Int) => S =
+{ case (S0, 1) => S1
+case (S1, 1) => S2
+case _ => Sink
+}
+val dfa3 = DFA(S0, sigmai, Set[S](S2))
+dfa3.accepts(List(1, 1))        // true
+dfa3.accepts(Nil)               // false
+dfa3.accepts(List(1, 2))        // false
 // NFAs (Nondeterministic Finite Automata)
-case class NFA[A, C](starts: Set[A],           // starting states
+case class NFA[A, C](starts: Set[A],          // starting states
-delta: (A, C) => Set[A],  // transition function
+delta: (A, C) => Set[A], // transition function
-fins:  A => Boolean) {    // final states
+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))
 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
+// 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) },

changeset 223	417df5986615
parent 222	ec9cbf969edf
child 224	1a45c9bcc77b