pep-material: comparison progs/lecture1.scala

equal deleted inserted replaced

-:c2d36d8ee2a7
+:2e13dedd922e
 // Scala Lecture 1
 //=================
 // Value assignments
 // (their names should be lower case)
-//===================================
+//====================================
 val x = 42
 val y = 3 + 4
 val z = x / y
 // Hello World
 //=============
-// an example of a stand-alone scala file;
+// an example of a stand-alone Scala file
-// in the coursework students must submit
+// (in the assignments you must submit a plain Scala script)
-// plain scala "work-sheets"
 object Hello extends App {
 println("hello world")
 }
-// can be called with
+// can then be called with
 //
 // $> scalac hello-world.scala
 // $> scala Hello
 //
 // $> java -cp /usr/local/src/scala/lib/scala-library.jar:. Hello
 // Collections
 //=============
 // some alterative syntax for lists
 1 :: 2 :: 3 :: Nil
 List(1, 2, 3) ::: List(4, 5, 6)
+// Equality is structural
+//========================
+val a = "Dave"
+val b = "Dave"
+if (a == b) println("equal") else println("unequal")
+Set(1,2,3) == Set(3,1,2)
+List(1,2,3) == List(3,1,2)
+// this applies for "concrete" values;
+// you cannot compare functions
 // Printing/Strings
 //==================
 println("test")
 List(1,2,3,4).max
 List(1,2,3,4).min
 List(1,2,3,4).sum
 List(1,2,3,4).take(2).sum
 List(1,2,3,4).drop(2).sum
-List(1,2,3,4,3)indexOf(3)
+List(1,2,3,4,3).indexOf(3)
 "1,2,3,4,5".split(",").mkString("\n")
 "1,2,3,4,5".split(",3,").mkString("\n")
 // Types (slide)
 Set[Double]
 Pairs: (Int, String)
 List[(BigInt, String)]
 */
-// Smart Strings
-//===============
-println(">\n\n<")
-println(""">\n<""")
-println("""">\n<"""")
-/* in Java
-val lyrics = "Sun dips down, the day has gone. \n" +
-"Witches, wolves and giants yawn. \n" +
-"Queen and dragon, troll and gnome: \n" +
-"tired buddies head for home."
-*/
-val lyrics = """Sun dips down, the day has gone.
-|Witches, wolves and giants yawn.
-|Queen and dragon, troll and gnome:
-|tired buddies head for home.""".stripMargin
-println(lyrics)
 // Pairs/Tuples
 //==============
 def square(x: Int) : Int = x * x
 square(6)
 // The general scheme for a function: you have to give a type
 // to each argument and a return type of the function
 //
 //  def fname(arg1: ty1, arg2: ty2,..., argn: tyn): rty = {
 //    body
 // If-Conditionals
 //=================
 // Scala does not have a then-keyword
-// both if-else branches need to be presents
+// both if-else branches need to be present
 def fact(n: Int) : Int =
 if (n == 0) 1 else n * fact(n - 1)
 gcd(48, 18)
 def power(x: Int, n: Int) : Int =
-if (n == 0) 1  else x * power(x, n - 1)
+if (n == 0) 1 else x * power(x, n - 1)
 power(5, 5)
+// Option type
+//=============
+//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)
+// error handling with Options (no exceptions)
+//
+//  Try(something).getOrElse(what_to_do_in_case_of_an_exception)
+//
+import scala.util._
+import io.Source
+val my_url = "https://nms.kcl.ac.uk/christian.urban/"
+Source.fromURL(my_url).mkString
+Try(Source.fromURL(my_url).mkString).getOrElse("")
+Try(Some(Source.fromURL(my_url).mkString)).getOrElse(None)
+// the same for files
+Source.fromFile("test.txt").mkString
 // String Interpolations
 //=======================
 m <- (1 to 3).toList;
 if ((n + m) % 2 == 0)) yield (n, m)
 // with patterns
-for ((m, n) <- List((1, 4), (2, 3), (3, 2), (4, 1))) yield m + n
+val lst = List((1, 4), (2, 3), (3, 2), (4, 1))
-for (p <- List((1, 4), (2, 3), (3, 2), (4, 1))) yield p._1 + p._2
+for ((m, n) <- lst) yield m + n
+for (p <- lst) yield p._1 + p._2
 // general pattern
 for (x <- ...) yield {
 // has no "yield"
 for (n <- (1 to 10)) println(n)
+// BTW: a roundabout way of printing out a list, say
-// concurrency (ONLY WORKS IN SCALA 2.11.8, not in SCALA 2.12)
+val lst = ('a' to 'm').toList
-//             (would need to have this wrapped into a function, or
-//              REPL called with scala -Yrepl-class-based)
+for (i <- (0 until lst.length)) println(lst(i))
+// why not?
+for (c <- lst) println(c)
+// Aside: concurrency
+// (ONLY WORKS OUT-OF-THE-BOX IN SCALA 2.11.8, not in SCALA 2.12)
+// (would need to have this wrapped into a function, or
+//  REPL called with scala -Yrepl-class-based)
 for (n <- (1 to 10)) println(n)
 for (n <- (1 to 10).par) println(n)
 // for measuring time
 val list = (1 to 1000000).toList
 time_needed(10, for (n <- list) yield n + 42)
 time_needed(10, for (n <- list.par) yield n + 42)
-// mutable vs immutable factorial
+// Function producing multiple outputs
-def fact_mu(n: Long) : Long = {
+//=====================================
-var result : Long = 1
-var i = 1
+def get_ascii(c: Char) : (Char, Int) = (c, c.toInt)
-while (i <= n) {
-result = result * i
+get_ascii('a')
-i = i + 1
-}
-result
-}
+// .maxBy, sortBy with pairs
+def get_length(s: String) : (String, Int) = (s, s.length)
-def fact_im(num: Long): Long = {
-if (num == 1) num else
+val lst = List("zero", "one", "two", "three", "four", "ten")
-num * fact_im(num - 1)
+val strs = for (s <- lst) yield get_length(s)
-}
+strs.sortBy(_._2)
-def test() = {
+strs.sortBy(_._1)
-for (i <- (0 to 10).par) yield {
-val l1 = for (n <- (List.fill(100000)(20 to 21)).flatten.par) yield fact_mu(n)
+strs.maxBy(_._2)
-val l2 = for (n <- (List.fill(100000)(20 to 21)).flatten.par) yield fact_im(n)
+strs.maxBy(_._1)
-l1.sum - l2.sum
-}
-}
-(for (i <- (1 to 10)) yield test().sum).sum
-// Webpages
-//==========
-import io.Source
-// obtaining a webpage
-val url = """https://nms.kcl.ac.uk/christian.urban/"""
-Source.fromURL(url)("ISO-8859-1").mkString
-// another example
-//val url = """http://api.postcodes.io/postcodes/CR84LQ"""
-// a function for looking up constituency data
-def consty_lookup(pcode: String) : String = {
-val url = "http://api.postcodes.io/postcodes/" + pcode
-Source.fromURL(url).mkString.split(",")(16)
-}
-consty_lookup("CR84LQ")
-consty_lookup("WC2B4BG")
-val places =
-List("CR84LQ", "WC2B4BG", "KY169QT", "CB11LY", "CB39AX")
-for (s <- places) println(consty_lookup(s))
-// A Web Crawler
-//===============
-//
-// the idea is to look for dead links using the
-// regular expression "https?://[^"]*"
-import io.Source
-import scala.util._
-// gets the first 10K of a web-page
-def get_page(url: String) : String = {
-Try(Source.fromURL(url)("ISO-8859-1").take(10000).mkString).
-getOrElse { println(s"  Problem with: $url"); ""}
-}
-// regex for URLs
-val http_pattern = """"https?://[^"]*"""".r
-// drops the first and last character from a string
-def unquote(s: String) = s.drop(1).dropRight(1)
-def get_all_URLs(page: String): Set[String] =
-http_pattern.findAllIn(page).map(unquote).toSet
-// naive version of crawl - searches until a given depth,
-// visits pages potentially more than once
-def crawl(url: String, n: Int) : Unit = {
-if (n == 0) ()
-else {
-println(s"Visiting: $n $url")
-for (u <- get_all_URLs(get_page(url))) crawl(u, n - 1)
-}
-}
-// some starting URLs for the crawler
-val startURL = """https://nms.kcl.ac.uk/christian.urban/"""
-//val startURL = """https://nms.kcl.ac.uk/luc.moreau/index.html"""
-crawl(startURL, 2)
 // Further Information
 //=====================
 // The Scala home page and general information is at
-// advantage of case classes
-//
-case class Participant(name: String, score: Int, active: Boolean)
-val ps = Seq(Participant("Jack", 34, true),
-Participant("Tom", 51, true),
-Participant("Bob", 90, false))
-ps.filter(_.score < 50).
-filter(_.active).
-map(_.copy(active = false))
-// another example why state is bad...does not work yet
-// for measuring time
-def time_needed[T](n: Int, code: => T) = {
-val start = System.nanoTime()
-for (i <- (0 to n)) code
-val end = System.nanoTime()
-(end - start) / 1.0e9
-}
-def santa_state(plan: List[Char]) : Int = {
-var floor = 0
-for (i <- plan.par) {
-if (i == '(') {
-floor += 1
-} else {
-floor -= 1
-}
-}
-floor
-}
-def i(c: Char) = if (c == '(') 1 else -1
-def santa_imutable(plan: List[Char]) : Int =
-plan.par.map(i(_)).reduce(_ + _)
-santa_state("(((((()))))".toList)
-santa_imutable("(((((()))))".toList)
-def randomString(length: Int) : String =
-List.fill(length)((40 + scala.util.Random.nextInt(2)).toChar)
-santa_state(randomString(100))
-val large_string = randomString(3000000)
-time_needed(10, santa_state(large_string))
-time_needed(10, santa_imutable(large_string))
-//=======================
-// equality is structural
-val a = "Dave"
-val b = "Dave"
-if (a == b) println("equal") else println("unequal")
-List.fill(10)(math.random)
-//------------------------
-for (a <- 0 to 10) {
-println(a)
-}
-for (a <- 0 until 10) {
-println(a)
-}
-for (a <- 0 until 2; b <- 0 to 2) {
-}
-output
-a=0, b=0
-a=0, b=1
-a=0, b=2
-a=1, b=0
-a=1, b=1
-a=1, b=2

changeset 199	2e13dedd922e
parent 195	4bacbe753e66
child 200	29781ad780f0