Getting Started with Scala

Dec 9, 2021
 Hello World
 /** Everybody’s first program */
object HelloWorld {
def main(args: Array[String]) {
println("Hello, World!")
}
}
 Save on a file named HelloWorld.scala
 Compile with scalac HelloWorld.scala (or from your IDE)
 Run with scala HelloWorld (or from your IDE)
 Generate documentation with scaladoc HelloWorld.scala
 The above code creates a single object
 Everything in the object is like Java’s static
 Scala doesn’t have static
 Scala does have classes; we’ll get to those later

2
 Comments
 // and /*...*/ comments are as in Java

 /** Scaladoc comments are similar to Javadoc

* comments. As in Javadoc, the first sentence
* is a summary sentence, and additional
* sentences give more detail. However, the
* formatting convention is slightly different,
* and wiki markup is used in preference to
* HTML markup. Most of the same flags
* (@author, etc.) are used. */
def doNothing = ()
 Types
 The type hierarchy is a lattice, not a tree
 That is, it has a “bottom” as well as a “top”
 Any
 AnyVal
 Boolean, Char, Byte, Short, Int, Long, Float, Double
 Scala has no primitives—these are objects

 Unit (has only a single value, ()

 Unit is returned by functions that “don't return anything” (e.g. println)

 AnyRef (corresponds to Object in Java)

 All Java reference types, for example, String
 ScalaObject
 All Scala reference types, including Array and List

 Null (bottom of all AnyRef objects)

 Nothing (bottom of Any)
4
 Declaring variables and values
 The syntax is
var name: type = value // declares a variable
val name: type = value // declares a value
 Values are immutable: they can’t be changed
 The : type can almost always be left off—the type is inferred from the value
 The = value must (almost) always be supplied
 This also works: var x: Double = 5

 Rules for alphanumeric names are just like in Java

 But there are other kinds of names 
 Scope rules are just like in Java
 Capitalization conventions are just like in Java
 Arithmetic, comparison, and logical operators are just like in Java
 Indentation is 2 spaces, not 4, but is otherwise the same as in Java

5
 “Statements”
 Scala’s “statements” should really be called “expressions,” because almost
every statement has a value
 For example, the value of a = 5 is 5
 The value of many statements, for example the while loop, is ()
 () is a value of type Unit
 () is the only value of type Unit
 () basically means “Nothing to see here. Move along.”
 The value of a block, {…}, is the last value computed in the block

 A statement is ended by the end of the line (not with a semicolon) unless it is
obviously incomplete
 For example, x = 3 * (2 * y + is obviously incomplete
 Because Scala lets you leave out a lot of unnecessary punctuation, sometimes a
line that you think is complete really isn’t complete (or vice versa)
 You can end statements with semicolons, but that’s not good Scala practice

6
 Familiar statement types
 These are the same as in Java (but have a value):
 variable = expression // also +=, *=, etc.
 The value of the statement is the value of the variable
 while (condition) { statements }
 The value of the statement is ()
 do { statements } while (condition)
 The value is ()
 if (condition) { statements }
 The value is the value of the last statement executed
 if (condition) { statements } else { statements }
 Older descriptions of Scala say that the else is required. It isn’t--if
omitted and the condition is false, the value of the if statement is ()

7
 The for comprehension
 Scala’s for is much more powerful than Java’s for
 Consequently, it is used much more often than the other kinds of loops
 We will just cover some simple cases here
 for (i <- 1 to 10) { println(i) }
 Prints the numbers 1 through 10
 for (i <- 1 until 10) { println(i) }
 Prints the numbers 1 through 9
 for (x <- 0 until myArray.length) { println(myArray(x)) }
 Prints all the values in myArray
 for (x <- myArray) { println(x) }
 Prints all the values in myArray
 for (x <- myArray
if x % 2 == 0) { println(x) }
 Prints all the even numbers in myArray
 Arrays
 Arrays in Scala are parameterized types
 Array[String] is an Array of Strings, where String is a type parameter
 In Java we would call this a “generic type”
 When no initial values are given, new is required, along with an
explicit type:
 val ary = new Array[Int](5)
 When initial values are given, new is not allowed:
 val ary2 = Array(3, 1, 4, 1, 6)
 Arrays in Scala are just another kind of object; they have no
special syntax

 Scala’s Lists are more useful, and used more often, than Arrays
 val list1 = List(3, 1, 4, 1, 6)
 val list2 = List[Int]() // An empty list must have an explicit type
 Simple List operations
 By default, Lists, like Strings, are immutable
 Operations on an immutable List return a new List
 Basic operations:
 list.head (or list head) returns the first element in the list
 list.tail (or list tail) returns a list with the first element removed
 list(i) returns the ith element (starting from 0) of the list
 list(i) = value is illegal (immutable, remember?)
 value :: list returns a list with value appended to the front
 list1 ::: list2 appends (“concatenates”) the two lists
 list.contains(value) (or list contains value) tests whether value is in list
 An operation on a List may return a List of a different type
 scala> "abc" :: List(1, 2, 3)
res22: List[Any] = List(abc, 1, 2, 3)
 There are over 150 built-in operations on Lists--use the API!
 Tuples
 Scala has tuples, up to size 22 (why 22? I have no idea.)
 scala> val t = Tuple3(3, "abc", 5.5)
t: (Int, java.lang.String, Double) = (3,abc,5.5)
 scala> val tt = (3, "abc", 5.5)
tt: (Int, java.lang.String, Double) = (3,abc,5.5)
 Tuples are referenced starting from 1, using _1, _2, ...
 scala> t._1
res28: Int = 3
 t _1 also works (the dot is optional)
 Tuples, like Lists, are immutable
 Tuples are a great way to return more than one value
from a method!
 An aside...abbreviations
 Scala lets you omit a lot of “unnecessary” punctuation
 For example,
if (name startsWith "Dr.") { ... }
is more readable (and easier to type) than
if (name.startsWith("Dr.")) { ... }
 Readability matters!
 Therefore, you should experiment with leaving out
punctuation anywhere you think it might be okay
 However,
 If you get mysterious syntax errors, try putting the
punctuation back in, both on this line and on the previous line
 Maps
 scala> val m = Map("apple" -> "red", "banana" -> "yellow")
m: scala.collection.immutable.Map[java.lang.String,java.lang.String]
= Map((apple,red), (banana,yellow))
 Notice that a Map is really just a list of Tuples
 The -> is provided as a more readable syntax

 scala> m("banana")
res2: java.lang.String = yellow

 scala> m contains "apple"

res3: Boolean = true

 scala> m("cherry")
java.util.NoSuchElementException: key not found: cherry
 Simple function definitions
 def isEven(n: Int) = {
val m = n % 2
m == 0
}
 The result is the last value (in this case, a Boolean)
 def isEven(n: Int) = n % 2 == 0
 The result is just a single expression, so no braces are needed
 def countTo(n: Int) {
for (i <- 1 to 10) { println(i) }
}
 It’s good style to omit the = when the result is ()
 If you omit the =, the result will be ()
 def half(n: Int): Double = n / 2
 You can state the result type explicitly
 In this example, half(7) will return 3.5 (!)
 def half(n: Int): Int = return n / 2
 If you use a return statement, you must state the result type explicitly
 Functions are first-class objects
 Functions are values (like integers, etc.) and can be assigned to
variables, passed to and returned from functions, and so on
 Wherever you see the => symbol, it’s a literal function
 Example (assigning a literal function to the variable foo):
 scala> val foo = (x: Int) => if (x % 2 == 0) x / 2 else 3 * x + 1
foo: (Int) => Int = <function1>

scala> foo(7)
res28: Int = 22
 The basic syntax of a function literal is
parameter_list => function_body
 In this example, foreach is a function that takes a function as a
parameter:
 myList.foreach(i => println(2 * i))
 Functions as parameters
 To define a function, you must specify the types of each of its parameters
 Therefore, to have a function parameter, you must know how to write its type:
 (type1, type2, ..., typeN) => return_type
 type => return_type // if only one parameter
 Example:
 scala> def doTwice(f: Int => Int, n: Int) = f(f(n))
doTwice: (f: (Int) => Int,n: Int)Int

scala> def collatz(n: Int) = if (n % 2 == 0) n / 2 else 3 * n + 1

collatz: (n: Int)Int

scala> doTwice(collatz, 7)
res2: Int = 11

scala> doTwice(a => 101 * a, 3)

res4: Int = 30603
 Higher-order methods on Lists
 map applies a one-parameter function to every element of a List, returning a
new List
 scala> def double(n: Int) = 2 * n
double: (n: Int)Int
 scala> val ll = List(2, 3, 5, 7, 11)
ll: List[Int] = List(2, 3, 5, 7, 11)
 scala> ll map double
res5: List[Int] = List(4, 6, 10, 14, 22)
 scala> ll map (n => 3 * n)
res6: List[Int] = List(6, 9, 15, 21, 33)
 scala> ll map (n => n > 5)
res8: List[Boolean] = List(false, false, false, true, true)
 filter applies a one-parameter test to every element of a List, returning a List of
those elements that pass the test
 scala> ll filter(n => n < 5)
res10: List[Int] = List(2, 3)
 scala> ll filter (_ < 5) // abbreviated function where one parameter is used once
res11: List[Int] = List(2, 3)
 More higher-order methods
 def filterNot(p: (A) => Boolean): List[A]
 Selects all elements of this list which do not satisfy a predicate

 def count(p: (A) => Boolean): Int

 Counts the number of elements in the list which satisfy a predicate

 def forall(p: (A) => Boolean): Boolean

 Tests whether a predicate holds for every element of this list

 def exists(p: (A) => Boolean): Boolean

 Tests whether a predicate holds for at least one of the elements of this list

 def find(p: (A) => Boolean): Option[A]

 Finds the first element of the list satisfying a predicate, if any

 def sortWith(lt: (A, A) => Boolean): List[A]

 Sorts this list according to a comparison function
 Pattern matching
 Pattern matching on literal values:
 today match {
case "Saturday" => println("Party! Party! Party!")
case "Sunday" => println("Pray....")
case day => println(day + " is a workday. :( ")
}
 Pattern matching on types:
 something match {
case x: Int => println("I'm the integer " + x)
case x: String =>
println("I'm the String \"" + x + "\"")
println("My length is " + x.length)
case _ => println("I don't know what I am! :( ")
}
 The Option type
 Scala has null because it interoperates with Java; it
shouldn’t be used any other time
 Instead, use an Option type, with values Some(value)
and None
 def max(list: List[Int]) = {
if (list.length > 0) {
val biggest = (list(0) /: list) { (a, b) => if (a > b) a else b }
Some(biggest)
} else {
None
}
 max(myList) match {
case Some(x) => println("The largest number is " + x)
case None => println("There are no numbers here!!!")
}
 The require and assert methods
 require and assert are methods that throw an exception when
their argument is false

 require is used to document something that must be true in order

for the code to work
 def sqrt(x: Double) = { require(x >= 0); ... }
 require is often used at the beginning of a method

 assert is used to document something that you “know” to be true

 takeCis700course
assert(languagesIKnow contains "Scala")
 assert is often used at the end of a block of code, to say what that code
has accomplished
 Dealing with exceptions
 Scala’s exception creation and throwing is like Java:
 class RottenEggException extends Exception
 throw new RottenEggException

 Catching a thrown exception uses pattern matching:

 try {
makeAnOmlet
} catch {
case ex: RottenEggException => println("#$%&#@")
case ex: Exception => println("What went wrong?")
}
 File I/O
 object TestIO {
def main(args: Array[String]) {  Use correct case for file names
println("Testing file I/O") (only Windows ignores case)
 Use forward slashes, /, in paths,
import java.io._
which work on any platform, not
import scala.io.Source
val file = new File("testio.txt") backslashes, \, which work only on
Windows
val writer = new PrintWriter(file)  Windows, Mac, and Linux have
writer write "first\r\n" different “end-of-line codes (\r\n
writer write "second" is Windows), and this causes
writer.close() problems
val lines = Source.fromFile(file).getLines().toList
println(lines)
}
}
 Testing file I/O
List(first, second)
 Use the source, Luke
 Books and tutorials are good for learning the syntax of Scala, but they aren’t much help
learning the API
 Unfortunately, Scala’s API documentation isn’t very complete
 The good news is, it’s easy to get to the source code--and in most cases, the source
code is easier to read than you might think
The End

25