Estou tentando criar uma construção elegante com compreensão da lógica de negócios baseada em futuros. Aqui está um exemplo que contém um exemplo de trabalho baseado no tratamento de exceções:

(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 ...
}

No entanto, isso pode ser visto como uma maneira não funcional ou não-Scala de lidar com as coisas. Existe uma maneira melhor de fazer isso?

Observe que esses erros vêm de fontes diferentes - alguns estão no nível comercial ('verificação de propriedade') e outros no nível do controlador ('autorização') e outros no nível db ('entidade não encontrada'). Portanto, as abordagens quando derivadas de um único tipo de erro comum podem não funcionar.