Re: Gestion des erreurs

mais qu'est-ce que le () à la fin ?

Euh, c'est moi qui ai oublié de le remplacer par (\s -> length s > 0 && (s !! 0) /= '#'), du coup c'est normal que cela n'ai pas de sens ...

fmap je suppose que ça veut dire function map

En fait, c'est « un peu plus » que cela. Imaginons que tu te donnes un type A quelconque, et que tu puisse manipuler des types [A] (ici c'est liste, mais en fait, ça peut être « programme », IO ...). Tu te dis :

• J'ai tout un tas de fonctions super cool sur le type A
• J'ai tout un tas de fonctions super cool sur le type [] (indépendantes de A, par exemple head, tail etc ...)
• J'aimerais avoir un moyen de transformer une fonction de A -> B en une fonction de [A] -> [B] : c'est fmap qui le fait

Alors, pour les listes, fmap = map. Mais en fait c'est beaucoup plus général : du moment que tu as un type paramétré, tu peux espérer trouver une fonction fmap, et qui a le bon goût de vérifier quelques axiomes (fmap id = id ou fmap f . fmap g = fmap (f . g) etc ...)

Donc en fait fmap, c'est « functor map », et c'est un moyen de transformer une fonction « normale » sur une fonction d'un type paramétré.

Dans le cas présent, c'est IO a qui est un type paramétré, et qui représente un calcul effectué dans un état global.

>>= Ça doit être un truc avec l'approche monadique

Exactement, et cela vient très naturellement. Bon, c'est cool de pouvoir appliquer les fonctions normales sur ton type, mais tu as construit un type, c'est pas pour rien : il faut pouvoir faire plus de choses. En plus, tu as souvent des fonctions comme : a -> F b (j'ai remplacé [] par F) et le problème ... c'est qu'elles ne se composent pas ! C'est tout ce que >>= fait : donner un moyen de composer ce nouveau type de fonctions.

• f : a -> F b : prend un type normal, retourne un type complexe
• g : b -> F c : idem
• f >=> g : a -> F c : prend un type normal, retourne un type complexe (en effectuant f puis g)

En fait, pour des raisons pratiques, on utilise plus souvent >>= que >=>, avec a >>= g === (\_ -> a) >>= g.

Exemple pratique, tu récupères la liste des arguments de la ligne de commande, c'est une action, de type Action [String], tu veux afficher cette liste, c'est une action, mais elle attend la chose à afficher en argument :

getArg :: Action [String]
print :: String -> Action ()
printArgs :: Action ()
printArgs = getArg >>= (print . concat)

Donc en réalité, tout le code qui est écrit en exemple est soit

1. De la composition de fonction
2. De la transformation de fonction (en fonction sur les IO)

En espérant que mes explications sont claires :-)