This slide is for a 30 minutes talk, during which I share my learning w/ my colleague about Functional Programing

1. Option - A Better Way to Handle Null Value
Jiaming Zhang
03 May 2017

2. What's Option?
Scala Documentation - Option

3. What's Option?
Option represents optional values. Instances of Option are either an instance of scala.Some or the object
None
Scala Documentation - Option

4. What's Option?
Option represents optional values. Instances of Option are either an instance of scala.Some or the object
None
def divide(x: Double, y: Double): Option[Double] =
if (y == 0) None else Some(x/y)
divide(4,2) // => Some(2.0)
divide(4,0) // => None
Scala Documentation - Option

5. What's Option?
Option represents optional values. Instances of Option are either an instance of scala.Some or the object
None
def divide(x: Double, y: Double): Option[Double] =
if (y == 0) None else Some(x/y)
divide(4,2) // => Some(2.0)
divide(4,0) // => None
// Map is a Scala built-in class, equivalent to Python's dict
val phonebook = Map(
"Vidar Deòrsa" -> "202-555-0136",
"Tito Oluwafunmilayo" -> "202-555-0129"
)
phonebook.get("Vidar Deòrsa") // => Some(202-555-0136)
phonebook.get("Anthony Asbury") // => None
Scala Documentation - Option

6. Why Use Option instead of Null?

7. Why Use Option instead of Null?
1. Clearer Function Signiture

8. Why Use Option instead of Null?
1. Clearer Function Signiture
def listHead[T](xs: List[T]): T = { /* ... */ }
listHead(List("x","y")) // => "x"
listHead(List(1,2,3)) // => 1
listHead(List()) // => ???
// Problem
// - Hard to know what `listHead(List())` returns w/o refering to doc/source code
// - Some careless user may even overlook such edge case, which leads to the infamous NullPointerException

9. Why Use Option instead of Null?
1. Clearer Function Signiture
def listHead[T](xs: List[T]): T = { /* ... */ }
listHead(List("x","y")) // => "x"
listHead(List(1,2,3)) // => 1
listHead(List()) // => ???
// Problem
// - Hard to know what `listHead(List())` returns w/o refering to doc/source code
// - Some careless user may even overlook such edge case, which leads to the infamous NullPointerException
def listHead[T](xs: List[T]): Option[T] = { /* ... */ }

10. Why Use Option instead of Null?
2. Can't Return Null

11. Why Use Option instead of Null?
2. Can't Return Null
A function can't return null if its return type is primitive (e.g. integer, double). An arbitrary value is usually
picked to represent null.
def search[T](haystack: Vector[T], needle: T): Int = { /* ... */ }
search(Vector("a", "b"), "a") // => 0
search(Vector("a", "b"), "x") // => -1

12. Why Use Option instead of Null?
2. Can't Return Null
A function can't return null if its return type is primitive (e.g. integer, double). An arbitrary value is usually
picked to represent null.
def search[T](haystack: Vector[T], needle: T): Int = { /* ... */ }
search(Vector("a", "b"), "a") // => 0
search(Vector("a", "b"), "x") // => -1
def search[T](haystack: Vector[T], needle: T): Option[Int] = { /* ... */ }
search(Vector("a", "b"), "a") // => Some(0)
search(Vector("a", "b"), "x") // => None

13. Why Use Option instead of Null?
2. Can't Return Null
A function can't return null if its return type is primitive (e.g. integer, double). An arbitrary value is usually
picked to represent null.
def search[T](haystack: Vector[T], needle: T): Int = { /* ... */ }
search(Vector("a", "b"), "a") // => 0
search(Vector("a", "b"), "x") // => -1
def search[T](haystack: Vector[T], needle: T): Option[Int] = { /* ... */ }
search(Vector("a", "b"), "a") // => Some(0)
search(Vector("a", "b"), "x") // => None
NOTE: As -1 is commonly used to represent NO FOUND, either approach is reasonable. However, the 2nd
apporach is more idiomatic in Scala.

14. Why Use Option instead of Null?
2. Can't Return Null
However, sometimes it's hard to find an arbitrary value to represent null.

15. Why Use Option instead of Null?
2. Can't Return Null
However, sometimes it's hard to find an arbitrary value to represent null.
def divide(divident: Double, divisor: Double): Double = { /* ... */ }
divide(4,2) // => 2.0
divide(4,0) // => ???

16. Why Use Option instead of Null?
2. Can't Return Null
However, sometimes it's hard to find an arbitrary value to represent null.
def divide(divident: Double, divisor: Double): Double = { /* ... */ }
divide(4,2) // => 2.0
divide(4,0) // => ???
@throws(classOf[java.lang.ArithmeticException])
def divide(divident: Double, divisor: Double): Double =
if (divisor !=0) divident / divisor
else throw new java.lang.ArithmeticException
// Not ideal as
// 1) FP discounrages side-effect and throwing exception is a side-effect
// 2) Exception should only be raised when its' truely exceptional

17. Why Use Option instead of Null?
2. Can't Return Null
However, sometimes it's hard to find an arbitrary value to represent null.
def divide(divident: Double, divisor: Double): Double = { /* ... */ }
divide(4,2) // => 2.0
divide(4,0) // => ???
@throws(classOf[java.lang.ArithmeticException])
def divide(divident: Double, divisor: Double): Double =
if (divisor !=0) divident / divisor
else throw new java.lang.ArithmeticException
// Not ideal as
// 1) FP discounrages side-effect and throwing exception is a side-effect
// 2) Exception should only be raised when its' truely exceptional
def divide(divident: Double, divisor: Double): Option[Double] =
if (divisor == 0) None else Some(divident / divisor)

18. Why Use Option instead of Null?
3. Work Well w/ Pattern Matching

19. Why Use Option instead of Null?
3. Work Well w/ Pattern Matching
// Given this function
def findMax(xs: List[Int]): Option[Int]
findMax(List(1,3)) // => Some(3)
findMax(List()) // => None
// How can I write this?
def findAbsMax(xs: List[Int]): Option[Int]
findAbsMax(List(1,3)) // => Some(3)
findAbsMax(List(-7,-9)) // => Some(7)
findAbsMax(List()) // => None

20. Why Use Option instead of Null?
3. Work Well w/ Pattern Matching
// Given this function
def findMax(xs: List[Int]): Option[Int]
findMax(List(1,3)) // => Some(3)
findMax(List()) // => None
// How can I write this?
def findAbsMax(xs: List[Int]): Option[Int]
findAbsMax(List(1,3)) // => Some(3)
findAbsMax(List(-7,-9)) // => Some(7)
findAbsMax(List()) // => None
def findAbsMax(xs: List[Int]): Option[Int] = findMax(xs) match {
case Some(x) => Some(math.abs(x))
case None => None
}

21. Why Use Option instead of Null?
4. Work Even Better w/ Higher-order Function
List(List(0,1,2), List(3,4,5)).flatMap(x => x) // => ???
List(List(1), List(), List(2)).flatMap(x => x) // => ???

22. Why Use Option instead of Null?
4. Work Even Better w/ Higher-order Function
List(List(0,1,2), List(3,4,5)).flatMap(x => x) // => ???
List(List(1), List(), List(2)).flatMap(x => x) // => ???
List(List(0,1,2), List(3,4,5)).flatMap(x => x) // => List(0,1,2,3,4,5)
List(List(1), List(), List(2)).flatMap(x => x) // => List(1,2)

23. Why Use Option instead of Null?
4. Work Even Better w/ Higher-order Function
List( List(1), List(), List(2) ).flatMap(x => x) // => List(1,2)
List( Some(1), None, Some(2) ).flatMap(x => x) // => ???

24. Why Use Option instead of Null?
4. Work Even Better w/ Higher-order Function
List( List(1), List(), List(2) ).flatMap(x => x) // => List(1,2)
List( Some(1), None, Some(2) ).flatMap(x => x) // => ???
List( List(1), List(), List(2) ).flatMap(x => x) // => List(1,2)
List( Some(1), None, Some(2) ).flatMap(x => x) // => List(1,2)

25. Why Use Option instead of Null?
4. Work Even Better w/ Higher-order Function
List( List(1), List(), List(2) ).flatMap(x => x) // => List(1,2)
List( Some(1), None, Some(2) ).flatMap(x => x) // => ???
List( List(1), List(), List(2) ).flatMap(x => x) // => List(1,2)
List( Some(1), None, Some(2) ).flatMap(x => x) // => List(1,2)
Takeaway: You can basically treat Some as a List that contains exactly one element and None as a empty List

26. Why Use Option instead of Null?
4. Work Even Better w/ Higher-order Function
Given this new understanding, let's rewrite this
def findAbsMax(xs: List[Int]): Option[Int] = findMax(xs) match {
case Some(x) => Some(math.abs(x))
case None => None
}

27. Why Use Option instead of Null?
4. Work Even Better w/ Higher-order Function
Given this new understanding, let's rewrite this
def findAbsMax(xs: List[Int]): Option[Int] = findMax(xs) match {
case Some(x) => Some(math.abs(x))
case None => None
}
def findAbsMax(xs: List[Int]): Option[Int] = findMax(xs).map(math.abs)

28. Why Use Option instead of Null?
4. Work Even Better w/ Higher-order Function
Given this new understanding, let's rewrite this
def findAbsMax(xs: List[Int]): Option[Int] = findMax(xs) match {
case Some(x) => Some(math.abs(x))
case None => None
}
def findAbsMax(xs: List[Int]): Option[Int] = findMax(xs).map(math.abs)
Here is a side-by-side comparison w/ List
List(-3).map(math.abs) // => List(3)
List().map(math.abs) // => List()
Some(-3).map(math.abs) // => Some(3)
None.map(math.abs) // => None

29. Why Use Option instead of Null?
5. Take advantage of FOR Expression
Let's continue the List vs Option analogy.
val list = List(List(1), List(), List(2))
list.flatMap(x => x.map(_*2))
// => List(2,4)
for (sublist <- list; item <- sublist) yield (item * 2)
// => List(2,4)

30. Why Use Option instead of Null?
5. Take advantage of FOR Expression
Let's continue the List vs Option analogy.
val list = List(List(1), List(), List(2))
list.flatMap(x => x.map(_*2))
// => List(2,4)
for (sublist <- list; item <- sublist) yield (item * 2)
// => List(2,4)
val list = List(Some(1), None, Some(2))
list.flatMap(option => option.map(_*2))
// => List(2,4)
for (option <- list; item <- option) yield (item * 2)
// => List(2,4)

31. Why Use Option instead of Null?
5. Take advantage of FOR Expression
Here is another more complicated example
// Given this function
def parseInt(value: String): Option[Int] = { /* ... */ }
parseInt("1") // => Some(1)
parseInt("x") // => None
parseInt(null) // => None
// Write function f so that
f(List("1", "x", "21", null)) // => List("2", "42")

32. Why Use Option instead of Null?
5. Take advantage of FOR Expression
Here is another more complicated example
// Given this function
def parseInt(value: String): Option[Int] = { /* ... */ }
parseInt("1") // => Some(1)
parseInt("x") // => None
parseInt(null) // => None
// Write function f so that
f(List("1", "x", "21", null)) // => List("2", "42")
def f(list: List[String]): List[String] = for {
item <- list
number <- parseInt(item)
} yield (number*2).toString