Estoy tratando de crear una construcción ordenada con comprensión de la lógica empresarial basada en futuros. Aquí hay una muestra que contiene un ejemplo de trabajo basado en el manejo de excepciones:

(for {
  // find the user by id, findUser(id) returns Future[Option[User]]
  userOpt <- userDao.findUser(userId)        
  _ = if (!userOpt.isDefined) throw new EntityNotFoundException(classOf[User], userId)

  user = userOpt.get       

  // authenticate it, authenticate(user) returns Future[AuthResult]
  authResult <- userDao.authenticate(user)   
  _ = if (!authResult.ok) throw new AuthFailedException(userId)

  // find the good owned by the user, findGood(id) returns Future[Option[Good]]
  goodOpt <- goodDao.findGood(goodId)        
  _ = if (!good.isDefined) throw new EntityNotFoundException(classOf[Good], goodId)

  good = goodOpt.get        

  // check ownership for the user, checkOwnership(user, good) returns Future[Boolean]
  ownership <- goodDao.checkOwnership(user, good)
  if (!ownership) throw new OwnershipException(user, good)

  _ <- goodDao.remove(good) 
} yield {
  renderJson(Map(
    "success" -> true
  ))
})
.recover {
  case ex: EntityNotFoundException =>
    /// ... handle error cases ...
    renderJson(Map(
        "success" -> false,
        "error" -> "Your blahblahblah was not found in our database"
    ))
  case ex: AuthFailedException =>
    /// ... handle error cases ...
  case ex: OwnershipException =>
    /// ... handle error cases ...
}

Sin embargo, esto podría verse como una forma no funcional o no Scala para manejar las cosas. ¿Hay una mejor manera de hacer esto?

Tenga en cuenta que estos errores provienen de diferentes fuentes: algunos están en el nivel comercial ('verificar la propiedad') y algunos están en el nivel del controlador ('autorización') y algunos están en el nivel de base de datos ('entidad no encontrada'). Entonces, los enfoques cuando los deriva de un solo tipo de error común podrían no funcionar.