Discussion :

[limestrael]

Je me demandais, quelle est la méthode la plus efficace pour faire une boucle principale se répétant jusqu'à la fin du programme (en gros là où en impératif on aurait un while(continuer) { ... }).
Genre j'ai une fonction qui doit être répétée :

Code :

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

1
2
3
4
5
6
7
loop :: IO ()
loop = do
    drawSomething window x
    drawSomething window y
    handleEvents window
    updateWindow window
    etc.

Il y a bien 'forever loop', mais là pas moyen d'arrêter le programme sauf en envoyant une exception (beurk).
On peut aussi imaginer que loop est de type IO Bool (True si on continue, False si on arrête de répéter), ou bien IO (Maybe a) (Just x si on contiue et Nothing si on arrête) et dans ce cas on peut faire une récursion maison pour répéter la fonction en testant sa valeur de retour, mais vu que ce qui je cherche à faire est super commun je trouverai ça bizarre si il n'y a rien de prévu en Haskell pour faire ça et que je me retrouve obligé de faire une récursion.

[Jedai]

C'est facile à coder par soi-même, et la récursion est une solution simple au problème :

Code :

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

1
2
3
4
stuff = do
  ...
  ...
  when shouldLoop stuff

Si tu veux vraiment un combinateur :

Code :

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

1
2
loop :: IO Bool -> IO ()
loop action = action >>= flip when (loop action)

Je ne sais pas trop pourquoi ce combinateur n'est pas dans Control.Monad, peut-être parce qu'il paraissait trivial et que la condition d'arrêt ("IO (Maybe a) -> IO a" ou "IO (Maybe a) -> IO ()" ou "IO Bool -> IO ()") n'était pas évidente à choisir ?

--
Jedaï

[limestrael]

Oui, c'est très exactement comme cela que j'avais fait.
Une recursion est effectivement très facile à faire, mais je me demandais juste si cela ne posait pas de problème de pile...

[Jedai]

Non aucun problème de pile, le modèle d'exécution d'Haskell (ou plutôt celui choisi par GHC dans les limites imposées par le Report) est tel que cette pseudo-récursion (action n'est pas une fonction) n'entrainera pas d'accumulation sur la pile.

--
Jedaï

[limestrael]

Ok !
Mais est-ce le cas pour toutes les monades ou bien uniquement pour IO ?

Par exemple si le code était :

Code :

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

1
2
loop :: (Monad m) => m Bool -> m ()
loop action = action >>= flip when (loop action)

GHC se rendrait-il aussi compte qu'il n'a rien à accumuler sur la pile ?

[Jedai]

Ce n'est une question de se rendre compte ou pas, c'est une conséquence inévitable du modèle d'évaluation d'Haskell et de la définition de (>>=) et (>>) dans le cas d'IO et a priori de toutes les autres instances de Monad suivant les lois des monades.

--
Jedaï

[limestrael]

Ok