eoutin a écrit 3 commentaires

Ouai, j'avais pas vu pour le double post, désolé.
Pour en revenir à mon problème, j'ai bien compris que c'était bien compliqué cette histoire de monad IO.
Je vous met aussi la fonction dans laquelle je veut réutiliser ma liste mélangée aléatoirement.

data Mobile = Poids Rational | Branche Rational Mobile Mobile deriving Show

poids :: Mobile -> Rational
poids (Poids n) = n
poids (Branche _ g d) = poids g + poids d

shuffle' [] acc = return acc
shuffle' l acc =
do k <- randomRIO (0, length l - 1)
let (lead, x:xs) = splitAt k l
shuffle' (lead ++ xs) (x:acc)

shuffle :: [a] -> IO [a]
shuffle l = shuffle' l []

ranCreation :: [Rational] -> Mobile
ranCreation [] = (Poids 0)
ranCreation [p] = (Poids p)
ranCreation li = let m = splity li; x = (fst m); y = (snd m); k = (poids (ranCreation y))/(poids (ranCreation x) + poids (ranCreation y))
in ((Branche k) (ranCreation x) (ranCreation y))

splity :: [a] -> ([a],[a]) --Fonction qui découpe une liste en 2
splity x = let n = div (length x) 2
in splitAt n x


Ma fonction ranCreation me permettrai donc de créer des mobiles aléatoires, en mélangeant à chaque fois les listes de poids.

Merci à vous.

Bonjour,
j'ai un nouveau soucis, cette fois c'est une histoire de IO.
j'ai une fonction shuffle qui mélange une liste donnée (de type [a]) et qui renvoie cette liste mélangée alétoirement (de type IO [a]).
Cependant, je veux utiliser cette fonction shuffle dans une autre fonction (qui ne prend pas de IO [a] en argument mais [a]).
Je voudrais donc en quelque sorte convertir xs :: IO [Integer] en xs :: [Integer] pour ne pas avoir de soucis dans la fonction qui utilise shuffle.

Voici ma fonction shuffle :

shuffle' [] acc = return acc
shuffle' l acc =
do k <- randomRIO (0, length l - 1)
let (lead, x:xs) = splitAt k l
shuffle' (lead ++ xs) (x:acc)

shuffle :: [a] -> IO [a]
shuffle l = shuffle' l []


Merci.

Ok, merci beaucoup, c'est bien ce que je cherchais.
Au revoir.