This is the presentation from my talk at the Vienna Scala Usergroup on June 8th, 2017. It is about various approaches for error and failure handling in Scala.

1. ERROR HANDLING IN
SCALA
Daniel Pfeiffer - @pfeiffer_d_

2. FROM ZERO TO
HERO

3. ERRORS VS.
FAILURES

4. ERRORS ARE UNEXPECTED

5. FAILURES ARE EXPECTED WRONG
BEHAVIOUR

6. THE PROBLEM
DOMAIN

7. THE PROBLEM DOMAIN
sealed trait TimeEntryStatus
case object Open extends TimeEntryStatus
case object Accepted extends TimeEntryStatus
case object Declined extends TimeEntryStatus
case class TimeEntry(
id: UUID,
begin: LocalDateTime,
end: LocalDateTime,
status: TimeEntryStatus
)

8. THE PROBLEM DOMAIN
val timeEntry = TimeEntry(
id = UUID.randomUUID,
begin = LocalDateTime.now.minusHours(1),
end = LocalDateTime.now,
status = Open
)

9. THE PROBLEM DOMAIN
class TimeEntryService{
private[this] var timeEntries: Map[UUID, TimeEntry] = Map()
def create(t: TimeEntry) = ???
def accept(id: UUID) = ???
def decline(id: UUID) = ???
}

10. FAILURES
HAPPEN
IDs are unique
IDs might not exist
Many more

11. A JAVAISH
SOLUTION
Many of us are used to
develop like this
Failures handling with
exceptions
Better solutions
already exist

12. A JAVAISH SOLUTION
abstract class TimeEntryException(message: String) extends Exception
case class TimeEntryAlreadyExistsException(id: UUID)
extends TimeEntryException(s"Time Entry with id $id already exists.")
case class TimeEntryDoesNotExistException(id: UUID)
extends TimeEntryException(s"Time Entry with id $id does not exist.")

13. A JAVAISH SOLUTION
class TimeEntryService {
def create(t: TimeEntry): Unit = {
if (timeEntries.contains(t.id)) {
throw TimeEntryAlreadyExistsException(t.id)
} else {
timeEntries = timeEntries + (t.id -> t)
}
}
}

14. A JAVAISH SOLUTION
try {
service.create(entry)
service.accept(entry.id)
} catch {
case TimeEntryDoesNotExistException(id) =>
println("Sorry the time entry does not exist.")
case TimeEntryAlreadyExistsException(id) =>
println("Sorry the time entry does already exist.")
}

15. AT LEAST WE CAN
TRY

16. AT LEAST WE CAN TRY
def create(timeEntry: TimeEntry): Try[Unit] = {
if (timeentries.contains(timeEntry.id)) {
Failure(TimeEntryAlreadyExistsException(timeEntry.id))
} else {
timeentries += (timeEntry.id -> timeEntry)
Success(())
}
}

17. LOOKS BETTER, HMMM?
val result: Try[Unit] = for {
_ <- service.create(timeEntry)
_ <- service.accept(timeEntry.id)
_ <- service.create(timeEntry)
} yield ()
result match {
case Success(_) => println("Succeeded.")
case Failure(ex) => println(s"Exception occurred. ${ex.getMessage}")
}

18. USE THE FORCE LUKE

19. MY PRECIOUS
sealed trait TimeEntryFailure
case class ValidationFailed(failures: List[String])
extends TimeEntryFailure
case class TimeEntryDoesNotExist(id: UUID)
extends TimeEntryFailure
case class TimeEntryAlreadyExists(id: UUID)
extends TimeEntryFailure

20. EITHER, WE TRY...
type TimeEntryResult[A] = Either[TimeEntryFailure, A]
def create(t: TimeEntry): TimeEntryResult[Unit] = {
if (timeEntries.contains(t.id)) {
Left(TimeEntryAlreadyExists(t.id))
} else {
timeEntries = timeEntries + (t.id -> t)
Right(())
}
}

21. ... AND MATCH IT
//type TimeEntryResult[A] = Either[TimeEntryFailure,A]
val result: TimeEntryResult[Unit] = for {
_ <- service.create(entry)
_ <- service.create(entry)
_ <- service.accept(entry.id)
} yield ()
result.fold(
{
case TimeEntryDoesNotExist(id) => println("Sorry, the time entry does not exis
case TimeEntryAlreadyExists(id) => println("Sorry, the time entry already exis
}, { _ =>
println("Yeaaah, success!")
}
)

22. YOU GOT A COMPILER, SO USE IT
[warn] /Users/daniel/presentations/2017-06-08_error-handling-in-scala/
code/src/main/scala/com/github/dpfeiffer/errorhandling/either/
ExampleWithEither.scala:60: match may not be exhaustive.
[warn] It would fail on the following input: ValidationFailed(_)
[warn] {
[warn] ^
[warn] one warning found

23. LET'S MAKE THIS A HARD CONSTRAINT
scalacOptions += "-Xfatal-warnings",
[error] /Users/daniel/presentations/2017-06-08_error-handling-in-scala/
code/src/main/scala/com/github/dpfeiffer/errorhandling/either/
ExampleWithEither.scala:60: match may not be exhaustive.
[error] It would fail on the following input: ValidationFailed(_)
[error] {
[error] ^
[error] one error found

24. THE EMPIRE STRIKES BACK

25. WELCOME TO THE FUTURE, ...
def create(timeEntry: TimeEntry)
(implicit ec: ExecutionContext): Future[Unit] = {
for{
exists <- exists(timeEntry.id)
_ <- if (exists) {
Future.failed(TimeEntryAlreadyExistsException(timeEntry.id))
} else {
store(timeEntry)
}
} yield ()
}

26. ... THAT LOOKS LIKE THE TRY
val result = for {
_ <- service.create(timeEntry)
_ <- service.accept(timeEntry.id)
_ <- service.create(timeEntry)
} yield ()
result.onComplete {
case Success(_) => println("Succeeded.")
case Failure(ex) => println(s"Exception occurred. ${ex.getMessage}")
}

27. WE
WANT
BOTH
Asynchronity
Nice failure handling

28. FUTURE[EITHER[FAILURE,A]]
//type TimeEntryResult[A] = Future[Either[TimeEntryFailure, A]]
val result: TimeEntryResult[Unit] = for {
r1 <- service.create(entry)
r2 <- r1 match {
case Left(f) => Future.successful[TimeEntryFailureOr[Unit]](Left(f))
case Right(_) => service.create(entry)
}
r3 <- r2 match {
case Left(f) => Future.successful[TimeEntryFailureOr[Unit]](Left(f))
case Right(_) => service.accept(entry.id)
}
} yield r3

31. MONAD
TRANSFORMERS

32. EITHERT MONAD TRANSFORMER
vs
type TimeEntryResult[A] = Future[Either[TimeEntryFailure, A]]
import cats.data.EitherT
type TimeEntryResult[A] = EitherT[Future, TimeEntryFailure, A]

33. WRAPPING EVERYTHING IN A NEW
MONAD
type FutureEither = EitherT[Future, String, String]
val a: FutureEither = EitherT(Future(Right("right")))
val b: FutureEither = EitherT(Future(Left("left"))
val c: FutureEither = EitherT.right(Future("right"))
val d: FutureEither = EitherT.left(Future("left"))
val e: FutureEither = EitherT.fromEither(Right("right"))

34. THE USAGE LOOKS GOOD IF...
we only use TimeEntryResult[_]
//type TimeEntryResult[A] = EitherT[Future,TimeEntryFailure,A]
val result: TimeEntryResult[Unit] = for {
_ <- service.create(entry)
_ <- service.create(entry)
_ <- service.accept(entry.id)
} yield ()
result
.fold(handleFailure, _ => println("Success!!!"))
.onComplete {
case Failure(t) => println("Oh noooo!")
case Success(_) =>
}

35. BUT IF WE MIX TYPES...
def create(t: TimeEntry)
(implicit ec: ExecutionContext): TimeEntryResult[Unit] = {
for {
_ <- EitherT (
find(t.id).map{
case Some(_) => Left(TimeEntryAlreadyExists(t.id))
case None => Right(())
}
)
_ <- EitherT.right(store(t))
} yield ()
}
private def find(timeEntryId: UUID)
(implicit ec: ExecutionContext): Future[Option[TimeEntry]] = Future {
timeEntries.get(timeEntryId)
}
private def store(t: TimeEntry)
(implicit ec: ExecutionContext): Future[Unit] = Future {
timeEntries += (t.id -> t)
().asRight
}

36. SCALA IS FLEXIBLE ENOUGH TO GUIDE
US A WAY
def create(t: TimeEntry)
(implicit ec: ExecutionContext): TimeEntryResult[Unit] = {
for {
_ <- ? <~ find(t.id).map {
case Some(_) => Left(TimeEntryAlreadyExists(t.id))
case None => Right(())
}
_ <- ? <~ store(t)
} yield ()
}

37. SO WE CREATED OUR OWN DSL
object ? {
def <~[A](x: A)(implicit ec: ExecutionContext): TimeEntryResult[A] = {
x.pure[TimeEntryResult]
}
def <~[A](x: Either[TimeEntryFailure, A])(implicit ec: ExecutionContext): TimeEn
EitherT.fromEither[Future](x)
}
def <~[A](x: Future[A])(implicit ev: A <:!< Either[TimeEntryFailure, _], ec:
EitherT.right[Future, TimeEntryFailure, A](x)
}
def <~[A](x: Future[Either[TimeEntryFailure, A]]): TimeEntryResult[A] = {
EitherT(x)
}
}

38. LITERATURE
http://blog.leifbattermann.de/2017/03/16/7-most-
convenient-ways-to-create-a-future-either-stack/
http://twitter.github.io/effectivescala/#Error%20handlin
http://typelevel.org/cats/
http://eed3si9n.com/herding-cats/stacking-future-
and-either.html http://eed3si9n.com/herding-
cats/monad-transfomers.html
https://github.com/dpfeiffer/error-handling-in-scala