random -package:MonadRandom

Pseudo-random number generation This package provides basic pseudo-random number generation, including the ability to split random number generators.

System.Random: pure pseudo-random number interface

In pure code, use System.Random.uniform and System.Random.uniformR from System.Random to generate pseudo-random numbers with a pure pseudo-random number generator like System.Random.StdGen. As an example, here is how you can simulate rolls of a six-sided die using System.Random.uniformR:
>>> let roll = uniformR (1, 6)        :: RandomGen g => g -> (Word, g)

>>> let rolls = unfoldr (Just . roll) :: RandomGen g => g -> [Word]

>>> let pureGen = mkStdGen 42

>>> take 10 (rolls pureGen)           :: [Word]
[1,1,3,2,4,5,3,4,6,2]
See System.Random for more details.

System.Random.Stateful: monadic pseudo-random number interface

In monadic code, use System.Random.Stateful.uniformM and System.Random.Stateful.uniformRM from System.Random.Stateful to generate pseudo-random numbers with a monadic pseudo-random number generator, or using a monadic adapter. As an example, here is how you can simulate rolls of a six-sided die using System.Random.Stateful.uniformRM:
>>> let rollM = uniformRM (1, 6)                 :: StatefulGen g m => g -> m Word

>>> let pureGen = mkStdGen 42

>>> runStateGen_ pureGen (replicateM 10 . rollM) :: [Word]
[1,1,3,2,4,5,3,4,6,2]
The monadic adapter System.Random.Stateful.runStateGen_ is used here to lift the pure pseudo-random number generator pureGen into the System.Random.Stateful.StatefulGen context. The monadic interface can also be used with existing monadic pseudo-random number generators. In this example, we use the one provided in the mwc-random package:
>>> import System.Random.MWC as MWC

>>> let rollM = uniformRM (1, 6)       :: StatefulGen g m => g -> m Word

>>> monadicGen <- MWC.create

>>> replicateM 10 (rollM monadicGen) :: IO [Word]
[2,3,6,6,4,4,3,1,5,4]
See System.Random.Stateful for more details.
The same as randomR, but using a default range determined by the type:
  • For bounded types (instances of Bounded, such as Char), the range is normally the whole type.
  • For floating point types, the range is normally the closed interval [0,1].
  • For Integer, the range is (arbitrarily) the range of Int.
The same as randomR, but using a default range determined by the type:
  • For bounded types (instances of Bounded, such as Char), the range is normally the whole type.
  • For floating point types, the range is normally the closed interval [0,1].
  • For Integer, the range is (arbitrarily) the range of Int.
Create a random Seed using an effectful source of randomness.
Pick a random element, using reservoir sampling
Pick a random element of the list.
Set random playing.
Toggle random mode.
Generate a random bytestring of length n. The PRNG is seeded from the system randomness source.
ioProperty $ ((fromIntegral n ===) . B.length) <$> random n
n > 4 ==> ioProperty $ (/=) <$> random n <*> random n
Generate a single random UUID.
Return hosts in random order.
This library deals with the common task of pseudo-random number generation.
The class of types for which random values can be generated. Most instances of Random will produce values that are uniformly distributed on the full range, but for those types without a well-defined "full range" some sensible default subrange will be selected. Random exists primarily for backwards compatibility with version 1.1 of this library. In new code, use the better specified Uniform and UniformRange instead.
PRNG services See http://www.openssl.org/docs/crypto/rand.html For random Integer generation, see OpenSSL.BN
This module is for instantiating cryptographicly strong determinitic random bit generators (DRBGs, aka PRNGs) For the simple use case of using the system random number generator (Entropy) to seed the DRBG:
g <- newGenIO
Users needing to provide their own entropy can call newGen directly
entropy <- getEntropy nrBytes
let generator = newGen entropy
Flexible modeling and sampling of random variables. The central abstraction in this library is the concept of a random variable. It is not fully formalized in the standard measure-theoretic language, but rather is informally defined as a "thing you can get random values out of". Different random variables may have different types of values they can return or the same types but different probabilities for each value they can return. The random values you get out of them are traditionally called "random variates". Most imperative-language random number libraries are all about obtaining and manipulating random variates. This one is about defining, manipulating and sampling random variables. Computationally, the distinction is small and mostly just a matter of perspective, but from a program design perspective it provides both a powerfully composable abstraction and a very useful separation of concerns. Abstract random variables as implemented by RVar are composable. They can be defined in a monadic / "imperative" style that amounts to manipulating variates, but with strict type-level isolation. Concrete random variables are also provided, but they do not compose as generically. The Distribution type class allows concrete random variables to "forget" their concreteness so that they can be composed. For examples of both, see the documentation for RVar and Distribution, as well as the code for any of the concrete distributions such as Uniform, Gamma, etc. Both abstract and concrete random variables can be sampled (despite the types GHCi may list for the functions) by the functions in Data.Random.Sample. Random variable sampling is done with regard to a generic basis of primitive random variables defined in Data.Random.Internal.Primitives. This basis is very low-level and the actual set of primitives is still fairly experimental, which is why it is in the "Internal" sub-heirarchy. User-defined variables should use the existing high-level variables such as Uniform and Normal rather than these basis variables. Data.Random.Source defines classes for entropy sources that provide implementations of these primitive variables. Several implementations are available in the Data.Random.Source.* modules.