Re: Gestion des erreurs

On est pas vendredi, mais remplacer du shell par du caml ... mis à part des améliorations purement techniques de performances, je ne comprend pas l'intérêt syntaxique (voir l'exemple qui est donné ...)

Après, pour la monade, oui, c'est une solution élégante, mais en OCaml, on ne peut pas garantir la pureté des fonctions, du coup, des méthodes de type « retry » et autres pourraient avoir des comportements étranges ... (si on ne fait pas attention)

Quitte à essayer de construire une bibliothèque qui le fait bien, autant coder directement en Haskell, qui possède tout ce qu'il faut pour combiner des fonctions, et qui permet (via l'évaluation paresseuse) de remplacer les générateurs de python par de simples listes ... et ce sans avoir une syntaxe immonde

cat :: String -> IO [String]
cat f = lines <$> readFile f
-- En traduisant « mot à mot » l'exemple du journal 
main :: IO ()
main = cat "fichier" >>= return . filter (\s -> length s > 0 && (s !! 0) /= '#') 
 >>= return . map toFloat
 >>= return . sort
 >>= return . take 10
 >>= output
-- En ré-écrivant pour utiliser >>= uniquement 
-- quand nécessaire (préférant (<$>) qui correspond à 
-- fmap en notation infixe)
main :: IO ()
main = (take 10 <$> 
 sort <$> 
 map toFloat <$> 
 filter (\s -> length s > 0 && (s !! 0) /= '#') <$> 
 cat "fichier") >>= output 
-- Enfin, en utilisant fmap f . fmap g = fmap (f . g)
main :: IO ()
main = (fmap traitement (cat "fichier")) >>= output
 where 
 traitement = take 10 . sort . map toFloat . filter ()

Pour résumer, oui l'approche monadique (ici avec IO) a beaucoup d'avantages :

1. Tu peux automatiquement promouvoir n'importe quelle fonction « normale » en une fonction qui agit sur un résultat de « programme » avec fmap ou <$>, ce qui permet d'utiliser toute fonction déjà écrite dans le langage que tu utilises
2. Tu peux raisonner sur des axiomes simples pour simplifier le code
3. Le résultat est encore lisible, plus facile à « comprendre » et surtout à modifier (on voit la structure du programme de manière apparente, et pas seulement au travers de commentaires à chaque étape ...)

Le seul problème est l'intégration du code monadique dans le langage, et en python c'est pas toujours « esthétique », le problème en caml se pose moins puisqu'il est possible de définir des opérateurs infixes.

Remarque : c'est le genre de syntaxe que j'ai proposé d'utiliser en mettant en place une classe python dans un autre commentaire.