Discussion :

[Trap D]

Bonjour

Je viens enfin de tenter de me mettre a Haskell depuis 2 jours !

Je voudrais adapter un code Prolog :
regroupe([a,a,a, b,c,c], L) ==> L = [[a,2], [b,1], [c,2]]

Voilà mon essai

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
type MyType = [(Char, Int)]
 
regroupe :: [Char] -> MyType
 
regroupe n = case (n) of
	[k] -> [(k,1)]
	x:y:t -> (x,m+1):q where ((x == y) , ((x,m):q = regroupe (y:t)))  <== cette ligne est refusée à la compilation
	x:y:t -> (x,1):q where q = regroupe (y:t)

J'ai tenté plusieurs méthode mais aucune ne fonctionne en particulier celle-ci qui paraissait évidente pour un fan de Prolog

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
regroupe n = case (n) of
	[k] -> [(k,1)]
	x:x:t -> (x,m+1):q where (x,m):q = regroupe (x:t)
	x:y:t -> (x,1):q where q = regroupe (y:t)

où j'ai le message suivant
"conflicting définition for `x'
In a case alternative"

Donc je m'en remets à vous pour faire avancer mes connaissances

Merci

[gorgonite]

et comme cela ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
regroupe n = case (n) of
	[k] -> [(k,1)]
	x:y:t -> (x,m+1):q where x=y and (x,m):q = regroupe (x:t)
	x:y:t -> (x,1):q where q = regroupe (y:t)

[Trap D]

Ben non, il refuse en me signalant un = invalide pour "(x,m):q = regroupe (x:t)"

[Trap D]

Bon, j'y suis quand même arrvié, mais ce que j'ai fait ne me plaît pas beaucoup

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
type MyType = [(Char, Int)]
 
regroupe :: [Char] -> MyType
 
regroupe [n] = [(n,1)]
regroupe (x:y:t) = if x == y 
		   then regroupe1 (x:y:t)
		   else regroupe2 (x:y:t)
 
regroupe1 (x:y:t) = (x,m+1):q where (x,m):q = regroupe (y:t)
regroupe2 (x:y:t) = (x,1):q where q = regroupe (y:t)

Est-il possible de passer par des lambda sans définir explicitement regroupe1 et regroupe2 ???

Merci de vos remarques éventuelles.

[Alp]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
type MyType = [(Char, Int)]
 
regroupe :: [Char] -> MyType
 
regroupe [n] = [(n,1)]
regroupe (x:y:t) = if x == y 
		   then regroupe1 (x:y:t)
		   else regroupe2 (x:y:t)
             where
                   regroupe1 (x:y:t) = (x,m+1):q where (x,m):q = regroupe (y:t)
                   regroupe2 (x:y:t) = (x,1):q where q = regroupe (y:t)

J'ai peur qu'avec des lambdas ça ne soit carrément pas lisible

[Trap D]

J'ai peur qu'avec des lambdas ça ne soit carrément pas lisible

Alors ça serait du vrai Haskell ...

[Alp]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
type MyType = [(Char, Int)]
 
regroupe :: [Char] -> MyType
 
regroupe [n] = [(n,1)]
regroupe (x:y:t) = if x == y 
		   then regroupe1 (\(x:y:t) -> (x, m+1):q where (x,m):q = regroupe (y:t)) (x:y:t)
		   else (\(x:y:t) -> (x,1):q where q = regroupe (y:t)) (x:y:t)

devrait passer alors.

[Alp]

Je t'aurais plutôt vu jouer avec LambdaProlog, soit dit en passant.

[gorgonite]

Je t'aurais plutôt vu jouer avec LambdaProlog, soit dit en passant.

perso, je déconseille... sans grand intérêt en dehors de deux labos

[Alp]

La curiosité c'est bien.

Développer des applis avec, c'est une autre paire de manche. Autant rester sur OCaml/Haskell.

[Trap D]

I'm back.
J'ai essayé ton code, mais il ne passe pas (parse error on input `where').

Je n'ai pas envie de jouer avec avec des trucs un peu bancal (LambdaProlog est peut-être intéressant d'ailleurs je n'en sais rien), je préfère choisir un "vrai" langage fonctionnel, où j'ai tout à apprendre et comme je fréquente un bon forum avec de fins connaisseurs je suis sûr que j'y arriverais !

[Alp]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
type MyType = [(Char, Int)]
 
regroupe :: [Char] -> MyType
 
regroupe [n] = [(n,1)]
regroupe (x:y:t) = if x == y 
		   then (\(x:y:t) -> (\(x,m):q -> (x, m+1):q) (regroupe (y:t)) (x:y:t)
		   else (\(x:y:t) -> (x,1):(regroupe (y:t)) (x:y:t)

Et ça ?
A'pu 'where'

[Jedai]

Le "where" en Haskell regroupe des définitions, tu ne peux pas y mettre des conditions comme "x == y"...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
regroupe :: [Char] -> MyType
regroupe [] = []
regroupe [k] = [(k,1)]
regroupe (x:y:t) 
  | x == y    = let ((_,m):q) = regroupe (y:t) in (x,m+1):q
  | otherwise = (x,1) : regroupe (y:t)

serait le plus proche de ton code initial (sans le bug sur []).

Bien sûr un utilisateur plus expérimenté écrirait probablement simplement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
regroupe :: (Eq a) => [a] -> [(a,Int)]
regroupe = map (head &&& length) . group

--
Jedaï

[Trap D]

Salut et merci pour vos aides

Jedaï : Je préfère la première forme beaucoup simple à comprendre.
Il faut combien de temps de pratique pour arriver à écrire la deuxième forme ?

[Jedai]

Jedaï : Je préfère la première forme beaucoup simple à comprendre.
Il faut combien de temps de pratique pour arriver à écrire la deuxième forme ?

Ca dépend des gens. Quelques semaines peut-être ?

Quand à préférer la première ou la seconde proposition, je dirais que la seconde est infiniment plus claire : je peux en embracer la signification en un clin d'oeil comme une composition simple de fonctions courante, alors même que la première m'oblige à lire plusieurs lignes de code et à raisonner par cas, reconstituer laborieusement ce qui est exprimé directement dans la seconde.
Bien sûr je comprendrais que pour l'instant la seconde te déconcerte parce qu'elle utilise quelques fonctions que tu ne connais pas bien (group et (&&&)) et un style pointfree qui ne t'est probablement pas familier, mais je doute que tu préfères toujours la première forme à la seconde après quelques semaines de pratique.

Disons qu'il est normal que tu écrives la première au stade où tu en es mais je te donne la seconde pour que tu ais un avant goût de ce que tu écriras dans quelques temps.

--
Jedaï

[Garulfo]

Salut et merci pour vos aides

Jedaï : Je préfère la première forme beaucoup simple à comprendre.
Il faut combien de temps de pratique pour arriver à écrire la deuxième forme ?

Ca dépend des gens. Quelques semaines peut-être ?

Quand à préférer la première ou la seconde proposition, je dirais que la seconde est infiniment plus claire[...]
Disons qu'il est normal que tu écrives la première au stade où tu en es mais je te donne la seconde pour que tu ais un avant goût de ce que tu écriras dans quelques temps.

Je suis encore d'accord avec Jedaï — oui encore — quand à la préférence. De plus, c'est cette forme qu'il faut viser du premier coup. Il y a plusieurs raisons à cela. D'abord cela cache les détails et augmente le niveau d'abstraction. Ensuite — et c'est lié — cela permet d'espérer une implémentation amélioré de l'itérateur. De plus, ça permet aussi de généraliser à une extension en ne généralisant que l'itérateur, du moins potentiellement. Finalement, on gagne un temps impressionnant quand on pense tout de suite ainsi (à l'instar de la programmation par flots) et on réduit d'autant les risques d'erreur car le code est rapidement « pesé et emballé ».

En tout cas, j'ai des étudiants qui travaille en ocaml pour un de nos projets et ils font comme toi (TrapD). C'est naturel de commencer à décomposer les itérations car c'est ce qu'on apprend en cours. Il faut quand même un peu de temps pour assimiler le principe. Par contre, une fois qu'on l'a il est bon pour tous les langages qui disposent d'itérateurs — c'est-à-dire tous les langages fonctionnels que je connais.

[Alp]

D'ailleurs, c'est peut-être le moment pour Trap D de lire un peu sur foldl, foldr, map et compagnie.
http://www.haskell.org/haskellwiki/Fold
http://www.haskell.org/haskellwiki/Foldr_Foldl_Foldl%27
http://www.cs.bham.ac.uk/~ard/modules/swh06.html
http://www.cse.unsw.edu.au/~en1000/haskell/hof.html

Et si tu trouves le temps... Y'a un excellent papier, que je t'ai mis ici :
http://papers.mestan.fr/FP%20with%20...20Fokkinga.pdf

Les fold's sont les plus "complexes". Map et filter sont assez simples par exemple.

Bon courage

(PS : la seconde forme est clairement simple mais pour ton problème fallait rester dans ton exemple, pas de folding, maping, rien
D'ailleurs je vais voir si je m'étais trompé )

[Trap D]

regroupe = map (head &&& length) . group
je peux en embracer la signification en un clin d'oeil comme une composition simple de fonctions courante,

Celà nécessite une connaissance des fonctions prédéfinies de Haskell et pour le profane, même programmeur chevronné comme je crois quand même l'être, c'est totalement abscon.
Ce que je comprends, c'est que je dois connaître beaucoup d'outils avant de programmer correctement en Haskell.
Ce que j'aime bien en Prolog c'est que c'est surtout une manière de penser, il y a peu d'outils particuliers.
Ceci dit, je vais m'y mettre.
J'ai trouvé ce lien sur haskell, qu'en pensez vous ?

[Garulfo]

Celà nécessite une connaissance des fonctions prédéfinies de Haskell et pour le profane, même programmeur chevronné comme je crois quand même l'être, c'est totalement abscon.[...]

Mais tu ne faisais pas du Scheme toi ?
Parce que c'est très semblable dans la manière de penser ce genre de chose. C'est vrai qu'il faut connaître les opérateurs. Mais c'est plus question de savoir où chercher dans ce cas.

En général ça peut se lire très bien. Bon je ne dirais pas que ça forme des phrases, mais ce n'est pas si complexe. Pas plus qu'une boucle for l'est pour un débutant en C++ :mg:

[Trap D]

Oui, je t'avais contacté par MP et tu m'avais conseillé de lire le livre "Programmer avec scheme" de CHAZARIN.
j'avoue avoir commencer à le lire mais comme Prolog me plait énormément, j'ai un peu laisser tomber Scheme.
je comprends (enfin je crois) le principe de la programmation fonctionnelle, mais ce qui est plus dur c'est d'arriver à écrire un programme correct :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

c'est plus question de savoir où chercher dans ce cas.