Search for a command to run...
![Error Handling in Cats Effect [Part-9]](/_next/image?url=https%3A%2F%2Fcdn.hashnode.com%2Fres%2Fhashnode%2Fimage%2Fupload%2Fv1682255148919%2F40617721-1396-4eff-85dc-6619819c2b75.jpeg&w=3840&q=75)
Travel | Movies | History | Nature
I am a software developer. Started my career as a Java developer, but later switched to Scala. I wish to write Scala articles which are easier for newbies to follow. I love to travel, prefer to be alone or in very small group. Love to watch movies/series.
// deprecated: method onError in class IO is deprecated since 3.6.0: Use onError with PartialFunction argument:
val loggedFailedError: IO[Int] = failedIO.onError(ex => IO.println("It failed with message: "+ex.getMessage))
// new:
val loggedFailedError: IO[Int] =
failedIO.onError {case ex => IO.println(s"It failed with message: ${ex.getMessage}")}
Hey sammo90 , are you using the version 3.6.0 ? This deprecation warning has been removed from 3.6.1. I think it was due to some package visibility issue.
Using Scala 3.8.3 (Windows 10): I get the warning:
Compiling project (Scala 3.8.3, JVM (temurin:21))
[warn] .\yadu9.sc:51:38
[warn] method onError in class IO is deprecated since 3.6.0: Use onError with PartialFunction argument
[warn] val loggedFailedError_1: IO[Int] = failedIO.onError(ex => IO.println("It failed with message: "+ex.getMessage))
[warn] ^^^^^^^^^^^^^^^^
Compiled project (Scala 3.8.3, JVM (temurin:21))
[io-compute-1] 500
[io-compute-blocker-1] -2
[io-compute-2] -2
[io-compute-blocker-1] 0
[io-compute-blocker-1] 0
[io-compute-blocker-1] -9
It failed with message: Boom!
Exception in thread "main" java.lang.RuntimeException: Boom!
...
Code section is:
val errorIO = IO(100/0)
val recoveredFailedIO_1: IO[Int] = errorIO.recover {
case ex: ArithmeticException => -9
}
// deprecated: method onError in class IO is deprecated since 3.6.0: Use onError with PartialFunction argument
val loggedFailedError_1: IO[Int] = failedIO.onError(ex => IO.println("It failed with message: "+ex.getMessage))
// new:
val loggedFailedError: IO[Int] =
failedIO.onError {case ex => IO.println(s"It failed with message: ${ex.getMessage}")}
My bad! Thanks. Corrected it.
In this series, I will try to introduce different concepts in Cats Effects. This is going to be a list of many short articles regarding the key features of Cats Effect.
For Scala developers who are new to Cats Effect, this article series aims to provide a comprehensive guide on how to use the effect system that helps control the execution of events. The series covers the concept of an effect, the importance of an ef...
Implementing Continuous Data Flows with FS2 Streaming
Building Resumable Data Pipelines with Redis-backed Offset Tracking and Batch Processing
Creating Flexible Data Integration Patterns for Cross-System Data Movement
How to leverage Scala 3 Mirrors to generically parse CSV files into case classes, making data handling more flexible and type-safe.
Introduction Recently, at work, there was a requirement to list out the direct dependencies of the our SBT project, something like Bill Of Materials. SBT itself provides the dependencies as list or tree or searchable HTML page using the built-in comm...
This is another part of the Cats Effect 3 series. In this short part, let's look at some of the ways to handle errors in Cats Effect 3.
Firstly, let's see how we can raise an error in CE. We can create a failed IO instance using the raiseError method:
val failedIO: IO[Int] = IO.raiseError(new RuntimeException("Boom!"))
Now, let's see different ways to handle error values in CE.
We can handle errors on IO by using handleError and handleErrorWith methods:
val handledError = failedIO.handleError(ex => 500)
val handledErrorWith = failedIO.handleErrorWith(ex => IO(-2))
In case of a failure, the handleError block is executed and that value is returned instead of the input value. We need to return an IO from handleErrorWith block, where as a plain value is returned from the handleError block.
We can also use recover and recoverWith methods to transform a failed IO effect:
val recoveredFailedIO: IO[Int] = failedIO.recover {
case ex => 0
}
The method recover takes a partial function and we can apply pattern matching on the exceptions to return a desired value. In the previous example, we can return a value of 0 in case of a failure. Similarly, we can use recoverWith to return an effectful value inside the partial function instead of a plain value:
val recoveredWithFailedIO: IO[Int] = failedIO.recoverWith {
case ex => IO(0)
}
In this case, we have to return an IO within the pattern matching.
This is similar to the recover and recoverWith methods available on Future.
The main difference between handleError and recover method is that the recover method takes a partial function, which enables us to easily handle different types of errors in different ways. Let's look at an example:
val errorIO = IO(100/0)
val recoveredFailedIO: IO[Int] = errorIO.recover {
case ex: ArithmeticException => 0
}
In the above case, the errorIO value will be transformed into IO(0) in case of ArithmeticException. For any other errors, the same failure value will be returned since we don't have a matching case statement for them.
If we want to merely perform a side effect on failure, such as logging the exception, we can simply use the method onError:
val loggedFailedError: IO[Int] = failedIO.onError(ex => IO.println("It failed with message: "+ex.getMessage))
Using onError(), we are logging the error message to the console and returning the same IO effect back. In Scala Future, we need to do failedFuture.failed.foreach method to perform an action on a failed future.
We can use the method attempt to lift the value of an IO into an Either. If the IO succeeds, it lifts the value as Right, otherwise into a Left:
val attemptedIO: IO[Either[Throwable, Int]] = loggedFailedError.attempt
There is a method rethrow() that is the inverse of the attempt method. It converts an IO[Either[Throwable, A]] to IO[A]. If the either is a Right, the value will be lifted into IO, otherwise it will be a failed IO:
val eitherValue: IO[Either[Throwable, String]] = IO.pure(Right("Hello World"))
val rethrownValue: IO[String] = eitherValue.rethrow
Another way to operate on a failed IO is by using orElse():
val orElseResult1: IO[Int] = IO(100).orElse(IO(-1)) //returns IO(100)
val orElseResult2: IO[Int] = failedIO.orElse(IO(-1)) //returns IO(-1)
In this short part, we discussed various options available in Cats Effect to handle errors. The sample code is available here on GitHub.