How can I generate different random values in Haskell?

by

There are two problems with your code:

  1. You are calling unsafePerformIO, but explicitly violating the contract of that function. It is on you to prove that the thing you provide to unsafePerformIO is actually pure, and the compiler is within its rights to act as if that’s the case, and here it is definitely not.
  2. You are not carefully tracking the updated random number generator state after using it. Indeed, it is not possible to do this correctly with randomRs; if you use randomRs, then to a first approximation, that must be the last randomness your program needs.

The simplest fix to both of these is to admit that you really, truly are doing IO. So:

import Control.Monad
import System.Random

randomize :: String -> IO String
randomize "random" = replicateM 10 (randomRIO ('a', 'z'))
randomize other = pure other

Try it out in ghci:

> traverse randomize ["random", "foo", "random", "bar", "random", "boo"]
["xytuowzanb","foo","lzhasynexf","bar","dceuvoxkyh","boo"]

There is no call to unsafePerformIO, and so no proof burden to shirk; and randomRIO tracks the updated generator state for you in a hidden IORef, and so you correctly continue advancing it on each call.

More Related Contents:

  1. Random number in Haskell [duplicate]
  2. Sampling sequences of random numbers in Haskell
  3. `String’ is applied to too many type arguments
  4. How do I define Lisp’s apply in Haskell?
  5. Operating on a return from a Maybe that contains “Just”
  6. Is there a Haskell idiom for updating a nested data structure?
  7. What’s so bad about Lazy I/O?
  8. Positive integer type
  9. Explicitly import instances
  10. How to compare two functions for equivalence, as in (λx.2*x) == (λx.x+x)?
  11. Why do 3 and x (which was assigned 3) have different inferred types in Haskell? [duplicate]
  12. How do I use fix, and how does it work?
  13. Splitting list into a list of possible tuples
  14. List of different types?
  15. What is Levity polymorphism
  16. How to infer the type of an expression manually
  17. Understanding the Haskell as-pattern
  18. Haskell: How to create most generic function possible that applies a function to tuple items
  19. Can you overload + in haskell?
  20. Non-Trivial Lazy Evaluation
  21. Is there a way to see the list of functions in a module, in GHCI?
  22. Haskell GHC: what is the time complexity of a pattern match with N constructors?
  23. Creating unique labels in Haskell
  24. What’s the status of multicore programming in Haskell?
  25. Tools for analyzing performance of a Haskell program
  26. How does foldr work?
  27. How to catch a no parse exception from the read function in Haskell?
  28. Why does OCaml sometimes require eta expansion?
  29. Explanation of “tying the knot”
  30. Return specific type within Haskell

Leave a Comment