pep-material: comparison progs/lecture1.scala

equal deleted inserted replaced

-:86a456f8cb92
+:135bf034ac30
 // - List, Sets, Strings, ...
 // - Value assignments (val vs var)
 // - How to define functions? (What is returned?)
 // - If-Conditions
-val tmp = 0
-val result = !(tmp == 0)
-val result = if (tmp == 0) true else false
-//        expressions (if (tmp == 0) true else false)
 // - For-Comprehensions (guards, with/without yield)
-//
-//
-// - Options
-// - Higher-Order Functions (short-hand notation)
-// - maps (behind for-comprehensions)
-// - Pattern-Matching
 // - String-Interpolations
+//
+//
 // Value assignments
 // (their names should be lower case)
 //====================================
 val x = 42
 val y = 3 + 4
 val z = x / y
 val x = 70
-print(z)
+println(z)
 // (you cannot reassign values: z = 9 will give an error)
 //var z = 9
 //z = 10
 // Hello World
 //=============
 // an example of a stand-alone Scala file
 (1 until 10).toList
 // Equality in Scala is structural
 //=================================
-val a = "Dave2"
+val a = "Dave"
 val b = "Dave"
 if (a == b) println("Equal") else println("Unequal")
 Set(1,2,3) == Set(3,1,2)
 1   // an Int
 1L  // a Long
 1F  // a Float
 1D  // a Double
-// useful list methods on lists
+// useful methods for lists
-//==============================
+//=========================
 List(1,2,3,4).length
 List(1,2,3,4).reverse
 List(1,2,3,4).max
 List(1,2,3,4).min
 val name = "bob"
 val name : String = "bob"
 // type errors
-math.sqrt("64".toDouble)
+math.sqrt("64")
 // produces
 //
-// error: type mismatch;
+// Type Mismatch Error:
-// found   : String("64")
+//   Found   : ("64" : String)
-// required: Double
+//   Required: Double
-// math.sqrt("64")
+//
 // Pairs/Tuples
 //==============
 // 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 = {
-//
+//     ....
 //  }
 // If-Conditionals
 //=================
-// - Scala does not have a then-keyword
+// - Scala used to not have a then-keyword
 // - !!both if-else branches need to be present!!
 def fact(n: Int) : Int =
 if (n == 0) 1 else n * fact(n - 1)
+// Scala 3 introduced if-then-else - maybe people
+// desperately needed it
+def fact(n: Int) : Int =
+if n == 0 then 1 else n * fact(n - 1)
 fact(5)
 fact(150)
 /* boolean operators
 !      not
 && ||  and, or
 */
 def fib(n: Int) : Int = {
 if (n == 0) 1 else
 if (n == 1) 1 else fib(n - 1) + fib(n - 2)
 }
 fib(9)
 //gcd - Euclid's algorithm
 def gcd(a: Int, b: Int) : Int = {
 if (b == 0) a
 else  gcd(b, a % b)
 def average(xs: List[Int]) : Int = {
 if (xs.length == 0) 0
 else xs.sum / xs.length
 }
+average(List(3,4,5))
 average(List())
+average(Nil)
 // For-Comprehensions (not For-Loops)
 //====================================
 for (n <- (1 to 10).toList) println(n * n)
 for (n <- (1 to 10).toList) yield n * n
 // BTW: a roundabout way of printing out a list, say
 val lst = ('a' to 'm').toList
 for (i <- (0 until lst.length)) println(lst(i))
-// Why not just? Why making your life so complicated?
+// ...why not just the following? Why making your life
+// so complicated?
 for (c <- lst) println(c)
 // Functions producing multiple outputs
 // Aside: concurrency
-// scala -Yrepl-class-based -cp scala-parallel-collections_2.13-0.2.0.jar
+// scala-cli --extra-jars scala-parallel-collections_3-1.0.4.jar
 for (n <- (1 to 10)) println(n)
 import scala.collection.parallel.CollectionConverters._
 for (i <- (0 to n)) code
 val end = System.nanoTime()
 (end - start) / 1.0e9
 }
-val list = (1 to 1000000).toList
+val list = (1L to 10_000_000L).toList
 time_needed(10, for (n <- list) yield n + 42)
 time_needed(10, for (n <- list.par) yield n + 42)
 // ...but par does not make everything faster
 // But what the heck....lets try to count to 1 Mio in parallel
 import scala.collection.parallel.CollectionConverters._
 var cnt = 0
-for(i <- (1 to 1000000).par) cnt += 1
+for(i <- (1 to 100_000).par) cnt += 1
-println(s"Should be 1 Mio: $cnt")
+println(s"Should be 100000: $cnt")
 // Or
 // 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.par; if (B contains x)) count += 1
+for (x <- A.par; if B contains x) count += 1
 count
 }
 val A = (0 to 999).toSet
 val B = (0 to 999 by 4).toSet
 A.par.count(x => B contains x)
 count_intersection2(A, B)
-//another bad example
-def test() = {
+// String Interpolations
-var cnt = 0
+//=======================
-for(i <- (1 to 1000000).par) cnt += 1
-println(cnt)
+def cube(n: Int) : Int = n * n * n
-}
+val n = 3
-test()
+println("The cube of " + n + " is " + cube(n) + ".")
+println(s"The cube of $n is ${cube(n)}.")
-// Regular Expressions (the built in ones)
+// or even
-val s = """Any so-called "politician" should respect a vote."""
+println(s"The cube of $n is ${n * n * n}.")
-print(s)
+// helpful for debugging purposes
-print("""foo""")
+//
+//     "The most effective debugging tool is still careful
-val reg = """\d+""".r
+//          thought, coupled with judiciously placed print
+//                                             statements."
-reg.findAllIn("bbbbaaabbbaaaccc").toList
+//       — Brian W. Kernighan, in Unix for Beginners (1979)
-reg.replaceAllIn("bbbbaaabbbaaaccc", "*")
-reg.replaceAllIn("bbbb0aaa1bbba2aac3cc", "_")
-reg.replaceAllIn("bbbb00aaa11bbba232aac33cc", "_")
+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)
+// you can also implement your own string interpolations
+extension (sc: StringContext) {
+def i(args: Any*): String = s"\t${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}"
+l"some_fresh_name"
 // Further Information
 //=====================
+// We are going to use Scala 3 and the scala-cli repl (easier to use)
+//
+//  https://scala-cli.virtuslab.org
+//
+//
 // The Scala homepage and general information is at
 //
 //  http://www.scala-lang.org
 //	http://docs.scala-lang.org
 //
 //
-// It should be fairly easy to install the Scala binary and
+// It should be fairly easy to install the scala-cli binary and
 // run Scala on the commandline. People also use Scala with
-// Vim and Jedit. I currently settled on VS Code
+// Vim and Jedit. I currently settled on Codium
 //
 //   https://code.visualstudio.com
 //
 // There are also plugins for Eclipse and IntelliJ - YMMV.
 // Finally there are online editors specifically designed for
 //
 //
 // Scala Library Docs
 //====================
 //
-//  http://www.scala-lang.org/api/current/
+//  https://dotty.epfl.ch/api/index.html
 //
 // Scala Tutorials
 //
 //  http://docs.scala-lang.org/tutorials/
 //
 // There are also a massive number of Scala tutorials on youtube
 // and there are tons of books and free material. Google is your
-// friend.
+// friend. Just make sure you follow newer material about Scala 3.

changeset 471	135bf034ac30
parent 447	f51e593903ac
child 481	e03a0100ec46