random -package:random

Create a random Seed using an effectful source of randomness.

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.

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 module is provided for backwards compatibility, and simply re-exports Control.Monad.Random.Lazy.

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.

Random monads, passing a random number generator through a computation. This version is lazy; for a strict version, see Control.Monad.Trans.Random.Strict, which has the same interface.

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.