Discussion :

[mchk0123]

Désolé si je vais vite au coeur du sujet,
je débute en Haskell (mon essai de deuxième langage fonctionnel aprés Scheme), je trouve ça trés sympa.

Mon programme marche bien, par contre j'ai ce bout de code qui me parait (même à moi auteur) un peu abscond :

Code :

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

1
2
3
4
5
6
7
head_until [] p = []
head_until (x:xs) p = if not (p x) then x : head_until xs p else []
next_move l i =
...
is_end_move l = l == (-1,-1)
all_next_moves2 l = (0, 0) : head_until (map (next_move l) (all_next_moves2 l)) is_end_move
all_next_moves l = tail (all_next_moves2 s)

Comme je ne maitrise vraiment pas encore le langage de A-Z est-ce que quelqu'un pourrait me donner des indices ou des pistes d'amélioration sur la lisibilité de ce bout de code (destiné à un tuto dvp). Ou s'il existe des souxieries classique sur ce pb. ?

En gros j'ai un générateur next_item qui prend en entrée un état l et un mouvement i et qui renvoi le prochain mouvement. Et je construit dans all_next_items tous les mouvements succesifs possibles (jusqu'à mouvement d'arrêt de l'itération).

Merci d'avance.

[Jedai]

Voyons, en conservant nextMove (traditionnellement, on utilise plutôt le CamelCase en Haskell, donc si tu pouvais garder ça ce serait pas mal pour un tutoriel, également utiliser des noms plus explicites pour tes arguments serait un plus), on pourrait faire :

Code :

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

allNextMoves state = tail . takeWhile (/= (-1,-1)) . iterate (nextMove state) $ (0,0)

(takeWhile et iterate sont tous deux dans le Prelude)

Si tu fais un tutoriel pour dvp en Haskell, n'hésite pas à me demander conseil ou à me montrer ton code.

--
Jedaï

[mchk0123]

Merci beaucoup pour cette aide précieuse, (pas de livres sous la main, donc tutos Haskell seulement snif.). J'ai commencé Haskell il y a 2 jours, donc c'est vraiment le tout début début ; et je n'ai pas encore plongé dans le manuel de référence.

C'est pour la rédaction d'un tuto d'introduction à l'IA sur les jeux. Les exemples pourraient être partiellement ou totalement en Haskell, mais rien n'ai encore arrêté pour l'instant, le choix est à l'étude collective. Si tu veux, j'ai ouvert un post d'avancement du tuto ; tu pourra te faire une idée du sujet, et du contenu. J'y mettrai aussi les exemples de code.

En tout cas merci pour ta proposition de coup de main.

Et merci pour ta solution, j'était tombé en plein dans le NIH.

[kaukau]

mchk0123, j'ai traduit ce tutoriel qui est très instructif:
http://corentin-dupont.developpez.co...c-programmers/

[mchk0123]

Super nouvelle,

J'ai déjà lus plusieurs tutoriels, dont celui-ci. Par contre impossible de me rappeller si je l'ai lu en Anglais ou en Français (ma mémoire défaille, je vais devoir m'acheter une nouvelle barrette).

En tout cas ça servira grandement aux nouveaux débutants.

Je vais en profiter pour poser une question toute bête :

- est-ce qu'il existe un moyen de "débugger" un programme Haskell en insérant un peu partout des PutStrLn pour afficher des informations ?

J'ai déjà essayé mais je me suis heurté au "nomadisme" (def: action d'utiliser le concept de nomades ; attention à ne pas confondre avec les habitants du desert ;-)). Ceci dit j'arrive bien à faire des affichage dans le main, mais si on doit propager explicitement le type IO à toutes les fonctions qui utilisent les E/S, ça me semble un peu lourd.

Je suis sur qu'il doit surement exister une solution à ce type de situation. Mais je suis vraiment trop booké pour plonger dans les tutoriels avancés (surtout ceux en anglais) pour l'instant.

[Jedai]

Ce n'est pas "nomades", c'est "monades".
Par ailleurs pour faire ce que tu demandes, tu peux utiliser trace de Debug.Trace.
Une meilleure idée pourrait être d'utiliser le débuggueur intégré à ghci, il est pas mal.

--
Jedaï

[Garulfo]

[...]
Une meilleure idée pourrait être d'utiliser le débuggueur intégré à ghci, il est pas mal.

Il y a de la doc de celui-ci ?
En général je dévermine mes programmes fonctionnels avec les traces.

[Jedai]

Il y a de la doc de celui-ci ?

Oui, tu as de la doc dans le manuel de GHC, ainsi que quelques exemples sur des blogs.
(NB : OCaml a un excellent debuggueur également)

--
Jedaï

[mchk0123]

Par ailleurs pour faire ce que tu demandes, tu peux utiliser trace de Debug.Trace.
Une meilleure idée pourrait être d'utiliser le débuggueur intégré à ghci, il est pas mal.

Merci encore pour ces 2 solutions. Personnellement j'utiliserai soit l'un soit l'autre selon contexte.

J'ai vraiment l'impression de poser des questions de base mais il faut dire qu'entre les tutoriels et la doc. de référence, il y a un gap important.
Je vais faire part de mes impressions de débutant, en espérant que cela soit utile à la communauté devp.com d'Haskell :

Les tutoriels nous prennent en main étape par étape, une idée après l'autre. Par contre pour se repérer dans la documentation c'est une autre affaire. Chaque page HTML fait au moins au 20aine d'écrans, ça va quand on maitrise bien le langage, mais c'est vraiment trop long pour une initiation intermédaire.

Ce qui manque cruellement ce sont :
- des pages de résumé (< 3 écrans) sous forme arborescente (comme dans la documentation Python) pour aller du plus général au plus particulier, même si celles-ci ne couvrent pas toute l'étendue du langage
- des pages d'index des liens courants dans une frame gauche (comme dans java doc)
- une FAQ en Français pour reprendre des question/réponse comme celle-ci sur le debug / tracage

[Jedai]

- une FAQ en Français pour reprendre des question/réponse comme celle-ci sur le debug / tracage

Ca ça pourrait être une bonne idée, je vais lancer un post auquel vous êtes invités à contribuer.

--
Jedaï