Functional Error Handling (FEH)


In Scala, the correct solution to handling potential errors is to use Scala’s error-handling data types. In short, this means that a function that can fail should return one of the Option, Try, or Either types:

def wc(f: File): Option[?]
def wc(f: File): Try[?]
def wc(f: File): Either[?]

The basic idea is that you return an error-handling data type to account for the possibility that an error may occur in this function.

These types are wrappers

Error-handling types are basically wrappers, and inside their wrapper they contain one of two possibilities:

  • The function succeeded, and you can access its success value
  • The function failed, and you can access its error value

So it’s like you’re getting a container back from a function:

│                                       │
│   Success Value  OR  Failure Value    │
│                  --                   │

As shown, when you get the container back from the function, it will contain either a Success Value or a Failure Value — but not both.

A great thing about this approach is that unlike exceptions, they don’t short-circuit your code: you’re just working with another data type. You treat this result as a value, and you continue writing your code as algebra. You’ll see what this means shortly.

The Option, Try, and Either error-handling data types take slightly different approaches, but that’s the essence of them.

So let’s see how they work.

The three error-handling types

As mentioned, Scala’s three error-handling types are named Option, Try, and Either. Thinking in OOP for a moment, each of these are parent data types, and they each have two sub-types.

For these three values, these are the parent types and their two sub-types:

  • Option, Some, and None
  • Try, Success, and Failure
  • Either, Right, and Left

Their class hierarchies are basic OOP, and look like this:

      │  Option  │
     │            │    
┌────┴───┐   ┌────┴───┐
│  Some  │   │  None  │
└────────┘   └────────┘


        │ Try │
     │            │     
┌────┴────┐  ┌────┴────┐
│ Success │  │ Failure │
└─────────┘  └─────────┘

and this:

       │  Either  │
     │             │     
┌────┴───┐    ┌────┴────┐
│  Left  │    │  Right  │
└────────┘    └─────────┘

If your background is Java, you can think of Option, Try, and Either as being interfaces, and their sub-types are implementations of their interface.

In the following lessons we’ll look at what this means, and how these types work.