pep-material: comparison progs/lecture2.scala

equal deleted inserted replaced

-:73ce78e5b91c
+:19856bd9ec2d
 for (i <- (0 until lst.length).toList) yield square(lst(i))
 // this is just so prone to off-by-one errors;
 // write instead
-for (e <- lst) yield square(e)
+for (e <- lst; if (e % 2) == 0; if (e != 4)) yield square(e)
 //this works for sets as well
 val st = Set(1, 2, 3, 4, 5, 6, 7, 8, 9)
 // Side-Effects
 //==============
 // with only a side-effect (no list is produced),
-// has no "yield"
+// for has no "yield"
 for (n <- (1 to 10)) println(n)
 for (n <- (1 to 10)) {
 // know when to use yield and when not:
-for (e <- Set(1, 2, 3, 4, 5, 6, 7, 8, 9); if e < 5) yield square(e)
+val test =
+for (e <- Set(1, 2, 3, 4, 5, 6, 7, 8, 9); if e < 5) yield square(e)
 // Option type
 //=============
 //in Scala you use Option
 //   - if the value is present, you use Some(value)
 //   - if no value is present, you use None
-List(7,2,3,4,5,6).find(_ < 4)
+List(7,24,3,4,5,6).find(_ < 4)
 List(5,6,7,8,9).find(_ < 4)
+List(7,2,3,4,5,6).filter(_ < 4)
 // some operations on Option's
 val lst = List(None, Some(1), Some(2), None, Some(3))
 lst.flatten
-Some(1).get
+Some(10).get
+None.get
 Some(1).isDefined
 None.isDefined
 val ps = List((3, 0), (3, 2), (4, 2), (2, 0), (1, 0), (1, 1))
 import io.Source
 val my_url = """https://nms.kcl.ac.uk/christian.urban"""
+//val my_url = """https://nms.kcl.ac.uk/christan.urban"""  // misspelled
 Source.fromURL(my_url).mkString
 Try(Source.fromURL(my_url).mkString).getOrElse("")
 // code could potentially throw a NullPointerException.
 // even Scala is not immune to problems like this:
-List(5,6,7,8,9).indexOf(7)
+List(5,6,7,8,9).indexOf(42)
+// ... how are we supposed to know that this returns -1
 // Higher-Order Functions
 //========================
 val lst = (1 to 10).toList
 def even(x: Int) : Boolean = x % 2 == 0
 def odd(x: Int) : Boolean = x % 2 == 1
-lst.filter(x => even(x))
+lst.filter(x => even(x) && odd(x))
 lst.filter(even(_))
-lst.filter(even)
+lst.filter(odd && even)
 lst.find(_ > 8)
 // map applies a function to each element of a list
 def square(x: Int): Int = x * x
+val lst = (1 to 10).toList
 lst.map(square)
 lst.map(square).filter(_ > 4)
 lst.map(square).filter(_ > 4).map(square)
 // map works for most collection types, including sets
-Set(1, 3, 6).map(square)
+Set(1, 3, 6).map(square).filter(_ > 4)
-// Why could functions as arguments be useful?
+val l = List((1, 3),(2, 4),(4, 1),(6, 2))
+l.map(square(_._1))
+// Why are functions as arguments useful?
 //
 // Consider the sum between a and b:
 def sumInts(a: Int, b: Int) : Int =
 if (a > b) 0 else a + sumInts(a + 1, b)
-sumInt(10, 16)
+sumInts(10, 16)
 // sum squares
 def square(n: Int) : Int = n * n
 def sumSquares(a: Int, b: Int) : Int =
 sumFacts(2, 6)
-// You can see the pattern....can we simplify out work?
+// You can see the pattern....can we simplify our work?
 // The type of functions from ints to ints: Int => Int
 def sum(f: Int => Int, a: Int, b: Int) : Int = {
 if (a > b) 0
 else f(a) + sum(f, a + 1, b)
 // What should we do for sumInts?
 def id(n: Int) : Int = n
 def sumInts(a: Int, b: Int) : Int = sum(id, a, b)
+sumInts(10, 12)
 // Anonymous Functions: You can also write:
 def sumCubes(a: Int, b: Int) : Int =   sum(x => x * x * x, a, b)
 // an aside: partial application
 def add(a: Int)(b: Int) : Int = a + b
+def add_abc(a: Int)(b: Int)(c: Int) : Int = a + b + c
+val add2 : Int => Int = add(2)
+add2(5)
+val add2_bc : Int => Int => Int = add_abc(2)
+val add2_9_c : Int => Int = add2_bc(9)
+add2_9_c(10)
 sum(add(2), 0, 2)
 sum(add(10), 0, 2)
-def add2(a: Int, b: Int) : Int = a + b
-sum(x => add2(2, x), 0, 2)
-sum(x => add2(10, x), 0, 2)
 // Function Composition
 //======================
-// How could Higher-Order Functions and Options be helpful?
+// How can be Higher-Order Functions and Options be helpful?
 def add_footer(msg: String) : String = msg ++ " - Sent from iOS"
 def valid_msg(msg: String) : Boolean = msg.size <= 140
 def duplicate(s: String) : String = s ++ s
-// they compose nicely
+// they compose very nicely, e.g
 valid_msg(add_footer("Hello World"))
-valid_msg(duplicate(add_footer("Hello World")))
+valid_msg(duplicate(duplicate(add_footer("Helloooooooooooooooooo World"))))
+// but not all functions do
 // first_word: let's first do it the ugly Java way using null:
 def first_word(msg: String) : String = {
 val words = msg.split(" ")
 if (words(0) != "") words(0) else null
 def extended_duplicate(s: String) : String =
 if (s != null) s ++ s else null
 extended_duplicate(first_word(""))
+// but this is against the rules of the game: we do not want
+// to change duplicate, because first_word might return null
 // Avoid always null!
 def better_first_word(msg: String) : Option[String] = {
 val words = msg.split(" ")
 if (words(0) != "") Some(words(0)) else None
 }
 better_first_word("Hello World").map(duplicate)
-better_first_word("Hello World").map(duplicate).map(duplicate).map(valid_msg)
+better_first_word("Hello World").map(duplicate)
+better_first_word("").map(duplicate).map(duplicate).map(valid_msg)
 better_first_word("").map(duplicate)
 better_first_word("").map(duplicate).map(valid_msg)
-// Implicits (Cool Feature)
-//=========================
-//
-// 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
-// No returns in Scala
-//====================
-// You should not use "return" in Scala:
-//
-// A return expression, when evaluated, abandons the
-// current computation and returns to the caller of the
-// function in which return appears."
-def sq1(x: Int): Int = x * x
-def sq2(x: Int): Int = return x * x
-def sumq(ls: List[Int]): Int = {
-ls.map(sq1).sum[Int]
-}
-sumq(List(1, 2, 3, 4))
-def sumq(ls: List[Int]): Int = {
-val sqs : List[Int] = for (x <- ls) yield (return x * x)
-sqs.sum
-}
 // Pattern Matching
 //==================
 // remember
 val lst = List(None, Some(1), Some(2), None, Some(3)).flatten
 def my_flatten(xs: List[Option[Int]]): List[Int] = {
-...
+...?
 }
 case None::xs => my_flatten(xs)
 case Some(n)::xs => n::my_flatten(xs)
 }
-// another example
+// another example including a catch-all pattern
 def get_me_a_string(n: Int): String = n match {
 case 0 => "zero"
 case 1 => "one"
 case 2 => "two"
 case _ => "many"
 case Green() => true
 case Blue()  => false
 }
-// actually this can be written with "object"
+// actually colors can be written with "object",
+// because they do not take any arguments
 // another example
 //=================
+// Once upon a time, in a complete fictional country there were persons...
 abstract class Person
 case class King() extends Person
 case class Peer(deg: String, terr: String, succ: Int) extends Person
 case class Knight(name: String) extends Person
 // Problems with mutability and parallel computations
 //====================================================
 def count_intersection(A: Set[Int], B: Set[Int]) : Int = {
 var count = 0
 val A = (1 to 1000).toSet
 val B = (1 to 1000 by 4).toSet
 count_intersection(A, B)
-// but do not try to add .par to the for-loop above
+// but do not try to add .par to the for-loop above,
+// otherwise you will be caught in race-condition hell.
 //propper parallel version
 def count_intersection2(A: Set[Int], B: Set[Int]) : Int =
 A.par.count(x => B contains x)
 time_needed(10, count_intersection(A, B))
 time_needed(10, count_intersection2(A, B))
+// Implicits (Cool Feature)
+//=========================
+//
+// 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
+// No returns in Scala
+//====================
+// You should not use "return" in Scala:
+//
+// A return expression, when evaluated, abandons the
+// current computation and returns to the caller of the
+// function in which return appears."
+def sq1(x: Int): Int = x * x
+def sq2(x: Int): Int = return x * x
+def sumq(ls: List[Int]): Int = {
+ls.map(sq1).sum[Int]
+}
+sumq(List(1, 2, 3, 4))
+def sumq(ls: List[Int]): Int = {
+val sqs : List[Int] = for (x <- ls) yield (return x * x)
+sqs.sum
+}
 // Type abbreviations
 //====================
 // some syntactic convenience
 type Board = List[List[Int]]
-// Sudoku
+// Sudoku in Scala
-//========
+//=================
 // THE POINT OF THIS CODE IS NOT TO BE SUPER
 // EFFICIENT AND FAST, just explaining exhaustive
 // depth-first search
 val indexes = (0 to 8).toList
 def empty(game: String) = game.indexOf(EmptyValue)
 def isDone(game: String) = empty(game) == -1
-def emptyPosition(game: String) = (empty(game) % MaxValue, empty(game) / MaxValue)
+def emptyPosition(game: String) =
+(empty(game) % MaxValue, empty(game) / MaxValue)
-def get_row(game: String, y: Int) = indexes.map(col => game(y * MaxValue + col))
-def get_col(game: String, x: Int) = indexes.map(row => game(x + row * MaxValue))
+def get_row(game: String, y: Int) =
+indexes.map(col => game(y * MaxValue + col))
+def get_col(game: String, x: Int) =
+indexes.map(row => game(x + row * MaxValue))
 get_row(game0, 3)
 get_col(game0, 0)
 def get_box(game: String, pos: Pos): List[Char] = {
 get_box(game0, (0, 0))
 get_box(game0, (1, 1))
 get_box(game0, (2, 1))
 // this is not mutable!!
-def update(game: String, pos: Int, value: Char): String = game.updated(pos, value)
+def update(game: String, pos: Int, value: Char): String =
+game.updated(pos, value)
 def toAvoid(game: String, pos: Pos): List[Char] =
 (get_col(game, pos._1) ++ get_row(game, pos._2) ++ get_box(game, pos))
-def candidates(game: String, pos: Pos): List[Char] = allValues.diff(toAvoid(game,pos))
+def candidates(game: String, pos: Pos): List[Char] =
+allValues.diff(toAvoid(game,pos))
 //candidates(game0, (0,0))
 def pretty(game: String): String =
 "\n" + (game sliding (MaxValue, MaxValue) mkString "\n")
 def search(game: String): List[String] = {
 if (isDone(game)) List(game)
 else {
 val cs = candidates(game, emptyPosition(game))
-cs.map(c => search(update(game, empty(game), c))).toList.flatten
+cs.par.map(c => search(update(game, empty(game), c))).toList.flatten
 }
 }
 search(game0).map(pretty)
 time_needed(1, search(game3))
+//===================
+// the end for today

changeset 150	19856bd9ec2d
parent 148	fc72f3ab3a57
child 155	eccf17f56922