Throwing exceptions in Scala, what is the “official rule”

by

The basic guideline is to use exceptions for something really exceptional**. For an “ordinary” failure, it’s far better to use Option or Either. If you are interfacing with Java where exceptions are thrown when someone sneezes the wrong way, you can use Try to keep yourself safe.

Let’s take some examples.

Suppose you have a method that fetches something from a map. What could go wrong? Well, something dramatic and dangerous like a segfault* stack overflow, or something expected like the element isn’t found. You’d let the segfault stack overflow throw an exception, but if you merely don’t find an element, why not return an Option[V] instead of the value or an exception (or null)?

Now suppose you’re writing a program where the user is supposed to enter a filename. Now, if you’re not just going to instantly bail on the program when something goes wrong, an Either is the way to go:

def main(args: Array[String]) {
  val f = {
    if (args.length < 1) Left("No filename given")
    else {
      val file = new File(args(0))
      if (!file.exists) Left("File does not exist: "+args(0))
      else Right(file)
    }
  }
  // ...
}

Now suppose you want to parse an string with space-delimited numbers.

val numbers = "1 2 3 fish 5 6"      // Uh-oh
// numbers.split(" ").map(_.toInt)  <- will throw exception!
val tried = numbers.split(" ").map(s => Try(s.toInt))  // Caught it!
val good = tried.collect{ case Success(n) => n }

So you have three ways (at least) to deal with different types of failure: Option for it worked / didn’t, in cases where not working is expected behavior, not a shocking and alarming failure; Either for when things can work or not (or, really, any case where you have two mutually exclusive options) and you want to save some information about what went wrong; and Try when you don’t want the whole headache of exception handling yourself, but still need to interface with code that is exception-happy.

Incidentally, exceptions make for good examples–so you’ll find them more often in a textbook or learning material than elsewhere, I think: textbook examples are very often incomplete, which means that serious problems that normally would be prevented by careful design ought instead be flagged by throwing an exception.

*Edit: Segfaults crash the JVM and should never happen regardless of the bytecode; even an exception won’t help you then. I meant stack overflow.

**Edit: Exceptions (without a stack trace) are also used for control flow in Scala–they’re actually quite an efficient mechanism, and they enable things like library-defined break statements and a return that returns from your method even though the control has actually passed into one or more closures. Mostly, you shouldn’t worry about this yourself, except to realize that catching all Throwables is not such a super idea since you might catch one of these control flow exceptions by mistake.

More Related Contents:

  1. Method parameters validation in Scala, with for comprehension and monads
  2. Using Either to process failures in Scala code
  3. write Multiple lines in scala
  4. Scala 2.8 breakOut
  5. What is the formal difference in Scala between braces and parentheses, and when should they be used?
  6. How using try catch for exception handling is best practice
  7. Hidden features of Scala
  8. Encoder error while trying to map dataframe row to updated row
  9. What is a Manifest in Scala and when do you need it?
  10. Getting the desugared part of a Scala for/comprehension expression?
  11. What are some compelling use cases for dependent method types?
  12. Apache Spark how to append new column from list/array to Spark dataframe
  13. How to get ID of a map task in Spark?
  14. Why doesn’t Array’s == function return true for Array(1,2) == Array(1,2)?
  15. Encode an ADT / sealed trait hierarchy into Spark DataSet column
  16. Is there a way to use “type” word as a variable name in Scala?
  17. Use functional combinators on Scala Tuples?
  18. scala tuple unpacking
  19. How does the “scala.sys.process” from Scala 2.9 work?
  20. Difference between MutableList and ListBuffer
  21. Spark RDD default number of partitions
  22. Why does Spark RDD partition has 2GB limit for HDFS?
  23. Creating a method definition tree from a method symbol and a body
  24. Akka Kill vs. Stop vs. Poison Pill?
  25. Scala generic method – No ClassTag available for T
  26. Is there a simple example of how to generate verilog from Chisel3 module?
  27. Run a scala code jar appear NoSuchMethodError:scala.Predef$.refArrayOps
  28. Multiple try codes in one block
  29. Spark UDF with varargs
  30. How to transpose an RDD in Spark

Leave a Comment