Scala - Exception Handling (try/catch/finally)

Key Insights

• Scala’s try/catch/finally uses pattern matching syntax rather than Java’s multiple catch blocks, making exception handling more concise and type-safe • The Try monad provides a functional alternative to imperative exception handling, enabling composition and transformation of potentially failing operations • Scala encourages encoding failures in types using Option, Either, or Try rather than relying on exceptions for control flow

Basic Exception Handling with try/catch/finally

Scala’s exception handling syntax resembles Java but leverages pattern matching for catch blocks. The catch clause uses case statements to match exception types, providing a more idiomatic Scala approach.

def divideNumbers(a: Int, b: Int): Int = {
  try {
    a / b
  } catch {
    case e: ArithmeticException => 
      println(s"Cannot divide by zero: ${e.getMessage}")
      0
    case e: Exception => 
      println(s"Unexpected error: ${e.getMessage}")
      -1
  } finally {
    println("Division operation completed")
  }
}

// Usage
val result1 = divideNumbers(10, 2)  // 5
val result2 = divideNumbers(10, 0)  // 0, with error message

The finally block executes regardless of whether an exception occurs, making it ideal for cleanup operations like closing resources. Unlike Java, Scala’s try/catch/finally is an expression that returns a value.

def readFileContent(filename: String): String = {
  val source = scala.io.Source.fromFile(filename)
  try {
    source.getLines().mkString("\n")
  } catch {
    case e: java.io.FileNotFoundException => 
      s"File not found: $filename"
    case e: java.io.IOException => 
      s"Error reading file: ${e.getMessage}"
  } finally {
    source.close()
  }
}

Pattern Matching in Exception Handling

Scala’s pattern matching capabilities extend to exception handling, allowing you to match on exception properties and extract values.

def parseIntSafely(str: String): Int = {
  try {
    str.toInt
  } catch {
    case e: NumberFormatException if str.isEmpty => 
      println("Empty string provided")
      0
    case e: NumberFormatException if str.startsWith("-") => 
      println("Negative number format issue")
      -1
    case _: NumberFormatException => 
      println("Invalid number format")
      Int.MinValue
  }
}

// Advanced pattern matching with exception messages
def processData(data: String): Either[String, Int] = {
  try {
    Right(data.toInt * 2)
  } catch {
    case e @ NumberFormatException(msg) if msg.contains("null") =>
      Left("Null value encountered")
    case e: NumberFormatException =>
      Left(s"Parse error: ${e.getMessage}")
  }
}

The Try Monad for Functional Exception Handling

The Try type represents a computation that may fail with an exception. It has two subtypes: Success[T] and Failure[T], providing a functional approach to error handling.

import scala.util.{Try, Success, Failure}

def divide(a: Int, b: Int): Try[Int] = Try(a / b)

// Pattern matching on Try
divide(10, 2) match {
  case Success(result) => println(s"Result: $result")
  case Failure(exception) => println(s"Error: ${exception.getMessage}")
}

// Chaining operations with map and flatMap
val calculation: Try[Int] = for {
  step1 <- Try(10 / 2)
  step2 <- Try(step1 * 3)
  step3 <- Try(step2 - 5)
} yield step3

calculation match {
  case Success(value) => println(s"Final result: $value")
  case Failure(e) => println(s"Calculation failed: ${e.getMessage}")
}

Try provides methods for transformation and recovery, making it composable unlike traditional try/catch blocks.

def parseAndDouble(str: String): Try[Int] = {
  Try(str.toInt).map(_ * 2)
}

def parseWithFallback(str: String): Int = {
  Try(str.toInt)
    .recover {
      case _: NumberFormatException => 0
    }
    .getOrElse(-1)
}

// Combining multiple Try operations
def calculateAverage(numbers: List[String]): Try[Double] = {
  val parsedNumbers = numbers.map(s => Try(s.toInt))
  
  Try {
    val values = parsedNumbers.map(_.get)
    values.sum.toDouble / values.length
  }
}

// Better approach with sequence
def calculateAverageSafe(numbers: List[String]): Try[Double] = {
  import scala.util.Try
  
  val parsedNumbers: List[Try[Int]] = numbers.map(s => Try(s.toInt))
  val allOrNothing: Try[List[Int]] = Try(parsedNumbers.map(_.get))
  
  allOrNothing.map { values =>
    values.sum.toDouble / values.length
  }
}

Resource Management with try-with-resources

Scala 2.13+ provides automatic resource management through the Using object, similar to Java’s try-with-resources.

import scala.util.Using
import scala.io.Source

def readFile(filename: String): Try[String] = {
  Using(Source.fromFile(filename)) { source =>
    source.getLines().mkString("\n")
  }
}

// Multiple resources
def copyFile(source: String, dest: String): Try[Unit] = {
  Using.Manager { use =>
    val in = use(Source.fromFile(source))
    val out = use(new java.io.PrintWriter(dest))
    
    in.getLines().foreach(out.println)
  }
}

// Manual resource management with try/finally
def processFileManually(filename: String): Try[Int] = {
  var source: Option[Source] = None
  try {
    source = Some(Source.fromFile(filename))
    Success(source.get.getLines().size)
  } catch {
    case e: Exception => Failure(e)
  } finally {
    source.foreach(_.close())
  }
}

Combining Try with Either and Option

Scala’s error handling types can be converted and combined for different use cases.

import scala.util.{Try, Success, Failure}

def tryToOption[T](t: Try[T]): Option[T] = t.toOption

def tryToEither[T](t: Try[T]): Either[Throwable, T] = t.toEither

// Converting between types
def parseNumber(str: String): Either[String, Int] = {
  Try(str.toInt).toEither.left.map(_.getMessage)
}

// Practical example: validating and processing user input
case class User(name: String, age: Int)

def createUser(name: String, ageStr: String): Either[String, User] = {
  Try(ageStr.toInt).toEither match {
    case Right(age) if age > 0 && age < 150 =>
      Right(User(name, age))
    case Right(age) =>
      Left(s"Invalid age: $age")
    case Left(e) =>
      Left(s"Age must be a number: ${e.getMessage}")
  }
}

// Usage
createUser("Alice", "30") match {
  case Right(user) => println(s"Created user: $user")
  case Left(error) => println(s"Validation error: $error")
}

Custom Exception Types and Best Practices

Define custom exceptions for domain-specific errors and use sealed traits for exhaustive pattern matching.

sealed trait ValidationError extends Exception
case class InvalidEmailError(email: String) 
  extends Exception(s"Invalid email: $email") with ValidationError
case class InvalidAgeError(age: Int) 
  extends Exception(s"Invalid age: $age") with ValidationError

def validateEmail(email: String): Try[String] = {
  if (email.contains("@")) Success(email)
  else Failure(InvalidEmailError(email))
}

def validateAge(age: Int): Try[Int] = {
  if (age >= 0 && age <= 150) Success(age)
  else Failure(InvalidAgeError(age))
}

// Combining validations
def validateUser(email: String, age: Int): Try[(String, Int)] = {
  for {
    validEmail <- validateEmail(email)
    validAge <- validateAge(age)
  } yield (validEmail, validAge)
}

// Pattern matching on custom exceptions
def handleValidation(email: String, age: Int): String = {
  validateUser(email, age) match {
    case Success((e, a)) => s"Valid user: $e, $a years old"
    case Failure(InvalidEmailError(e)) => s"Fix email: $e"
    case Failure(InvalidAgeError(a)) => s"Fix age: $a"
    case Failure(e) => s"Unknown error: ${e.getMessage}"
  }
}

Prefer encoding failures in types rather than throwing exceptions for control flow. Reserve exceptions for truly exceptional circumstances, and use Try, Either, or Option for expected failure cases. This approach makes error handling explicit in function signatures and enables better composition of operations.