Option
A special type of error that can occur is the absence of some value. For example when looking up a value in a database or a List you can use the find method. When implementing this in Java the common solution (at least until Java 7) would be to return null when a value cannot be found or to throw some version of the NotFound exception. In Scala you will typically use the Option[T] type, returning Some(value) when the value is found and None when the value is absent.
So instead of having to look at the Javadoc or Scaladoc you only need to look at the type of the function to know how a missing value is represented. Moreover you don't need to litter your code with null checks or try/catch blocks.
Another use case is in parsing input data: user input, JSON, XML etc.. Instead of throwing an exception for invalid input you simply return a None to indicate parsing failed. The disadvantage of using Option for this situation is that you hide the type of error from the user of your function which, depending on the use-case, may or may not be a problem.
An example that ensures that a name is non-empty:
def validateName(name: String): Option[String] = {
if (name.isEmpty) None
else Some(name)
}
You can use the validateName method in several ways in your code:
// Use a default value
validateName(inputName).getOrElse("Default name")
// Apply some other function to the result
validateName(inputName).map(_.toUpperCase)
// Combine with other validations, short-circuiting on the first error
// returning a new Option[Person]
for {
name <- validateName(inputName)
age <- validateAge(inputAge)
} yield Person(name, age)
Either
Option is nice to indicate failure, but if you need to provide some more information about the failure Option is not powerful enough. In that case Either[L,R] can be used. It has 2 implementations, Left and Right. Both can wrap a custom type, respectively type L and type R. By convention Right is right, so it contains the successful result and Left contains the error. Rewriting the validateName method to return an error message would give:
def validateName(name: String): Either[String, String] = {
if (name.isEmpty) Left("Name cannot be empty")
else Right(name)
}
Similar to Option Either can be used in several ways. It differs from option because you always have to specify the so-called projection you want to work with via the left or right method:
// Apply some function to the successful result
validateName(inputName).right.map(_.toUpperCase)
// Combine with other validations, short-circuiting on the first error
// returning a new Either[Person]
for {
name <- validateName(inputName).right
age <- validateAge(inputAge).right
} yield Person(name, age)
// Handle both the Left and Right case
validateName(inputName).fold {
error => s"Validation failed: $error",
result => s"Validation succeeded: $result"
}
// And of course pattern matching also works
validateName(inputName) match {
case Left(error) => s"Validation failed: $error",
case Right(result) => s"Validation succeeded: $result"
}
// Convert to an option:
validateName(inputName).right.toOption
This projection is kind of clumsy and can lead to several convoluted compiler error messages in for expressions. Due to these issues several alternative implementations for a kind of Either have been created, most well known are the \/ type in Scalaz and the Or type in Scalactic. Both avoid the projection issues of the Scala Either and, at the same time, add additional functionality for aggregating multiple validation errors into a single result type.
