pep-material: comparison progs/lecture1.scala

equal deleted inserted replaced

-:85aa2203cd42
+:6624122bdf74
 // Value assignments
 // (their names should be lower case)
 //====================================
+//var z = 9
+//z = 10
 val x = 42
 val y = 3 + 4
 val z = x / y
+val x = 70
 // (you cannot reassign values: z = 9 will give an error)
 // Hello World
 Set(1,2,3,1)
 // ranges
 1 to 10
 (1 to 10).toList
+(1 to 10).toList.toString
 (1 until 10).toList
 // picking an element in a list
 val lst = List(1, 2, 3, 1)
 Set(1,2,3) == Set(3,1,2)
 List(1,2,3) == List(3,1,2)
-// this applies to "concrete" values...pretty much everything;
+// this applies to "concrete" values...pretty much
-// but for example you cannot compare functions (later),
+// everything; but for example you cannot compare
-// and also not Arrays
+// functions (later), and also not arrays
 Array(1) == Array(1)
 // Printing/Strings
 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)
 // you can make the type of a value explicit
 val name: String = "leo"
 // type errors
-math.sqrt("64")
+math.sqrt("64".toDouble)
 // produces
 //
 // error: type mismatch;
 // found   : String("64")
 // Function Definitions
 //======================
+def foo(s: String) : String = {
+val tmp = s ++ s ++ s
+val res = s ++ s
+res
+}
+foo("test")
 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
 double(4)
 square(6)
 str(3)
-// The general scheme for a function: you have to give a type
+// The general scheme for a function: you have to give a
-// to each argument and a return type of the function
+// type to each argument and a return type of the function
 //
 //  def fname(arg1: ty1, arg2: ty2,..., argn: tyn): rty = {
-//    body
+//
 //  }
-//
 // BTW: no returns!!
 // "last" line (expression) in a function determines the
 // result
 def fact2(n: BigInt) : BigInt =
 if (n == 0) 1 else n * fact2(n - 1)
 fact2(150)
 def fib(n: Int) : Int =
 if (n == 0) 1 else
 if (n == 1) 1 else fib(n - 1) + fib(n - 2)
 // For-Comprehensions (not For-Loops)
 //====================================
+(1 to 10).toList
 for (n <- (1 to 10).toList) yield {
 square(n) + 1
 }
 for (n <- (1 to 10).toList;
-m <- (1 to 10).toList) yield m * n
+m <- (1 to 10).toList) yield (m, n)
 // you can assign the result of a for-comprehension
 // to a value
 val mult_table =
 println(mult_table.mkString)
 mult_table.sliding(10,10).mkString("\n")
 // the list/set/... can also be constructed in any
 // other way
 for (n <- Set(10,12,4,5,7,8,10)) yield n * n
+for (n <- (1 to 10)) yield {
+n * n
+}
+if (1 == 2) "a" else "b"
 // with if-predicates / filters
 for (n <- (1 to 3).toList;
 m <- (1 to 3).toList;
-if (n + m) % 2 == 0;
+if (n + m) % 2 == 0) yield (n, m)
-if (n * m) < 2) yield (n, m)
 for (n <- (1 to 3).toList;
 m <- (1 to 3).toList;
 if ((((n + m) % 2 == 0)))) yield (n, m)
 }
 // Functions producing multiple outputs
 //======================================
-def get_ascii(c: Char) : (Char, Int) = (c, c.toInt)
+def get_ascii(c: Char) : (Char, Int) =
+(c, c.toInt)
 get_ascii('a')
 // .maxBy, sortBy with pairs
-def get_length(s: String) : (String, Int) = (s, s.length)
+def get_length(s: String) : (String, Int) =
+(s, s.length)
 val lst = List("zero", "one", "two", "three", "four", "ten")
 val strs = for (s <- lst) yield get_length(s)
 strs.sortBy(_._2)
 // with only a side-effect (no list is produced),
 // has no "yield"
 for (n <- (1 to 10)) println(n)
+(1 to 10).toList
+(1 until 10).toList
 // 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))

changeset 314	6624122bdf74
parent 313	85aa2203cd42
child 316	03d55eb6a0b7