La gestion des exceptions en Haskell

Quand dois-je utiliser la fonction?

Voici la recommandation du conseil de Contrôle.La documentation des exceptions:

• Si vous voulez faire un peu de nettoyage dans le cas où une exception est soulevée, utiliser finally, bracket ou onException.
• Pour récupérer après une exception et de faire autre chose, le meilleur choix est d'utiliser l'un des try famille.
• ... à moins que vous récupérez à partir asynchrone exception, auquel cas l'utilisation catch ou catchJust.

essayer :: Exception e => IO a -> IO (Soit e un)

try prend un IO action à exécuter, et renvoie un Either. Si le calcul réussi, le résultat est donné enveloppé dans un Right constructeur. (Pensez à droit, par opposition à tort). Si l'action a déclenché une exception du type spécifié, elle est retournée dans un Left constructeur. Si l'exception a été pas du type approprié, il continue à se propager de la pile. La spécification de SomeException que le type va attraper toutes les exceptions, qui peut ou peut ne pas être une bonne idée.

Notez que si vous voulez attraper une exception à partir d'un pur calcul, vous devrez utiliser evaluate pour forcer l'évaluation au sein de l' try.

main = do
    result <- try (evaluate (5 `div` 0)) :: IO (Either SomeException Int)
    case result of
        Left ex  -> putStrLn $ "Caught exception: " ++ show ex
        Right val -> putStrLn $ "The answer was: " ++ show val

catch :: Exception e => IO a -> e -> IO a) -> IO un

catch est similaire à try. Il tente d'abord d'spécifié IO action, mais si une exception est levée, le gestionnaire est donné l'exception d'obtenir une réponse alternative.

main = catch (print $ 5 `div` 0) handler
  where
    handler :: SomeException -> IO ()
    handler ex = putStrLn $ "Caught exception: " ++ show ex

Cependant, il y a une différence importante. Lors de l'utilisation de catch votre gestionnaire ne peut pas être interrompue par une asynchroneous exception (c'est à dire jeté partir d'un autre thread via throwTo). Essaie de soulever un asynchroneous exception bloquera jusqu'à ce que votre gestionnaire a fini de s'exécuter.

Remarque qu'il existe une autre catch dans le Prélude, de sorte que vous pourriez vouloir faire import Prelude hiding (catch).

poignée :: Exception e => e -> IO a) -> IO a -> IO un

handle est tout simplement catch avec les arguments dans l'ordre inverse. À utiliser dépend de ce qui rend votre code plus lisible, ou celui qui correspond le mieux si vous voulez utiliser l'application partielle. Ils sont par ailleurs identiques.

tryJust, catchJust et handleJust

Noter que try, catch et handle va attraper tous exceptions de l'/type inféré. tryJust et amis vous permettent de spécifier un sélecteur de fonction qui filtre des exceptions que vous souhaitez gérer. Par exemple, toutes les erreurs de calcul sont de type ArithException. Si vous ne voulez attraper DivideByZero, vous pouvez le faire:

main = do
    result <- tryJust selectDivByZero (evaluate $ 5 `div` 0)
    case result of
        Left what -> putStrLn $ "Division by " ++ what
        Right val -> putStrLn $ "The answer was: " ++ show val
  where
    selectDivByZero :: ArithException -> Maybe String
    selectDivByZero DivideByZero = Just "zero"
    selectDivByZero _ = Nothing

---

Une remarque sur la pureté

Noter que ce type de gestion d'exception ne peut se faire que dans impur code (c'est à dire la IO monade). Si vous avez besoin de gérer les erreurs dans le code pur, vous devez retourner des valeurs à l'aide Maybe ou Either au lieu (ou tout autre type de données algébrique). C'est souvent préférable car il est plus explicite, de sorte que vous savez toujours ce qui peut arriver où. Les monades comme Control.Monad.Error rend ce type d'erreur de manipulation plus facile de travailler avec.

---

Voir aussi:

• De contrôle.Exception

Re: question 3: attraper et manipuler sont les même (trouvé par le biais de hoogle). Le choix de l'utiliser dépend généralement de la durée de chaque argument. Si l'action est plus courte, l'utilisation de capture et vice versa. Simple poignée exemple à partir de la documentation:

do handle (\NonTermination -> exitWith (ExitFailure 1)) $ ...

Aussi, vous pouvez, en théorie au curry la poignée de la fonction d'un gestionnaire personnalisé, que vous pouvez ensuite passer autour, par exemple. (adapté à partir de la documentation):

let handler = handle (\NonTermination -> exitWith (ExitFailure 1))

Des messages d'erreur personnalisés:

do       
    let result = 5 `div` 0
    let handler = (\_ -> print "Error") :: IOException -> IO ()
    catch (print result) handler