Scala bloque enfin la fermeture / le rinçage des ressources

Quelque chose comme ça est une bonne idée, mais je ferais une méthode:

def cleanly[A,B](resource: => A)(cleanup: A => Unit)(code: A => B): Option[B] = {
  try {
    val r = resource
    try { Some(code(r)) }
    finally { cleanup(r) }
  } catch {
    case e: Exception => None
  }
}

(notez que nous attrapons seulement une fois; si vous voulez vraiment un message imprimé dans un cas et pas l'autre, alors vous devez attraper les deux comme vous l'avez fait). (Notez également que je n'attrape que des exceptions; attraper Error est généralement imprudent, car il est presque impossible de récupérer.) La méthode est utilisée comme ceci:

cleanly(new FileOutputStream(path))(_.close){ fos =>
  Iterator.continually(in.read).takeWhile(_ != -1).foreach(fos.write)
}

Comme il renvoie une valeur, vous obtiendrez un Some(()) s'il a réussi ici (ce que vous pouvez ignorer).

Edit: pour le rendre plus général, je le ferais vraiment retourner un Either à la place, donc vous obtenez l'exception. Comme ça:

def cleanly[A,B](resource: => A)(cleanup: A => Unit)(code: A => B): Either[Exception,B] = {
  try {
    val r = resource
    try { Right(code(r)) } finally { cleanup(r) }
  }
  catch { case e: Exception => Left(e) }
}

Maintenant, si vous obtenez une Right, tout s'est bien passé. Si vous obtenez un Left, vous pouvez choisir votre exception. Si vous ne vous souciez pas de l'exception, vous pouvez utiliser .right.toOption pour la mapper dans une option, ou simplement utiliser .right.map ou autre pour fonctionner sur le résultat correct seulement s'il est là (comme avec Option). (Pattern matching est un moyen utile de traiter EitherS.)