pep-material: comparison progs/lecture1.scala

equal deleted inserted replaced

-:e0ee3aa6334b
+:7653dd662db3
 // Scala Lecture 1
 //=================
+print("Hello")
 // Topics
 //--------
 // - List, Sets, Ints, Strings, ...
 // - Value assignments (val vs var)
 List(1, 2, 3) ::: List(3, 6, 5)
 Set(1, 2, 3) ++ Set(3, 6, 5)
 // ranges
 1 to 10
-(1 to 10).toList
+(1 to 100).toString
 (1 to 10).toList.toString
 // Equality in Scala is structural
 val name = "bob"
 val name : Int = "bob"
 // type errors
-math.sqrt("64")
+math.sqrt(64)
 // produces
 //
 // Type Mismatch Error:
 //   Found   : ("64" : String)
 //
 //  def fname(arg1: ty1, arg2: ty2,..., argn: tyn): rty = {
 //     ....
 //  }
+def incr(x: Int) : Int = x + 1
+incr(42)
+def add(x: Int, y: Int) : Int = x + y
 def average(ls: List[Int]) : Int = {
-println(s"$ls")
 val s = ls.sum
 val l = ls.length
-if (l == 0) 0
+s / l
-else s / l
+}
-}
+average(List(1,2,3,4))
-average(List(1,2,3,4,56))
-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
 // For-Comprehensions (not For-Loops)
 //====================================
-val lst = (1 to 10).toSet
+val lst = (1 to 10).toList
-val result = for (n <- lst) yield {
+for (n <- lst) yield {
 n * n
 }
 println(result)
+def square(n: Int) = n * n
+def double(n: Int) = n + n
 for (n <- lst) yield {
 square(n) + double(n)
 }
-for (n <- (1 to 10).toList;
+val foo = for (n <- (1 to 10).toList;
-m <- (1 to 5).toList) yield (n, m)
+m <- (1 to 5).toList;
+if (n + m) % 2 == 0) yield (n, m)
+foo.head
 // you can assign the result of a for-comprehension
 // to a value
 val mult_table =
 for (n <- (1 to 10).toList;
 // general pattern of for-yield
 // (yield can be several lines)
+/*
 for (pat <- ...) yield {
 // potentially complicated
 // calculation of a result
 }
+*/
 // For without yield
 //===================
 // with only a side-effect (no list is produced),
 // has no "yield"
+for (n <- (1 to 10).toList) yield println(n * n)
 val xs = for (n <- (1 to 10).toList) println(n * n)
 xs.tail  // error
 // - no mutable data-structures (no Arrays, no ListBuffers)
 // But what the heck....lets try to count to 1 Mio in parallel
 //
 // requires
-// scala --extra-jars scala- parallel-collections_3-1.0.4.jar
+// scala --extra-jars scala-parallel-collections_3-1.2.0.jar
 import scala.collection.parallel.CollectionConverters._
+for (n <- (1 to 10).par) println(n)
 def test() = {
 var cnt = 0
 for(i <- (1 to 100_000).par) cnt += 1
 gcd_db(48, 18)
 // you can also implement your own string interpolations
 extension (sc: StringContext) {
-def i(args: Any*): String = s"\t${sc.s(args:_*)}\n"
+def i(args: Any*): String = s"\t${sc.s(args*)}\n"
-def l(args: Any*): String = s"${sc.s(args:_*)}:\n"
+def l(args: Any*): String = s"${sc.s(args*)}:\n"
 }
 // this allows you to write things like
 i"add ${3+2}"

changeset 504	7653dd662db3
parent 497	ef37fb04a343