Programming with null

def getDirs1 (dirName : String) : List[java.io.File] = 
  val dir = new java.io.File (dirName)
  val xs = dir.listFiles
  if xs == null 
    then null
    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))
  

Client handling null

def printNumTemp1 () =   
  var result : List[java.io.File] = Nil
  var found = false
  for s <- List("/temp", "/tmp"); if !found do 
    result = getDirs1(s)
    found = (result != null)    
  if found 
  then println(result.length)
  else println("No Temporary Directory.")

• Client handling option

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

• null: no compiler support to check for presence of null-checking, cannot have methods

• 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 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