pep-material: comparison progs/lecture5.scala

equal deleted inserted replaced

-:0e591f806290
+:8a34b2ebc8cc
 // Scala Lecture 5
 //=================
 // Laziness with style
 //=====================
 // The concept of lazy evaluation doesn’t really
 // exist in non-functional languages. C-like languages
-// are strict. To see the difference, consider
+// are (sort of) strict. To see the difference, consider
 def square(x: Int) = x * x
 square(42 + 8)
 // This is called "strict evaluation".
-// In contrast, say we have a pretty expensive operation:
+// On the contrary, say we have a pretty expensive operation:
 def peop(n: BigInt): Boolean = peop(n + 1)
 val a = "foo"
-val b = "bar"
+val b = "foo"
 if (a == b || peop(0)) println("true") else println("false")
 // This is called "lazy evaluation":
 // you delay compuation until it is really
 s.head #:: generatePrimes(s.tail.filter(_ % s.head != 0))
 val primes = generatePrimes(LazyList.from(2))
 // the first 10 primes
-primes.take(10).toList
+primes.take(100).toList
 time_needed(1, primes.filter(_ > 100).take(3000).toList)
 time_needed(1, primes.filter(_ > 100).take(3000).toList)
 // A Stream (LazyList) of successive numbers:
 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.%
 (for (r1 <- rs; r2 <- rs) yield SEQ(r1, r2)) #:::
 (for (r1 <- rs) yield STAR(r1)) )
 enum(LazyList(ZERO, ONE, CHAR('a'), CHAR('b'))).take(200).force
-enum(LazyList(ZERO, ONE, CHAR('a'), CHAR('b'))).take(5_000_000)
+enum(LazyList(ZERO, ONE, CHAR('a'), CHAR('b'))).take(5_000_000).force
+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
+}
 val is =
 (enum(LazyList(ZERO, ONE, CHAR('a'), CHAR('b')))
 .dropWhile(depth(_) < 3)
 // 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)
+case _::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))
+length_string_list(List(1, 2, 3, 4))
 // you can make the function parametric in type(s)
 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[String](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
 f: B => C,
 acc: List[C] = Nil): List[B] = xs match {
 case Nil => Nil
 case x::xs => {
 val res = f(x)
-if (acc.contains(res)) distinctBy(xs, f, acc)
+if (acc.contains(res) distinctBy(xs, f, acc)
 else x::distinctBy(xs, f, res::acc)
 }
 }
 val cs = List('A', 'b', 'a', 'c', 'B', 'D', 'd')
 val x = id(322)          // Int
 val y = id("hey")        // String
 val z = id(Set(1,2,3,4)) // Set[Int]
+id[+A, -B]
 // The type variable concept in Scala can get really complicated.
 //
 // - variance (OO)
 // - bounds (subtyping)
 var arr = Array[Int]()
 arr(0) = "Hello World"
 // (Immutable)
 // Object Oriented Programming in Scala
 //
 // =====================================
-abstract class Animal
+abstract class Animal
 case class Bird(name: String) extends Animal {
 override def toString = name
 }
 case class Mammal(name: String) extends Animal
 case class Reptile(name: String) extends Animal
 half + third
 half / third
 (1 / 3) + half
 (1 / 2) + third
 // DFAs in Scala
 //===============
 import scala.util.Try
 val eight = 0.8
 val six   = 0.6
 two - one == one
 eight - six == two
+eight - six
+// problems about equality and type-errors
-List(1, 2, 3).contains("your cup")
+List(1, 2, 3).contains("your cup")   // should not compile, but retruns false
+List(1, 2, 3) == Vector(1, 2, 3)     // again should not compile, but returns true
 // I like best about Scala that it lets me often write
 // concise, readable code. And it hooks up with the
 // Isabelle theorem prover.
 // Puzzlers
-val MONTH = 12
+val month = 12
-val DAY = 24
+val day = 24
-val (HOUR, MINUTE, SECOND) = (12, 0, 0)
+val (hour, min, sec) = (12, 0, 0)
 // use lowercase names for variable
 //==================
 val oneTwo = Seq(1, 2, 3).permutations
 if (oneTwo.length > 0) {
-println("Permutations of 1 and 2:")
+println("Permutations of 1,2 and 3:")
 oneTwo.foreach(println)
 }
 val threeFour = Seq(3, 4, 5).permutations
 if (!threeFour.isEmpty) {
-println("Permutations of 3 and 4:")
+println("Permutations of 3, 4 and 5:")
 threeFour.foreach(println)
 }
 //==================
 val (a, b, c) =
 //destined to fail at runtime.
 //================
 // does not work anymore in 2.13.0
-val numbers = List("1", "2").toSet() + "3"
+val numbers = List("1", "2").toSet + "3"

changeset 329	8a34b2ebc8cc
parent 328	0e591f806290
child 333	24bc76d97db2