pep-material: comparison progs/lecture2.scala

equal deleted inserted replaced

-:8b57dd326a91
+:607ceabeeffc
 // Scala Lecture 2
 //=================
+// For-Comprehensions Again
+//==========================
+// the first produces a result, while the second does not
+for (n <- List(1, 2, 3, 4, 5)) yield n * n
+for (n <- List(1, 2, 3, 4, 5)) println(n)
+// String Interpolations
+//=======================
+val n = 3
+println("The square of " + n + " is " + square(n) + ".")
+println(s"The square of ${n} is ${square(n)}.")
+// helpful for debugging purposes
+//
+//         "The most effective debugging tool is still careful thought,
+//          coupled with judiciously placed print statements."
+//                   — Brian W. Kernighan, in Unix for Beginners (1979)
+def gcd_db(a: Int, b: Int) : Int = {
+println(s"Function called with ${a} and ${b}.")
+if (b == 0) a else gcd_db(b, a % b)
+}
+gcd_db(48, 18)
 // The Option Type
 //=================
 get_contents("text.txt")
 get_contents("test.txt")
-// For-Comprehensions Again
-//==========================
-// the first produces a result, while the second does not
-for (n <- List(1, 2, 3, 4, 5)) yield n * n
-for (n <- List(1, 2, 3, 4, 5)) println(n)
-// String Interpolations
-//=======================
-val n = 3
-println("The square of " + n + " is " + square(n) + ".")
-println(s"The square of ${n} is ${square(n)}.")
-// helpful for debugging purposes
-//
-//         "The most effective debugging tool is still careful thought,
-//          coupled with judiciously placed print statements."
-//                   — Brian W. Kernighan, in Unix for Beginners (1979)
-def gcd_db(a: Int, b: Int) : Int = {
-println(s"Function called with ${a} and ${b}.")
-if (b == 0) a else gcd_db(b, a % b)
-}
-gcd_db(48, 18)
-// Asserts/Testing
-//=================
-assert(gcd(48, 18) == 6)
-assert(gcd(48, 18) == 5, "The gcd test failed")
-// Higher-Order Functions
-//========================
-// functions can take functions as arguments
-def even(x: Int) : Boolean = x % 2 == 0
-def odd(x: Int) : Boolean = x % 2 == 1
-val lst = (1 to 10).toList
-lst.filter(x => even(x))
-lst.filter(even(_))
-lst.filter(even)
-lst.count(even)
-lst.find(even)
-val ps = List((3, 0), (3, 2), (4, 2), (2, 2), (2, 0), (1, 1), (1, 0))
-lst.sortWith(_ > _)
-lst.sortWith(_ < _)
-def lex(x: (Int, Int), y: (Int, Int)) : Boolean =
-if (x._1 == y._1) x._2 < y._2 else x._1 < y._1
-ps.sortWith(lex)
-ps.sortBy(_._1)
-ps.sortBy(_._2)
-ps.maxBy(_._1)
-ps.maxBy(_._2)
-// maps (lower-case)
-//===================
-def double(x: Int): Int = x + x
-def square(x: Int): Int = x * x
-val lst = (1 to 10).toList
-lst.map(x => (double(x), square(x)))
-lst.map(square)
-// this is actually how for-comprehensions
-// defined as in Scala
-lst.map(n => square(n))
-for (n <- lst) yield square(n)
-// this can be iterated
-lst.map(square).filter(_ > 4)
-lst.map(square).filter(_ > 4).map(square)
-// lets define our own functions
-// type of functions, for example f: Int => Int
-lst.tail
-def my_map_int(lst: List[Int], f: Int => Int) : List[Int] = {
-if (lst == Nil) Nil
-else f(lst.head) :: my_map_int(lst.tail, f)
-}
-my_map_int(lst, square)
-// same function using pattern matching: a kind
-// of switch statement on steroids (see more later on)
-def my_map_int(lst: List[Int], f: Int => Int) : List[Int] = lst match {
-case Nil => Nil
-case x::xs => f(x)::my_map_int(xs, f)
-}
-// other function types
-//
-// f1: (Int, Int) => Int
-// f2: List[String] => Option[Int]
-// ...
-val lst = (1 to 10).toList
-def sumOf(f: Int => Int, lst: List[Int]): Int = lst match {
-case Nil => 0
-case x::xs => f(x) + sumOf(f, xs)
-}
-def sum_squares(lst: List[Int]) = sumOf(square, lst)
-def sum_cubes(lst: List[Int])   = sumOf(x => x * x * x, lst)
-sum_squares(lst)
-sum_cubes(lst)
-// lets try it factorial
-def fact(n: Int) : Int =
-if (n == 0) 1 else n * fact(n - 1)
-def sum_fact(lst: List[Int]) = sumOf(fact, lst)
-sum_fact(lst)
-// Map type (upper-case)
-//=======================
-// Note the difference between map and Map
-def factors(n: Int) : List[Int] =
-((1 until n).filter { divisor =>
-n % divisor == 0
-}).toList
-var ls = (1 to 10).toList
-val facs = ls.map(n => (n, factors(n)))
-facs.find(_._1 == 4)
-// works for lists of pairs
-facs.toMap
-facs.toMap.get(4)
-facs.toMap.getOrElse(42, Nil)
-val facsMap = facs.toMap
-val facsMap0 = facsMap + (0 -> List(1,2,3,4,5))
-facsMap0.get(1)
-val facsMap4 = facsMap + (1 -> List(1,2,3,4,5))
-facsMap.get(1)
-facsMap4.get(1)
-val ls = List("one", "two", "three", "four", "five")
-ls.groupBy(_.length)
-ls.groupBy(_.length).get(2)
-// Option type (again)
-//=====================
-// remember, in Java if something unusually happens,
-// you return null;
-//
-// 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(5,6,7,8,9).find(_ < 4)
 // operations on options
 val lst = List(None, Some(1), Some(2), None, Some(3))
 lst.flatten
 Some(1).isDefined
 None.isDefined
-None.isDefined
 val ps = List((3, 0), (3, 2), (4, 2), (2, 0), (1, 0), (1, 1))
+// division where possible
 for ((x, y) <- ps) yield {
 if (y == 0) None else Some(x / y)
 }
 val lst = List(None, Some(1), Some(2), None, Some(3))
 for (x <- lst) yield x.getOrElse(0)
-// error handling with Option (no exceptions)
-//
-//  Try(something).getOrElse(what_to_do_in_an_exception)
-//
-import scala.util._
-import io.Source
-Source.fromURL("""http://www.inf.ucl.ac.uk/staff/urbanc/""").mkString
-Try(Source.fromURL("""http://www.inf.kcl.ac.uk/staff/urbanc/""").mkString).getOrElse("")
-Try(Some(Source.fromURL("""http://www.inf.kcl.ac.uk/staff/urbanc/""").mkString)).getOrElse(None)
-// a function that turns strings into numbers (similar to .toInt)
-Integer.parseInt("12u34")
-def get_me_an_int(s: String) : Option[Int] =
-Try(Some(Integer.parseInt(s))).getOrElse(None)
-val lst = List("12345", "foo", "5432", "bar", "x21", "456")
-for (x <- lst) yield get_me_an_int(x)
-// summing up all the numbers
-lst.map(get_me_an_int).flatten.sum
-lst.map(get_me_an_int).flatten.sum
-lst.flatMap(get_me_an_int).map(_.toString)
 // This may not look any better than working with null in Java, but to
 // see the value, you have to put yourself in the shoes of the
 // consumer of the get_me_an_int function, and imagine you didn't
 // even Scala is not immune to problems like this:
 List(5,6,7,8,9).indexOf(7)
 List(5,6,7,8,9).indexOf(10)
 List(5,6,7,8,9)(-1)
+// Higher-Order Functions
+//========================
+// functions can take functions as arguments
+def even(x: Int) : Boolean = x % 2 == 0
+def odd(x: Int) : Boolean = x % 2 == 1
+val lst = (1 to 10).toList
+lst.filter(x => even(x))
+lst.filter(even(_))
+lst.filter(even)
+lst.count(even)
+lst.find(even)
+val ps = List((3, 0), (3, 2), (4, 2), (2, 2), (2, 0), (1, 1), (1, 0))
+lst.sortWith(_ > _)
+lst.sortWith(_ < _)
+def lex(x: (Int, Int), y: (Int, Int)) : Boolean =
+if (x._1 == y._1) x._2 < y._2 else x._1 < y._1
+ps.sortWith(lex)
+ps.sortBy(_._1)
+ps.sortBy(_._2)
+ps.maxBy(_._1)
+ps.maxBy(_._2)
+// maps (lower-case)
+//===================
+def double(x: Int): Int = x + x
+def square(x: Int): Int = x * x
+val lst = (1 to 10).toList
+lst.map(x => (double(x), square(x)))
+lst.map(square)
+// this is actually how for-comprehensions
+// defined as in Scala
+lst.map(n => square(n))
+for (n <- lst) yield square(n)
+// this can be iterated
+lst.map(square).filter(_ > 4)
+lst.map(square).filter(_ > 4).map(square)
+// lets define our own functions
+// type of functions, for example f: Int => Int
+lst.tail
+def my_map_int(lst: List[Int], f: Int => Int) : List[Int] = {
+if (lst == Nil) Nil
+else f(lst.head) :: my_map_int(lst.tail, f)
+}
+my_map_int(lst, square)
+// same function using pattern matching: a kind
+// of switch statement on steroids (see more later on)
+def my_map_int(lst: List[Int], f: Int => Int) : List[Int] = lst match {
+case Nil => Nil
+case x::xs => f(x)::my_map_int(xs, f)
+}
+// other function types
+//
+// f1: (Int, Int) => Int
+// f2: List[String] => Option[Int]
+// ...
+val lst = (1 to 10).toList
+def sumOf(f: Int => Int, lst: List[Int]): Int = lst match {
+case Nil => 0
+case x::xs => f(x) + sumOf(f, xs)
+}
+def sum_squares(lst: List[Int]) = sumOf(square, lst)
+def sum_cubes(lst: List[Int])   = sumOf(x => x * x * x, lst)
+sum_squares(lst)
+sum_cubes(lst)
+// lets try it factorial
+def fact(n: Int) : Int =
+if (n == 0) 1 else n * fact(n - 1)
+def sum_fact(lst: List[Int]) = sumOf(fact, lst)
+sum_fact(lst)
+// if you like verbosity, you can full-specify the literal.
+// Don't go telling that to people, though
+(1 to 100).filter((x: Int) => x % 2 == 0).sum
+// As x is known to be an Int anyway, you can omit that part
+(1 to 100).filter(x => x % 2 == 0).sum
+// As each parameter (only x in this case) is passed only once
+// you can use the wizardy placeholder syntax
+(1 to 100).filter(_ % 2 == 0).sum
+// But if you want to re-use your literal, you can also put it in a value
+// In this case, explicit types are required because there's nothing to infer from
+val isEven = (x: Int) => x % 2 == 0
+(1 to 100).filter(isEven).sum
+// Option Type again
+//===================
+// a function that turns strings into numbers (similar to .toInt)
+Integer.parseInt("12u34")
+def get_me_an_int(s: String) : Option[Int] =
+Try(Some(Integer.parseInt(s))).getOrElse(None)
+val lst = List("12345", "foo", "5432", "bar", "x21", "456")
+for (x <- lst) yield get_me_an_int(x)
+// summing up all the numbers
+lst.map(get_me_an_int).flatten.sum
+lst.map(get_me_an_int).flatten.sum
+lst.flatMap(get_me_an_int).sum
+// Map type (upper-case)
+//=======================
+// Note the difference between map and Map
+def factors(n: Int) : List[Int] =
+((1 until n).filter { divisor =>
+n % divisor == 0
+}).toList
+var ls = (1 to 10).toList
+val facs = ls.map(n => (n, factors(n)))
+facs.find(_._1 == 4)
+// works for lists of pairs
+facs.toMap
+facs.toMap.get(4)
+facs.toMap.getOrElse(42, Nil)
+val facsMap = facs.toMap
+val facsMap0 = facsMap + (0 -> List(1,2,3,4,5))
+facsMap0.get(1)
+val facsMap4 = facsMap + (1 -> List(1,2,3,4,5))
+facsMap.get(1)
+facsMap4.get(1)
+val ls = List("one", "two", "three", "four", "five")
+ls.groupBy(_.length)
+ls.groupBy(_.length).get(2)
 // Pattern Matching
 //==================
-// if you like verbosity, you can full-specify the literal.
-// Don't go telling that to people, though
-(1 to 100).filter((x: Int) => x % 2 == 0).sum
-// As x is known to be an Int anyway, you can omit that part
-(1 to 100).filter(x => x % 2 == 0).sum
-// As each parameter (only x in this case) is passed only once
-// you can use the wizardy placeholder syntax
-(1 to 100).filter(_ % 2 == 0).sum
-// But if you want to re-use your literal, you can also put it in a value
-// In this case, explicit types are required because there's nothing to infer from
-val isEven: (x: Int) => x % 2 == 0
-(1 to 100).filter(isEven).sum

changeset 317	607ceabeeffc
parent 316	8b57dd326a91
child 318	029e2862bb4e