Methods sometimes compute several interesting results from their input parameters. Yet, many languages, including Java, allow only one return value from a method. It would be convenient to have a built-in language construct that allows the return of more than just a single value from a method call, writes Daniel Spiewak in a recent blog post, The "Option" Pattern.

Spiewak introduces Scala's Option construct, illustrating its use with a common example from Java programming:

Often times a method needs to return either a value or nothing, depending on various conditions. More importantly, some internal state may be uninitialized, so a common “default” value for this state would be null...

Primitive values cannot be valued as null because they are true primitives (an int is actually a bona-fide integer value sitting in a register somewhere at the hardware level)... This too is a holdover from the days of C and C++, but it’s something we have to deal with. One of the consequences of this is that there is no reasonable “non-value” for primitive types... Effectively, null is an untyped value which may be assigned to any class type. Java has no concept of a Nothing type which is a subtype of anything.

In the article, Spiewak describes just such a construct in Scala, Option:

Option is a class in the Scala core libraries. It is what object-oriented developers would call “a simple container”. It simply wraps around an instance of some type as specified in its type parameter...

A simple application would be in a naive integer division function:

def div(a:Int)(b:Int):Option[Int] = if (b <= 0) None
  else if (a < b) Some(0)
  else Some(1 + div(a - b)(b).get)

What’s really interesting here is the use of Option to encapsulate the result. Here’s how we could use this method to perform some useful(?) calculations:

div(25)(5)     // => Some(5)
div(150)(2)    // => Some(75)
div(13)(4)     // => Some(3)

Each return value is wrapped in an instance of class Some, which is a subclass of Option... This doesn’t seem very useful until we consider what happens when we try to divide values which break the algorithm:

div(13)(0)     // => None
div(25)(-5)    // => None

Instead of getting an integer result wrapped in an enclosing class, we get an instance of a totally different class which doesn’t appear to encapsulate any value at all. None is still a subclass of Option, but unlike Some it does not represent any specific value. In fact, it would be more accurate to say that it represents the absence of a value.

In the article, Spiewak discusses how to use pattern matching to retrieve values from an Option, and also shows an example of implementing an Option-like construct in Java.What do you think of Scala's Option class?

def rand = Math.random*10 toInt
def getInput1 = if(rand % 2 == 0) Some(102) else None
getInput1 match{
  case Some(n)=>println("valid number " +n)
  case None=>println("invalid number")
}

def getInput2 = if(rand % 2 == 0) Some(new Object()) else None
getInput2 match{
  case Some(obj)=>println("valid object " +obj)
  case None=>println("invalid object")
}

def getDate = new java.text.SimpleDateFormat("yyyy-MM-dd").parse("2008-01-01")
def getInput3 = if(rand % 2 == 0) Some(getDate) else None
val input3 = getInput3 getOrElse new java.util.Date

try {
   return foo.getBar().getCar().getDog().getTail();
}
catch (NullPointerException npe) {  // something is null
   return null;
}