Programming with exceptions

def getDirs1 (dirName : String) : List[java.io.File] = 
  val dir = new java.io.File (dirName)
  val xs = dir.listFiles
  if xs == null 
  then throw new java.io.FileNotFoundException
  else xs.toList.filter (_.isDirectory)

Programming with optionals

def getDirs2 (dirName : String) : Option[List[java.io.File]] = 
  val dir = new java.io.File (dirName)
  val xs = dir.listFiles
  if xs == null 
  then None 
  else Some(xs.toList.filter (_.isDirectory))

With exception handling

def printNumTemp1 () =   
  var result : List[java.io.File] = Nil
  var found = false
  for s <- List("/temp", "/tmp"); if !found do 
    try 
      result = getDirs1(s)
      found = true
    catch
      case e: java.io.FileNotFoundException => ()
  found match 
    case false => println("No Temporary Directory.")
    case true  => println(result.length)

With option pattern matching

def printNumTemp2 () = 
  getDirs2("/temp") orElse getDirs2("/tmp") match 
    case None => println("No Temporary Directory.")
    case Some(result) => println(result.length)

• Map, fold, filter all work on Option

Scala

def sum (xs : List[Int]) : Int = xs match 
  case Nil => 0
  case y::ys => y + sum(ys)

• Nil: empty list
• null: empty reference

Java

int sum (Node<Integer> xs)
  if (xs == null) return 0;
  else return xs.item + sum(xs.next);

• null used to represent emptiness

Kotlin nullable versus non-nullable types

• T? in Kotlin resembles Option[T] in Scala
• null is used for None
• Types without ? do not allow null

var a: String = "abc"
a = null /* compilation error */
a.length /* always safe */

var b: String? = "abc"
b = null /* ok */
b.length /* compiler error */

b!!.length /* may give Null Pointer Exception */

b?.length                         /* Safe call */
if (b != null) b.length else null /* expanded */

b?.length ?: -1                               /* Elvis operator */
val t = b?.length; if (t != null) t else -1   /* expanded */