
Salut, est-ce que vous auriez quelques exemples de l'utilisation des symboles _ et []? C'est utilisé dans le cadre du pattern matching, mais j'ai du mal avec le _... a+ Corentin

Le jeudi 20 septembre 2007, Dupont Corentin a écrit :
Salut, est-ce que vous auriez quelques exemples de l'utilisation des symboles _ et []? C'est utilisé dans le cadre du pattern matching, mais j'ai du mal avec le _...
vrai :: Integer -> Bool vrai 0 = False vrai _ = True ce qui reviens à écrire en fonctionnel: Bool vrai (Integer variable) { if (variable == 0) { return False } else { return True } } On peut faire pareil sur des listes: vide :: [a] -> Bool vide [] = True vide (_) = False Sauf typo de ma part dans le code. Voici un exemple de code qui compile: myfilter :: [String] -> [String] myfilter [] = [] myfilter (x:xs) = case x of '#':_ -> myfilter(xs) otherwise -> x:myfilter(xs) Qui vire la fin des lignes dès qu'un '#' est rencontré. Cordialement. (J'ai bien compris que ça, alors j'en profite !)

En fait je suis venu à Haskell en faisant des recherches sur le refactoring de programmes. Etant informaticien, j'ai toujours trouvé que les programmes ne sont pas assez "plastiques". Les modifier est ardus, se fait à la main et est souvent aussi long que de redévelloper l'application. Il me semble aussi que le coup d'ajout d'une fonctionnalité dans un programme (en C par exemple) dépend fortement de la taille de ce programme... L'ajout d'une fonctionnalité A dans un programme de petite taille coute tant, l'ajout de cette même fonctionnalité dans un gros programme est... Beaucoup plus cher. Et ce n'est même pas garantie que ce soit linéaire... Il arrive que certains logiciels énormes dans mon milieu professionel deviennent des "chateaux de cartes" et le cout d'une nouvelle fonctionnalité devient prohibitif!!! Ce qui m'intérresse est le refactoring automatique, ou du moins assisté. Avez-vous connaissance de tels outils? Il m'a semblé que Haskell, avec sa transparence référentiel, est un bon candidat au refactoring automatique... Et qui dit refactoring dit analyse et préhension du programme dans son ensemble... J'imagine un logiciel qui donne une vue graphique d'ensemble de votre programme. Avec masquage des détails selon le niveau de "zoom"... Afin de distinguer du premier coup d'oeil les grandes fonctionnalitées symbolisées par des boites et leurs articulations. Est-ce utopique? J'imagine aussi pouvoir "refactorer" mon programme de façon entièrement graphique, en déplaçant les liaisons entre les boites...

http://www.haskell.org/haskellwiki/Applications_and_libraries/Program_develo... Dupont Corentin wrote:
En fait je suis venu à Haskell en faisant des recherches sur le refactoring de programmes.
Etant informaticien, j'ai toujours trouvé que les programmes ne sont pas assez "plastiques". Les modifier est ardus, se fait à la main et est souvent aussi long que de redévelloper l'application. Il me semble aussi que le coup d'ajout d'une fonctionnalité dans un programme (en C par exemple) dépend fortement de la taille de ce programme... L'ajout d'une fonctionnalité A dans un programme de petite taille coute tant, l'ajout de cette même fonctionnalité dans un gros programme est... Beaucoup plus cher. Et ce n'est même pas garantie que ce soit linéaire... Il arrive que certains logiciels énormes dans mon milieu professionel deviennent des "chateaux de cartes" et le cout d'une nouvelle fonctionnalité devient prohibitif!!!
Ce qui m'intérresse est le refactoring automatique, ou du moins assisté. Avez-vous connaissance de tels outils? Il m'a semblé que Haskell, avec sa transparence référentiel, est un bon candidat au refactoring automatique...
Et qui dit refactoring dit analyse et préhension du programme dans son ensemble... J'imagine un logiciel qui donne une vue graphique d'ensemble de votre programme. Avec masquage des détails selon le niveau de "zoom"... Afin de distinguer du premier coup d'oeil les grandes fonctionnalitées symbolisées par des boites et leurs articulations. Est-ce utopique? J'imagine aussi pouvoir "refactorer" mon programme de façon entièrement graphique, en déplaçant les liaisons entre les boites... _______________________________________________ Haskell-fr mailing list Haskell-fr@haskell.org http://www.haskell.org/mailman/listinfo/haskell-fr

On 9/20/07, Olivier Thauvin
Le jeudi 20 septembre 2007, Dupont Corentin a écrit :
Salut, est-ce que vous auriez quelques exemples de l'utilisation des symboles _ et []? C'est utilisé dans le cadre du pattern matching, mais j'ai du mal avec le _...
vrai :: Integer -> Bool vrai 0 = False vrai _ = True
ce qui reviens à écrire en fonctionnel:
Bool vrai (Integer variable) { if (variable == 0) { return False } else { return True } }
On peut faire pareil sur des listes:
vide :: [a] -> Bool vide [] = True vide (_) = False
Sauf typo de ma part dans le code.
Voici un exemple de code qui compile:
myfilter :: [String] -> [String] myfilter [] = [] myfilter (x:xs) = case x of '#':_ -> myfilter(xs) otherwise -> x:myfilter(xs)
Dans ton exemple je ne comprend pas, le x est bien un seul caratère? comment peut-il matcher avec '#':_ qui est me semble t-il une chaine?
Qui vire la fin des lignes dès qu'un '#' est rencontré.
Cordialement.
(J'ai bien compris que ça, alors j'en profite !)
_______________________________________________ Haskell-fr mailing list Haskell-fr@haskell.org http://www.haskell.org/mailman/listinfo/haskell-fr

On 9/20/07, Dupont Corentin
On 9/20/07, Olivier Thauvin
wrote: Le jeudi 20 septembre 2007, Dupont Corentin a écrit :
Salut, est-ce que vous auriez quelques exemples de l'utilisation des symboles _ et []? C'est utilisé dans le cadre du pattern matching, mais j'ai du mal avec le _...
vrai :: Integer -> Bool vrai 0 = False vrai _ = True
ce qui reviens à écrire en fonctionnel:
Bool vrai (Integer variable) { if (variable == 0) { return False } else { return True } }
On peut faire pareil sur des listes:
vide :: [a] -> Bool vide [] = True vide (_) = False
Sauf typo de ma part dans le code.
Voici un exemple de code qui compile:
myfilter :: [String] -> [String] myfilter [] = [] myfilter (x:xs) = case x of '#':_ -> myfilter(xs) otherwise -> x:myfilter(xs)
Dans ton exemple je ne comprend pas, le x est bien un seul caratère? comment peut-il matcher avec '#':_ qui est me semble t-il une chaine?
Autre question, est ce que je peux taper ton exemple directement que ghci sans utiliser de ficher?
Qui vire la fin des lignes dès qu'un '#' est rencontré.
Cordialement.
(J'ai bien compris que ça, alors j'en profite !)
_______________________________________________ Haskell-fr mailing list Haskell-fr@haskell.org http://www.haskell.org/mailman/listinfo/haskell-fr

On 9/20/07, david48
On 9/20/07, Dupont Corentin
wrote: Dans ton exemple je ne comprend pas, le x est bien un seul caratère? comment peut-il matcher avec '#':_ qui est me semble t-il une chaine?
myfilter :: [String] -> [String]
x est une chaine.
OK j'avais lu myfilter :: String -> String... Pour ghci, même avec let je n'y arrive pas car la fonction est en plusieurs lignes. Et je ne sait pas définir le type non plus...
David. _______________________________________________ Haskell-fr mailing list Haskell-fr@haskell.org http://www.haskell.org/mailman/listinfo/haskell-fr

Le 21/09/07, Dupont Corentin
Pour ghci, même avec let je n'y arrive pas car la fonction est en plusieurs lignes. Et je ne sait pas définir le type non plus...
Le type sera inféré, il est vrai que tu ne peux écrire que sur une ligne (je te conseille de prendre un éditeur avec un bon support d'Haskell, pour pouvoir charger directement tes modules dans une instance de GHCi, emacs ou vim pour citer des classiques), tu dois donc te passer du layout : let myfilter xxs = case xxs of {[] -> [] ; ('#':_):xs -> myfilter xs ; x:xs -> x:myfilter xs} (tu pourrais aussi copier plus directement la structure de l'original et faire deux case imbriqués, mais l'intérêt est limité...) ou tu peux écrire : let myfilter = filter ((/='#').head) bien sûr... ;-) (mais il n'y a plus de _) -- Jedaï

Le jeudi 20 septembre 2007, Dupont Corentin a écrit :
myfilter :: [String] -> [String] myfilter [] = [] myfilter (x:xs) = case x of '#':_ -> myfilter(xs) otherwise -> x:myfilter(xs)
Dans ton exemple je ne comprend pas, le x est bien un seul caratère?
Non, si tu regarde bien le prototype de la fonction, tu verras [String], et String est alias de [Char]. Donc dans (x:xs), x est le premier élément d'un tableau de chaine, donc un tableau de caractères.
comment peut-il matcher avec '#':_ qui est me semble t-il une chaine?
Si x est un tableau de Char ([Char]), il peut matcher '#':_ donc. Cordialement. PS: qq1 d'autre a déjà répondu, mais je m'en aperçois après avoir tapé, alors j'envois quand même ;)
participants (5)
-
Chaddaï Fouché
-
Dan Weston
-
david48
-
Dupont Corentin
-
Olivier Thauvin