Scala Options

One of the most interesting and unfamiliar features of Scala for Java programmers is the Option. The easiest way to think about it is as an explicit representation of an object that may be null. For example, let's say you have a method getString() which returns a String that may be null. In Java you would do:

	public class NullExample {
	public static void main(String[] args) {
	String s = getString();
	if (s != null) {
	// ...
	} else {
	// ...
	}
	}
	}

view raw NullExample.java hosted with ❤ by GitHub

while in Scala you would do:

	object OptionExample {
	def main(args: Array[String]) {
	val s: Option[String] = Option(getString())
	s match {
	case Some(s) => // ...
	case None => // ...
	}
	}
	}

view raw OptionExample.scala hosted with ❤ by GitHub

where we are leveraging pattern matching. The Option() apply method takes an object and turns it into either a Some (which is generic on the type) or a None depending on whether the object is null. So by using Options you are enforcing an actual type distinction between null and non-null instances of the object. This might not seem like a big deal, but if done thoroughly, you could end up with code in which you are guaranteed that an object not wrapped by an option is non-null. That means you could get rid of NullPointerExceptions! Anyone who has programmed long enough in Java knows how much of a win that would be. Unfortunately, because Scala projects typically have to integrate with a lot of existing Java code, we can't quite reach that ideal state. But if you're diligent in wrapping the return values of third-party libraries in options when the result may be null, you can enforce this checking in your own code.

Besides compile-time distinction between null and non-null instances, options are designed in such a way that they play very nicely with the functional side of Scala. In fact, options are treated as a collection where there is either zero or one element. That means you can do all sorts of interesting things such as:

	object OptionFun {
	def main(args: Array[String]) {
	val s: Option[String] = Option(getString())
	// print it if it's non-null
	s.foreach(println(_))
	// call a method if it's non-null and return the result as an option
	s.map(_.toUpperCase())
	// get the string if it's non-null; empty string otherwise
	s.getOrElse("")
	// returns true if it's null or the empty string
	s.forall(_.isEmpty())
	}
	}

view raw OptionFun.scala hosted with ❤ by GitHub

In each of these cases you would have to do an annoying null check before doing what you actually wanted to do. Scala's functional constructs for operating on collections provide concise ways of handling options without you ever having to mention null or None.