J'inaugure mon compte sur ce blog en y postant mon premier billet, sur Haskell qui plus est !

Je vais vous montrer puis vous expliquer un moyen simple de supprimer toutes les instances d'un caractère donné dans une chaîne, en Haskell... en une ligne, oui.
Il s'agit donc par exemple de pouvoir supprimer tous les 'a' dans (je vais faire dans l'original) le titre de ce billet !

"Supprimer toutes les instances d'un caractère dans une chaîne en Haskell"
doit donc devenir :
"Supprimer toutes les instnces d'un crctère dns une chîne en Hskell"

Voici comment faire, en utilisant la fonction filter que nous expliquerons plus bas.

strip :: Char -> String -> String
strip c s = filter (/= c) s

Premièrement, regardons le type de cette fonction.
Elle prend a deux arguments : un caractère et une chaîne de caractères (qui, en Haskell, est définie comme une liste de caractères [Char]). Elle retourne une chaîne de caractères ; c'est bien ce que l'on désire.

Regardons ensuite la seconde ligne : c désigne le fameux caractère à supprimer et s la chaîne dans laquelle le supprimer.

Nous faisons ensuite appel à la fonction filter qui prend un prédicat à un argument (une fonction d'un argument qui retourne un booléen) et qui s'applique ensuite sur une liste, donnée en second argument. Elle retourne une liste où seuls les éléments vérifiant le prédicat sont restés. Je tiens à rappeler que Haskell étant un langage fonctionnel, on ne modifie pas la liste, on en retourne une nouvelle. N'ayez crainte, ça ne va pas faire des programme lourd, il y a de belles optimisations qui tournent derrière.

Mettez le code précédent dans un fichier strip.hs par exemple, et chargez-le dans GHCi via :load strip.hs (en vous assurant que vous êtes dans le bon répertoire). Puis testons :

*Main> strip 'a' "Supprimer toutes les instances d'un caractères dans une chaîne en Haskell"
"Supprimer toutes les instnces d'un crctères dns une chîne en Hskell"

Notons toutefois que le code ci-dessus peut-être encore plus court !
En effet, nous avons indiqué la chaine "s" alors que l'on peut s'en passer et écrire cela :

strip :: Char -> String -> String
strip c = filter (/= c)

Et encore, on sent que strip n'est définissable qu'avec filter et l'opérateur /= ... Et bien tout à fait !

strip :: Char -> String -> String
strip = filter . (/=)

Cette propriété se nomme êta-réduction et rend le code bien plus sobre, concis et clair. En effet, en Haskell, après un certain temps, on parvient à écrire du code qui n'est presque qu'un enchainement de compositions de fonctions, de sorte qu'une ligne ne soit presque qu'une phrase, si l'on nomme bien les fonctions.

Je rappelle que le '.' est tout simplement l'opérateur de composition de fonctions, et il suffit de regarder son type pour s'en convaincre :
Tapez :t (.) dans GHCi pour vous en convaincre, il vous dira ceci :

*Main> :t (.)
(.) :: (b -> c) -> (a -> b) -> a -> c

Ce qui signifie en gros :

Pour tous types a, b et c (polymorphisme inside), l'opérateur . prend deux fonctions, l'une (disons g) du type b vers le type c, l'autre (disons f) du type a vers le type b, et elle en fait la composition pour obtenir une fonction qui va du type a vers le type c.

C'est exactement ce que fait l'opérateur 'o' en Mathématiques ; en effet, g . f en Haskell est équivalent à g o f en Mathématiques.

Voilà pour mon premier billet ici.

Si vous avez découvert Haskell par ce billet et que vous souhaitez vous y mettre, voici quelques liens essentiels :
http://www.haskell.org/ : Site officiel, où l'on peut télécharger compilateur, interpréteur, outils & bibliothèques divers et variés mais également consulter des tutoriels/cours sur Haskell - c'est le QG de tous les programmeurs Haskell
http://en.wikibooks.org/wiki/Haskell : Le Wikibook sur Haskell
http://book.realworldhaskell.org/read/ : Le livre 'Real World Haskell' qui est disponible gratuitement en lecture en ligne
Et pour terminer, il y a le salon #haskell (et #haskell.fr, mais ce dernier est peu actif) sur le réseau IRC Freenode.

A bientôt !