Décision pour des exceptions non contrôlées dans Scala

En tant que programmeur Java, j'ai toujours critiqué les exceptions non vérifiées. La plupart du temps, les programmeurs l'utilisent comme moyen de faciliter la programmation pour créer des problèmes plus tard. De plus, les programmes (bien que désordonnés) avec des exceptions vérifiées sont beaucoup plus robustes que leurs homologues non contrôlés.

Étonnamment à Scala, il n'y a rien qui s'appelle des exceptions vérifiées. Tous les Java cochés et décochés ne le sont pas dans Scala.

Quelle est la motivation derrière cette décision? Pour moi, cela ouvre un large éventail de problèmes lors de l'utilisation de tout code externe. Et si par hasard la documentation est médiocre, cela se traduit par KILL.

Les exceptions vérifiées sont généralement considérées comme un échec. Notez qu'aucun langage créé après Java ne les a adoptés. Voir http://www.artima.com/intv/handcuffs2.html , http://googletesting.blogspot.ru/2009/09/checked-exceptions-i-love-you-but-you.html , http: / /www.mindview.net/Etc/Discussions/CheckedExceptions , etc.

En particulier, ils sont impossibles (sauf en revenant à throws Exception ).

Dans Scala vous avez une meilleure option: utiliser les types algébriques pour les valeurs de rendement telles que Option[T], Either[Exception, T], votre propre type quand vous voulez que l'utilisateur pour traiter les cas de spécifiques (par exemple , au lieu de

def foo: Int // throws FileNotFoundException, IllegalStateException

vous avez

sealed trait FooResult
case class Success(value: Int) extends FooResult
case class FileNotFound(file: File) extends FooResult
case object IllegalState extends FooResult

def foo: FooResult

et le consommateur doit maintenant gérer tous les résultats)

Pour gérer le code externe qui lève des exceptions, vous avez scala.util.control.exceptionou scala.util.Try(à partir de Scala 2.10).

Les exceptions vérifiées en Java ne sont pas une si mauvaise chose. Bien sûr, les ADT peuvent être une meilleure option pour Scala, mais en Java, les exceptions vérifiées ont leur place et l' argument de code bien rangé est tout simplement insensé, peu importe le nombre de blogs qui le répètent. Il dit essentiellement que vous devez joyeusement ignorer les conditions graves et éventuellement réparables qui peuvent se produire dans votre système, car le système de type à vis, un joli code rend votre système robuste de manière automatique. Un tel raisonnement explique aussi pourquoi tant de programmeurs Java se déplacent volontairement leur code dans XMLs (Spring, Maven, etc. Je manque la jolie partie ici même).

La raison de l'absence d'exceptions vérifiées dans Scala donnée par M. Odersky ci-dessous http://www.scala-lang.org/old/node/8787.html est sans surprise différente et logique.

Le problème avec les exceptions vérifiées est mieux illustré par la méthode map sur les listes:

def map[B](f: A => B): List[B]

Comment annoter une carte avec @throws? Si la carte n'obtient pas elle-même une annotation @throws, il est probable que vous ne pouvez lui transmettre aucune fonction possédant un @throws. Cela introduirait des restrictions et des distinctions lourdes pour les façons dont la carte peut être utilisée. Les choses seraient mieux si nous pouvions dire d'une manière ou d'une autre que la carte lève toutes les exceptions que son argument de fonction lève. Il existe certains systèmes d'effets qui peuvent exprimer cela, mais jusqu'à présent, chaque notation que j'ai vue est trop lourde.

Lukas Rytz fait des recherches sur les systèmes d'effets légers qui pourraient être utilisés pour exprimer le type de carte et d'autres fonctions courantes de manière concise et précise. C'est de la recherche, donc on ne sait pas actuellement dans quelle mesure nous réussirons et quelle part de cela peut être mise dans Scala. Idéalement, nous pourrons l'ajouter à un moment donné en tant que système de type facultatif. Mais il est beaucoup trop tôt pour faire des prédictions concrètes.

À votre santé

Pas sûr, mais je pense que les lambdas Java 8 sont également limités à des exceptions non vérifiées.Les méthodes de la plupart (toutes?) Des nouvelles interfaces fonctionnelles de JDK 8 ( java.util.function.*) ne déclarent pas non plus d'exceptions non contrôlées.

Si vous voulez gagner en efficacité, vous devez abandonner .. précision / contrôle <- J'ai besoin d'un meilleur mot pour ça.

Scala est située vers le haut en ce qui concerne l'abstraction. Si l'un des objectifs de Scala est de se débarrasser du code passe-partout ennuyeux, alors la gestion des exceptions de Java est évidente. Si vous voulez écrire du code rapide en java, continuez de lever vos exceptions vérifiées jusqu'à ce qu'elles frappent main()et deviennent effectivement non vérifiées .

Je ne sais pas si j'arrive exactement à ce que vous demandez, mais c'est la raison la plus évidente à mon avis.

Eh bien, j'ai fait une petite recherche et quelqu'un a écrit sur la tragédie des exceptions de chèques .