- Concepts of Programming Languages

Option Type

Instructor:

Reporting Missing Data

def reduce[X](xs: List[X], f: (X,X)=>X) : X = xs match {
  case Nil => ???
  case head :: Nil  => head
  case head :: tail => f(head, reduce(tail))  
} ensuring {
  case result => ???
}

• case Nil => null: contract and clients have to distinguish between null and a result
• case Nil => throw IllegalArgumentException("Unable to reduce empty list"): how to write exception contract? how to not force clients distinguish result from exception?

Learning Objectives

How to represent missing results?

• Identify uses of option types

Option Type

• Principled approach to missing data
• Option[T] resembles List[T] with length 1
  • None represents absence of data
  • Some represents presence

• Example expressions of type Option[Int]: None, Some(5)

Absence of Data

def find[X](xs: List[X], p: X => Boolean): X = xs match
  case Nil        => null.asInstanceOf[X]
  case x :: rest  => if p(x) then x else find(rest, p)
end find

def find[X](xs: List[X], p: X => Boolean): Option[X] = xs match
  case Nil        => None
  case x :: rest  => if p(x) then Some(x) else find(rest, p)
end find

Absence of Data: Clients

• Find x>5, if found return "found x", else find x>3, if found return "found x", else print "not found"

val xs = List(1, 2, 3, 4, 5)

find(xs, _ > 5) match
  case null => find(xs, _ > 3) match
    case null => "not found"
    case n    => s"found $n"
  end match
  case n    => s"found $n"
end match

find(xs, _ > 5) orElse find(xs, _ > 3) match
  case None    => "not found"
  case Some(n) => s"found $n"
end match

Types of Emptiness

• Scala has many values that represent nothing, e.g.,
  • None: empty option
  • Nil: empty list
  • null: reference to nothing

• Unit is not an option type
  • Unit always has nothing
  • Unit nothing is ()

Nil vs. null

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

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

Nullable Types

• In Scala, we often pretend null does not exist

• Recent languages identify None and null: e.g. Swift, Kotlin
• These languages distinguish nullable and non-nullable types

Nullable Types

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 raise exception */
/* Safe call */
b?.length                        
/* Explicitly expanded safe call */
if (b != null) b.length else null
/* Safe call with default */
b?.length ?: -1             
/* Explicitly expanded */                  
val t = b?.length; if (t != null) t else -1

Nested Options

Safe division returns on zero: None (division undefined)

def safeDivide (n:Int,m:Int) : Option[Int] = 
  if m == 0 then None
  else Some (n/m)

def safeDivide (n:Int,m:Int) : Option[Int] = 
  Option.when(m!=0)(n/m) // Option.unless(m==0)(n/m)

• Divide an optional int safely

  val i: Option[Int] = Some(4)
  i.map(safeDivide(_,2))     // val res10: Option[Option[Int]] = Some(Some(2))
  

• Avoid nested options

  val i: Option[Int] = Some(4)
  i.flatMap(safeDivide(_,2))     // val res10: Option[Int] = Some(2)
  

Summary

• Option type represents presence/absence of data
• Either type represents alternative results
• Support higher-order functions map, etc.
• Enable expressing alternative computation attempts concisely (orElse, getOrElse)