Am Dienstag 09 Juni 2009 15:57:24 schrieb Magnus Therning:

On Tue, Jun 9, 2009 at 2:52 PM, ptrash wrote:

...

Hmm...it am not getting through it. I just want to generate a random number and then compare it with other numbers. Something like

r = randomRIO (1, 10) if (r > 5) then... else ...

You have to do it inside the IO monad, something like

myFunc = do r <- randomRIO (1, 10 if r > 5 then ... else ...

/M

Or make the source of the pseudo-random numbers explicit: import System.Random function :: (RandomGen g, Random a) => g -> other args -> result function gen whatever | r > 5 = blah newgen something | r < 3 = blub newgen somethingElse | otherwise = bling where (r,newgen) = randomR (lo,hi) gen and finally, when the programme is run: main = do args <- getArgs sg <- getStdGen foo <- thisNThat print $ function sg foo If you're doing much with random generators, wrap it in a State monad.

2009/6/9 Krzysztof Skrzętnicki

On Tue, Jun 9, 2009 at 16:14, Daniel Fischer wrote:

...

If you're doing much with random generators, wrap it in a State monad.

To avoid reinventing the wheel one can use excellent package available on Hackage: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/MonadRandom

Please do! Prefer MonadRandom to explicit generator passing: http://lukepalmer.wordpress.com/2009/01/17/use-monadrandom/. Keep computations in MonadRandom, and pull them out with evalRandomIO at the last second. Luke

http://hackage.haskell.org/cgi-bin/hackage-scripts/package/MonadRandom

...

The die function simulates the roll of a die, picking a number between 1 and 6, inclusive, and returning it in the Rand monad. Notice that this code will work with any source of random numbers g.

die :: (RandomGen g) => Rand g Int die = getRandomR (1,6)

The dice function uses replicate and sequence to simulate the roll of n dice.

dice :: (RandomGen g) => Int -> Rand g [Int] dice n = sequence (replicate n die)

To extract a value from the Rand monad, we can can use evalRandIO.

main = do values <- evalRandIO (dice 2) putStrLn (show values)

Best regards

Krzysztof Skrzętnicki _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

Hello jerzy, Tuesday, June 9, 2009, 8:23:04 PM, you wrote:

Please, tell him first about random streams, which he can handle without IO. Or, about ergodic functions (hashing contraptions which transform ANY parameter into something unrecognizable). When he says : "I know all that", THEN hurt him badly with monads.

i think that for someone coming from imperative programming teeling about IO monad is the easiest way. and then he will learn how to do it FP way -- Best regards, Bulat mailto:Bulat.Ziganshin@gmail.com

On Tue, 9 Jun 2009, Bulat Ziganshin wrote:

Hello jerzy,

Tuesday, June 9, 2009, 8:23:04 PM, you wrote:

...

Please, tell him first about random streams, which he can handle without IO. Or, about ergodic functions (hashing contraptions which transform ANY parameter into something unrecognizable). When he says : "I know all that", THEN hurt him badly with monads.

i think that for someone coming from imperative programming teeling about IO monad is the easiest way. and then he will learn how to do it FP way

I came from imperative programming and never wanted to use randomIO, because it forces you to IO and randomsIO is not lazy.

Hmm...I use the Eclipse Plugin. And this row is marked as error. Then where is the error? -- View this message in context: http://www.nabble.com/Convert-IO-Int-to-Int-tp23940249p23960827.html Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

On Wed, Jun 10, 2009 at 12:55 PM, ptrash wrote:

Hi,

I have tried on the console to write

x <- randomRIO(1,10) :t x

Everythings fine and the type of x is x :: Integer

The type of x *in the context of an IO computation* is Integer. GHCi is basically an IO computation. Another example: foo :: Integer -> Integer foo x = x+1 main :: IO () main = do x <- randomRIO (1,10) print (foo x) This is fine. In the context of the IO computation "main", x is bound to the result of "randomRIO (1,10)", and you can pass it to functions expecting Integer values (not IO Integer!). So in this way, and this way only, you can access the Integer returned by an IO action. You can *not* access the Integer returned by an IO action from within a normal function, *only* by by binding it to a variable (with "<-") inside *another IO action*. I'm not sure what text you're using to learn Haskell, but a very basic and fundamental property of Haskell (and indeed 99% of why it's cool, IMO) is that code which does side effects (like reading from a global random number seed), and code which does not do side effects (i.e. functions which always return the same result given the same input) are kept extremely separate. This appears to be the source of your confusion. It's simply not possible to do side effect inside a normal function, just like it's not possible to cast an arbitrary integer to a pointer in Java - the language is designed to not require it, and the benefits of being able to trust that your program obeys certain properties are worth it.

randomList :: Int -> [Integer] randomList 0 = [] randomList n = do r <- randomRIO (1, 10) r:randomList(n-1)

In this code you're trying to do side effects from within a pure function. This is *not* allowed. You must either make randomList an IO action (i.e returning IO [Integer]), or remove any impurities from its implementation. For example you can make randomList take a randon number generator and use the random number generator to produce random values: randomList :: (RandomGen g) -> Int -> g -> [Integer] randomList 0 _ = [] randomList n generator = r : randomList (n-1) newGenerator where (r, newGenerator) = randomR (1,10) generator This is totally pure, since if you pass in the same random number generator multiple times, you'll get the exact same result. Note that randomR returns a random values and a new random number generator (you wouldn't want to pass along the same one in the recursive call to randomList as that would give you an identical random number each time you use it!). So where do you get the random number generator from? Well one way is to make your own using "mkStdGen", which produces one from a seed (it will give you an identical one given an identical seed). Another way is to use "newStdGen" to generate one from within an IO action: main :: IO () main = do generator <- newStdGen print ( randomList 10 generator ) The point, though, is that things having side effects (such as newStdGen) can only be used in the context of something else having side effects. So the "IO" type is "contagious", as soon as you use it in a function, then that function must also return IO, and so on for anything using *that* function and son. -- Sebastian Sylvan +44(0)7857-300802 UIN: 44640862

On Wed, Jun 10, 2009 at 2:10 PM, Sebastian Sylvan < sebastian.sylvan@gmail.com> wrote:

On Wed, Jun 10, 2009 at 2:08 PM, Sebastian Sylvan < sebastian.sylvan@gmail.com> wrote:

...

randomList :: (RandomGen g) -> Int -> g -> [Integer]

Just spotted this typo, it should be:

randomList :: (RandomGen g) = Int -> g -> [Integer]

There may be other minor typos as I don't have a compiler handy.

Oh come on! randomList :: (RandomGen g) => Int -> g -> [Integer] -- Sebastian Sylvan +44(0)7857-300802 UIN: 44640862

This stuff is tricky for most newcomers I suspect (it was for me) x <- randomRIO(1,10) is "temporarilly" pulling the Integer you've named "x" out of the IO Integer it came from. You can think of the console as being an input/output stream inside the IO monad, which is why it is allowed there. The fact is these are equivalent do x <- randomRIO(1,10) x : <expression> and randomRIO(1,10) >>= (\x -> x:>=) is the "bind" operator for Monads and it allows you to do things like sequence an IO operation or action, then examine the contents returned by that IO action, possibly performing some transformation on it with another function. x:<expression> is the function that takes a value "x" and applies the cons function (:) to build a list with <expression>. The problem is that the type system of Haskell will not allow this because the bind function (which is used by the "do" syntax behind the scenes) is of type: (>>=) :: (Monad m) => m a -> (a -> m b) -> m b Which states that the first argument to (>>=) is a Monad a, or in your case "randomRIO(1,10)" which is of type "IO Integer" IO being the "m" part of "m a" and "Integer" being the "a" part of "m a". What comes next is your consing function of (x : <expression>). This is of type [Integer]. So you failed to give it a function of type (a -> m b). (a -> m b) says that the input type to that function must be the same as the "contained" value of the first argument to (>>=) (because they're both of type 'a'). The "m b" part says that you must use the *same Monad* you used in the first parameter to (>>=) which is IO, not []. However the 'b' part says you can convert things of one type 'a' to things of another type 'b'. This is legal: randomRIO(1,10) >>= return (x : <expression>) However what you've got now is not a List of Integers ([Integer]) but an IO [Integer]. Because of the type of (>>=), you are not going to ever permanently escape that IO "wrapper" around your values you're interested in. The "return" is a function of the class Monad, that takes a value, and "wraps it up" in a monad. Based on the (>>=) function's type, the system can infer that you meant the IO monad here. You can even test this at the console: Prelude System.Random> randomRIO(1,10) >>= (\x -> return (x:[99])) [7,99] Prelude System.Random> randomRIO(1,10) >>= (\x -> return (x:[99])) [6,99] Prelude System.Random> randomRIO(1,10) >>= (\x -> return (x:[99])) [2,99] Prelude System.Random> :t randomRIO(1,10) >>= (\x -> return (x:[99])) randomRIO(1,10) >>= (\x -> return (x:[99])) :: (Num t, Random t) => IO [t] vs "randomRIO(1,10) >>= (\x -> x:[99])" Which doesn't pass the type checking of the system because [] is not the same monad as IO. Perhaps you'd do well for yourself by reading "Learn You A Haskell"? I've found it to be pretty darned good at explaining lots of haskell to newcomers. Dave On Wed, Jun 10, 2009 at 4:55 AM, ptrash wrote:

Hi,

I have tried on the console to write

x <- randomRIO(1,10) :t x

Everythings fine and the type of x is x :: Integer

Now I have tried to write a Method which gives me a Number of random numbers the same way but it doesn't work.

randomList :: Int -> [Integer] randomList 0 = [] randomList n = do r <- randomRIO (1, 10) r:randomList(n-1)

It says Couldn't match expected type `IO t' against inferred type `[t]' r <- randomRIO (1,10) causes an error. But why does it work on the console? Is there a way to solve it another way? -- View this message in context: http://www.nabble.com/Convert-IO-Int-to-Int-tp23940249p23960652.html Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

_______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe