Discussion :

[kg2007]

Bonjour,

Je découvre petit à petit Haskell et me voila confronté aux monads ...

Considérons une première fonction :

Code :

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

1
2
3
foo :: State Bool ()
foo = do b <- get
             if (b == True) then foo else put b

Maintenant, je voudrais effectuer la même chose mais le type de la fonction est le suivant:

Code :

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

foo2 :: IO (State Bool ())

Et la, je bloque.
Pourriez vous m'aider à itérer une fonction de ce type ?

Merci d'avance.

[Alp]

Hmm...
Qu'est-ce qui te pose concrètement problème ?
Simplement de devoir plonger ta "fonction" (et donc son appel à elle-même) dans la monade IO ?

[kg2007]

Je ne cherche pas à "plonger" la fonction foo dans IO.

La fonction foo est récursive. La condition d'arrêt dépend de la valeur contenu dans la monade State.
Dans le même esprit, je cherche à écrire une fonction recursive du type foo2, dont la condition d'arrêt dépend de la valeur contenue dans State qui est elle même est dans IO.

J'espère être plus clair

[Alp]

Tu as essayé, fait une tentative déjà ?

[kg2007]

Oui, j'ai essayé.
Mais j'ai toujours "une monade de trop".

Code :

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

1
2
3
4
5
 
foo2 :: IO ( State Bool ())
foo2 = do l <- getChar c
          return $ do b <- get
                      if b then put b else foo2

Et évidement, le type attendu pour l'expression dans le else est State Bool () alors que le type est celui de foo2.

Voila où j'en suis.

Noter que ce code est un exemple de ma situation. Il ne faut donc pas lui preter la moindre utilité, mais je pense qu'il reflète bien mon problème réel.

[Garulfo]

Ta situation n'est vraiment pas clair.
Par exemple le premier code ne peut pas marche car « l » n'est pas déclaré. M'est avis que ton exemple est aussi plus compliqué que celui que tu nous montres. Il est difficile de te répondre lorsqu'on ne connait pas vraiment le problème. Tu sembles dire que c'est une erreur de typage. Il faudrait donc voir ta fonction.

[Alp]

Oui, j'ai essayé.
Mais j'ai toujours "une monade de trop".

Code :

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

1
2
3
4
5
 
foo2 :: IO ( State Bool ())
foo2 = do l <- getChar c
          return $ do b <- get
                      if b then put b else foo2

Et évidement, le type attendu pour l'expression dans le else est State Bool () alors que le type est celui de foo2.

Voila où j'en suis.

Noter que ce code est un exemple de ma situation. Il ne faut donc pas lui preter la moindre utilité, mais je pense qu'il reflète bien mon problème réel.

Es-tu sûr d'avoir mis le return au bon endroit ?
En effet, c'est le put b qui déterminera le type de ton expression. Peut-être que cela peut t'aider.

Garulfo > pas besoin de déclarer l ni b avant dans ce genre situations en Haskell, ils résultent d'une action dans une monade.

[kg2007]

Par exemple le premier code ne peut pas marche car « l » n'est pas déclaré.

Navré, j'ai corrigé.

Un autre exemple:
Le module Monad.Loops (http://hackage.haskell.org/packages/...3AiterateWhile) définit la fonction iterateWhile ayant le type suivant:

Code :

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

iterateWhile :: Monad m => (a -> Bool) -> m a -> m a

Je cherche à écrire un fonction ayant le même comportement mais dont le type est le suivant:

Code :

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

iterateWhileBis :: (Monad m,Monad n) => (a -> Bool) -> m (n a) -> m (n a)

Pourriez vous essayer d'écrire une telle fonction ?

[Alp]

Il n'y a pas besoin.

Dans le cas de iterateWhile, tu as m a. Mais ici, a peut très bien être un certain type n a où n est une autre monade que M.

Bref, ça devrait aller

[kg2007]

Ce n'est pas tout à fait pareil.

Le signature de la fonction qu tu evoques est la suivante:

Code :

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

(Monad m,Monad n) => (n a -> Bool) -> m (n a) -> m (n a)

Et une fonction de signature

Code :

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

n a -> Bool

ce n'est pas évident ...

La signature de la fonction que je cherche à réaliser est la suivante:

Code :

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

(Monad m,Monad n) => (a -> Bool) -> m (n a) -> m (n a)

[Jedai]

Je ne cherche pas à "plonger" la fonction foo dans IO.

La fonction foo est récursive. La condition d'arrêt dépend de la valeur contenu dans la monade State.
Dans le même esprit, je cherche à écrire une fonction recursive du type foo2, dont la condition d'arrêt dépend de la valeur contenue dans State qui est elle même est dans IO.

J'espère être plus clair

Ton type est incorrect, ici ce que tu as c'est une action IO qui retourne une action dans la monade State... Il n'y a donc pas d'état persistant au fil des itérations de cette fonction comme c'est sans doute ton objectif.

Pour faire ça il faut utiliser les transformateurs de monades :

Code :

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

1
2
3
4
5
foo2 :: StateT Bool IO ()
foo2 = do 
   l <- liftIO $ getChar
   b <- get
   if b then put b else foo2

(Non que cette fonction en particulier ait un intérêt quelconque... Je préfèrerais que tu nous dises ce que tu essaies réellement de faire)

--
Jedaï

[kg2007]

J'avais pensé à utiliser des transformateurs, mais cela me gène car je dois "intégrer" IO dans l'état alors que celui ci n'en dépend pas.

Pour préciser mon application:
J'ai un état. J'applique des opérations sur cet état. Jusqu'ici tout va bien. Mais ensuite je souhaiterais appliquer ces opérations dans un ordre aléatoire, d'où l'apparition de IO.
Les opérations modifiant l'état ne nécessite pas d'IO, seul l'ordre dans lequel je les applique en dépend, c'est pourquoi le type StateT n'est pas nécessaire.

En pseudo code.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
op1 :: State Bool ()
op1 = return ()
 
op2 :: State Bool ()
op2 = return ()  -- En vrai, on fait des choses ...
 
run :: IO (State Bool ())
run = do s <- newStdGen
             appliquer op1 ou op2 aléatoirement
             si l'état ne convient pas reapliquer run

Voila un peu plus à quoi ressemble mon application.


Après reflexion ... je crois que l'exemple iterateWhileBis illustre bien le problème.
Est-il possible d'écrire une telle fonction ?
Ou est necessaire d'utiliser des transformateurs ?

[Jedai]

Pour faire de l'aléatoire, tu n'as pas besoin d'IO, tu as juste besoin d'une monade pour l'aléatoire. Quelque chose comme MonadRandom (basique, reprend les idées et l'implémentation de System.Random) ou monte-carlo (plus rapide, interface différente, nécessite la librairie GSL) ou autres (tu as des trucs assez complexes sur Hackage, capable de traiter des distributions avancées). Ensuite tu peux l'utiliser dans StateT ou utiliser le transformeur associé autour de State au choix.

NB : IO est cependant toujours nécessaire pour créer le générateur aléatoire (du moins si tu veux qu'il change d'une exécution à l'autre).

Une autre approche est de créer d'avance les valeurs aléatoires que tu utiliseras dans ton State, tu peux même en créer une quantité infinie si le nombre dont tu auras besoin n'est pas fixé au départ.

Code :

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

1
2
3
4
5
6
7
8
foo :: IO (State Int ())
foo = do
    g <- newStdGen
    return . st . randomRs (False, True) $ g
  where
    st (b:bs) = do
      modify (+1)
      if b then st bs else return ()

--
Jedaï

[Garulfo]

[...]
Garulfo > pas besoin de déclarer l ni b avant dans ce genre situations en Haskell, ils résultent d'une action dans une monade.

Vu la réponse de notre nouveau participant, il me semble que j'avais raison

J'avais l'impression que l'erreur de typage venait du «*put » mais étant donné qu'on avait peut-être une fonction bidon devant nous, il était difficile d'être définitif.

En tout cas…

[Jedai]

Vu la réponse de notre nouveau participant, il me semble que j'avais raison

J'avais l'impression que l'erreur de typage venait du «*put » mais étant donné qu'on avait peut-être une fonction bidon devant nous, il était difficile d'être définitif.

En tout cas…

Le put n'était pas responsable de l'erreur de typage, il était du type correct d'après la signature de la fonction : State Bool (). Par contre foo2 dans la seconde branche du if/then/else n'est pas du bon type : il devrait avoir le même type que "put b" mais a le type IO (State Bool ())...

--
Jedaï

[Garulfo]

Le put n'était pas responsable de l'erreur de typage, il était du type correct d'après la signature de la fonction : State Bool (). Par contre foo2 dans la seconde branche du if/then/else n'est pas du bon type : il devrait avoir le même type que "put b" mais a le type IO (State Bool ())...

--
Jedaï

Oui enfin dire que les deux ne concordent pas n'est-ce pas dire la même chose ?

Parce que la signature de la fonction est IO (State Bool()) comme tu le dis. Donc dire que c'est « du type correct d'après la signature de la fonction : State Bool () » c'est un peu contradictoire non ?

En tout cas, vu que la fonction semblait être un exemple et non LA fonction, il me semblait peu pertinent de faire une remarque là.

[kg2007]

Merci beaucoup.
Le passage par liste infinie débloque ma situation de facon acceptable.

Il faut que j'avance un peu dans mon code ... C'est pourquoi je ne peux m'attarder plus longtemps la dessus ... mais j'y reviendrai ...
car j'aimerais bien comprendre pourquoi je n'arrive pas à coder iterateWhileBis.

Merci encore,
A bientot

(PS : C'est dommage qu'il n'y ait pas un bouton +ou- résolu )

[Jedai]

Parce que la signature de la fonction est IO (State Bool()) comme tu le dis. Donc dire que c'est « du type correct d'après la signature de la fonction : State Bool () » c'est un peu contradictoire non ?

En tout cas, vu que la fonction semblait être un exemple et non LA fonction, il me semblait peu pertinent de faire une remarque là.

Il y avait un return (dans la monade IO) devant cette expression, donc le type State Bool () était bien le type correct pour cette expression d'après la signature de la fonction. Néanmoins comme tu le dis cette fonction n'était qu'un exemple et n'avait guère de sens.

car j'aimerais bien comprendre pourquoi je n'arrive pas à coder iterateWhileBis.

Le type est réalisable, mais il te manque la première pierre pour coder cette fonction : que doit-elle faire exactement ? Je ne suis pas sûr qu'il soit possible de créer une "itération" intéressante de ton point de vue avec un tel type.

--
Jedaï