pep-material: comparison progs/lecture1.scala

equal deleted inserted replaced

-:9e0216756771
+:e43f7e92ba26
 // Collections
 //=============
 List(1,2,3,1)
 Set(1,2,3,1)
+// ranges
 1 to 10
 (1 to 10).toList
 (1 until 10).toList
-// an element in a list
+// picking an element in a list
 val lst = List(1, 2, 3, 1)
 lst(0)
 lst(2)
 // some alterative syntax for lists
 1 :: 2 :: 3 :: Nil
 List(1, 2, 3) ::: List(4, 5, 6)
-// Equality is structural
+// Equality in Scala is structural
-//========================
+//=================================
 val a = "Dave"
 val b = "Dave"
 if (a == b) println("Equal") else println("Unequal")
 // Printing/Strings
 //==================
 println("test")
-val tst = "This is a " + "test\n"
+val tst = "This is a " ++ "test"
+print(tst)
 println(tst)
 val lst = List(1,2,3,1)
 println(lst.toString)
+println(lst.mkString)
 println(lst.mkString(","))
 println(lst.mkString(", "))
 // some methods take more than one argument
 println(lst.mkString("{", ",", "}"))
+// (in this case .mkString can take no, one,
+// or three arguments...this has to do with
+// default arguments)
 // Conversion methods
 //====================
 List(1,2,3,1).toString
 List(1,2,3,1).toSet
 "hello".toList.tail
 1.toDouble
 // useful list methods
 "1,2,3,4,5".split(",3,").mkString("\n")
 "abcdefg".startsWith("abc")
-// Types (slide)
+// Types (see slide)
-//===============
+//===================
 /* Scala is a strongly typed language
-* some base types
+* base types
 Int, Long, BigInt, Float, Double
 String, Char
-Boolean
+Boolean...
-* some compound types
+* compound types
-List[Int],
+List[Int]
 Set[Double]
 Pairs: (Int, String)
 List[(BigInt, String)]
 Option[Int]
+* user-defined types (later)
 */
+// you can make the type of a value explicit
 val name: String = "leo"
 // type errors
 math.sqrt("64")
 // error: type mismatch;
 // found   : String("64")
 // required: Double
 // math.sqrt("64")
 // Pairs/Tuples
 //==============
 val p = (1, "one")
 p._1
 def incr(x: Int) : Int = x + 1
 def double(x: Int) : Int = x + x
 def square(x: Int) : Int = x * x
 def str(x: Int) : String = x.toString
+incr(3)
+double(4)
 square(6)
+str(3)
 // The general scheme for a function: you have to give a type
 // to each argument and a return type of the function
 //
 def silly(n: Int) : Int = {
 if (n < 10) n * n
 else n + n
 }
+def another_silly(x: Int, y: String) : String = {
+if (x <= 12) y
+else x.toString
+}
+another_silly(2, "two")
+another_silly(12, "twelf")
+another_silly(20, "twenty")
 // If-Conditionals
 //=================
 // - Scala does not have a then-keyword
-// - both if-else branches need to be present
+// - !both if-else branches need to be present!
 def fact(n: Int) : Int =
 if (n == 0) 1 else n * fact(n - 1)
 // Option type
 //=============
-//in Java if something unusually happens, you return null
+//in Java if something unusually happens, you return null or something
 //
 //in Scala you use Options instead
 //   - if the value is present, you use Some(value)
 //   - if no value is present, you use None
 //  Try(something).getOrElse(what_to_do_in_case_of_an_exception)
 //
 import scala.util._
 import io.Source
-val my_url = "https://nms.imperial.ac.uk/christian.urban/"
+val my_url = "https://nms.kcl.ac.uk/christian.urban/"
 Source.fromURL(my_url).mkString
 Try(Source.fromURL(my_url).mkString).getOrElse("")
 // much better - you record in the type that things can go wrong
 def get_contents(name: String) : Option[List[String]] =
 Try(Some(Source.fromFile(name).getLines.toList)).getOrElse(None)
 get_contents("text.txt")
+get_contents("test.txt")
 // String Interpolations
 //=======================
 for (n <- (1 to 10).toList;
 m <- (1 to 10).toList) yield m * n
+// you can assign the result of a for-comprehension
+// to a value
 val mult_table =
 for (n <- (1 to 10).toList;
 m <- (1 to 10).toList) yield m * n
 println(mult_table.mkString)
 // Why not just? Why making your life so complicated?
 for (c <- lst) println(c)
 // Aside: concurrency
-// (ONLY WORKS OUT-OF-THE-BOX IN SCALA 2.11.8, not in SCALA 2.12)
+// (scala <<..parallel_collections...>> -Yrepl-class-based)
-// (would need to have this wrapped into a function, or
-//  REPL called with scala -Yrepl-class-based)
 for (n <- (1 to 10)) println(n)
+import scala.collection.parallel.CollectionConverters._
 for (n <- (1 to 10).par) println(n)
 // for measuring time
 def time_needed[T](n: Int, code: => T) = {
 // - no vars, no ++i, no +=
 // - no mutable data-structures (no Arrays, no ListBuffers)
 // Q: Count how many elements are in the intersections of two sets?
+// A; IMPROPER WAY (mutable counter)
 def count_intersection(A: Set[Int], B: Set[Int]) : Int = {
 var count = 0
 for (x <- A; if (B contains x)) count += 1
 count

changeset 268	e43f7e92ba26
parent 265	59779ce322a6
child 272	da3d30ae67ec