1. Exceptions and other things
Scala Miscellany
Exceptions and other things

2. 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

3. 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 parameter is used once res11: List[Int] = List(2, 3)

4. 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

5. 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!!!") }

6. The Either type
scala> def f(i: Int) = | if (i == 0) { | Left("Divide by zero") | } else { | Right(24 / i) | } scala> for (i <- -3 to 3) { | f(i) match { | case Left(x) => println(s"Left with $x") | case Right(x) => println(s"Right with half of ${2 * x}") | } | } Right with half of -16 Right with half of -24 Right with half of -48 Left with Divide by zero Right with half of 48 Right with half of 24 Right with half of 16

7. 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
takeCis554course assert(languagesIKnow contains "Scala")
assert is often used as “executable documentation”

8. The ensuring method
The ensuring method applies a predicate to a value and, if the predicate result is true, returns the value, otherwise throws an AssertionError
Syntax: value ensuring(predicate)
scala> 12 ensuring(true) res1: Int = 12
scala> 12 ensuring(_ > 10) res2: Int = 12
scala> def twice(x: Int) = 2 * x ensuring(_ > 0) twice: (x: Int)Int
scala> twice(3) res3: Int = 6
scala> twice(-5) java.lang.AssertionError: assertion failed (+ many lines)
ensuring can be useful to guarantee the result of a method
Always use _ in the predicate to represent the method’s return value

9. 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 => case ex: Exception => println("What went wrong?") }

10. File I/O Use correct case for file names (only Windows ignores case)
object TestIO { def main(args: Array[String]) { println("Testing file I/O") import java.io._ import scala.io.Source val file = new File("testio.txt") val writer = new PrintWriter(file) writer write "first\r\n" writer write "second" writer.close() val lines = Source.fromFile(file).getLines().toList println(lines) } }
Testing file I/O List(first, second)
Use correct case for file names (only Windows ignores case)
Use forward slashes, /, in paths, which work on any platform, not backslashes, \, which work only on Windows
Windows, Mac, and Linux have different end-of-line codes (\r\n is Windows), and this causes problems

11. 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

12. The End