Random number in Haskell [duplicate]

by

This is a common barrier for new Haskell programmers. You want to escape IO, and it takes a while to figure out the best way to do so. The Learn You A Haskell tutorial has a good explanation of one way to generate random numbers using the state monad, but it still has to be seeded using getStdGen or newStdGen, which are in IO.

For simple cases you can just do something like

myPureFunction :: Float -> Float
myPureFunction x = 2 * x

main :: IO ()
main = do
    -- num :: Float
    num <- randomIO :: IO Float
    -- This "extracts" the float from IO Float and binds it to the name num
    print $ myPureFunction num

So you see, you can get your random number in main, then pass that value to a pure function that does the processing.

You may be asking yourself why there’s all this work to generate random numbers in Haskell. There are numerous good reasons, most of which have to do with the type system. Since generating random numbers requires modifying the state of the StdGen in the operating system, it has to live inside IO, otherwise you could have a pure function that gives you different results each time.

Imagine this contrived scenario:

myConstant :: Int
myConstant = unsafePerformIO randomIO

blowUpTheWorld :: IO ()
blowUpTheWorld = error "Firing all the nukes"

main :: IO ()
main = do
    if even myConstant
        then print "myConstant is even"
        else blowUpTheWorld

If you ran this a few times, chances are that you would end up “firing all the nukes”. Obviously, this is bad. myConstant should be, well, constant, but each time you run the program you’d get a different value. Haskell wants to guarantee that a pure function will always return the same value given the same inputs.

It may be annoying right now, but it’s a powerful tool in the functional programmer’s kit.

More Related Contents:

  1. How can I generate different random values in Haskell?
  2. Sampling sequences of random numbers in Haskell
  3. making permutation from two list but not using full number [closed]
  4. Answer to this Haskell expression [closed]
  5. Haskell, tuple (double, string) [closed]
  6. scrambling txt file using compiler [closed]
  7. Applicatives compose, monads don’t
  8. A Haskell function of type: IO String-> String
  9. Haskell: Parse error in pattern
  10. IO happens out of order when using getLine and putStr
  11. What is indexed monad?
  12. What does $ mean/do in Haskell?
  13. Why are polymorphic values not inferred in Haskell?
  14. Cabal not installing dependencies when needing profiling libraries?
  15. Library function to compose a function with itself n times
  16. Should do-notation be avoided in Haskell?
  17. Why doesn’t Haskell sequence these IO actions properly?
  18. Why doesn’t this function work if I use “[xs]” instead of “xs”?
  19. What is fusion in Haskell?
  20. Typeclass constraints on data declarations
  21. What does the `forall` keyword in Haskell/GHC do?
  22. How does deriving work in Haskell?
  23. Foldr/Foldl for free when Tree is implementing Foldable foldMap?
  24. What characters are permitted for Haskell operators?
  25. Converting IO Int to Int
  26. Convert String to Integer/Float in Haskell?
  27. Haskell – depth for each node in binary tree using Reader monad
  28. Haskell: Where vs. Let
  29. How does the ST monad work?
  30. An example of a Foldable which is not a Functor (or not Traversable)?

Leave a Comment