Error Handling in Scala

Knowledge Hub Functional Programming No Comments

This blog is part of a 10-part series designed to help readers learn Scala from the ground up. Whether you’re new to Scala or looking to solidify your understanding, this series will guide you through its core concepts step by step.

In Scala, managing errors effectively is crucial for building robust applications. Scala offers various ways to handle errors, including exceptions and functional constructs. Here’s a comprehensive guide:

Raising Exceptions

You can raise an exception using the throw keyword, followed by an instance of a subclass of java.lang.Throwable. For instance:

throw new IllegalStateException("Invalid operation")

Catching Exceptions

To handle exceptions, the try-catch construct is used. Code that might throw an exception is wrapped in a try block, and specific exceptions are handled in catch blocks. For example:

try {
  // Code that may throw an exception
} catch {
  case ex: IllegalStateException =>
    println(s"Illegal state: ${ex.getMessage}")
  case ex: Exception =>
    println(s"Unexpected error: ${ex.getMessage}")
}

In this example, exceptions of type IllegalStateException are handled by the first catch block, and all other exceptions are handled by the second block.

Using the finally Block

The finally block is used to execute code regardless of whether an exception was thrown or handled. For example:

try {
  // Code that may throw an exception
} catch {
  case ex: Exception =>
    println(s"Error: ${ex.getMessage}")
} finally {
  println("Execution completed.")
}

The code in the finally block executes unconditionally.

Custom Exceptions

You can define custom exceptions by extending java.lang.Exception. For instance:

class CustomError(message: String) extends Exception(message)
try {
  throw new CustomError("Custom error occurred")
} catch {
  case ex: CustomError =>
    println(s"Caught custom error: ${ex.getMessage}")
}

Functional Error Handling

Scala’s functional constructs like Try, Either, and Option enable cleaner and more expressive error handling.

Try

Try represents a computation that can either succeed (Success) or fail (Failure).

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

def safeDivide(x: Int, y: Int): Try[Int] = Try(x / y)
val result1 = safeDivide(10, 2)
result1 match {
  case Success(value) => println(s"Result: $value")
  case Failure(exception) => println(s"Error: ${exception.getMessage}")
}

val result2 = safeDivide(10, 0)
result2 match {
  case Success(value) => println(s"Result: $value")
  case Failure(exception) => println(s"Error: ${exception.getMessage}")
}

Either

Either represents a value that can be one of two types: Left (typically an error) or Right (a success).

object ErrorHandlingWithEither extends App {
  def safeDivide(dividend: Int, divisor: Int): Either[String, Int] = {
    if (divisor == 0) Left("Division by zero is not allowed.")
    else Right(dividend / divisor)
  }

  val result1 = safeDivide(10, 2)
  println(result1) // Right(5)
  val result2 = safeDivide(10, 0)
  println(result2) // Left(Division by zero is not allowed.)
}

Option

Option represents an optional value that can be either Some(value) or None.

import scala.util.Try

def safeDivide(x: Int, y: Int): Option[Int] = Try(x / y).toOption
val result = safeDivide(10, 2)
result match {
  case Some(value) => println(s"Result: $value")
  case None => println("Division by zero detected!")
}

Conclusion

This guide covers error-handling techniques in Scala, ranging from traditional exceptions to functional constructs like Try, Either, and Option. Choose the approach that best suits your application’s needs and aligns with the functional programming paradigm for cleaner and more maintainable code.

Pizenith is a trusted technology partner specializing in Data Engineering, Machine Learning, AI, Cloud Engineering, DevOps, and Functional Programming with Scala and Java. We help businesses scale with secure, automated, and data-driven solutions, delivering innovation in Test Automation and DevSecOps. Trusted by global enterprises, we empower organizations to stay ahead with AI-powered insights and scalable cloud infrastructure.

Want to future-proof your tech stack? Let’s talk! or reach us at info@pizenith.com.

Gallery

Contacts