Here is my first stab at this. README pasted below.

https://github.com/Hal9000/elixir_random

Comments and critiques are welcome.

Thanks,
Hal

The Random module is based on Erlang’s rand module. (See http://erlang.org/doc/man/rand.html ).
This in turn is a newer replacement for Erlang’s deprecated random.

All functionality of rand is preserved here. The primary differences are:

• The preferred function name is rand (although uniform and normal will still work, for people accustomed to those).
• rand takes a parameter :normal for normal-distribution results.
• The _s functions are unnecessary, as state is passed (as needed) by means of an optional parameter.
• Any function that accepts a state also returns the new state (second item in tuple); other functions simply return a number.
• A distinction is made between seed and seed3 (the latter of which takes a tuple of three integers rather than a state).
• The functions export_seed and export_seed_s are not really needed any longer.
• The rand function can take a range, e.g. rand(50..60).
• The Random module adds sample (which takes a second parameter, a number defaulting to 0); this calls Enum.take_random which works on any enumerable.
• The Random module adds shuffle (which simply calls Enum.shuffle and thus can take any enumerable.
• The PRNG is seeded on module load (default algorithm is :exsplus just as with :rand); you may of course reseed at any time.

Examples

x = Random.rand             # Random number between 0.0 and 1.0

x = Random.rand(:normal)    # Random number in normally-distributed range, -1..1 is one sigma

n = Random.rand(5)          # Random integer between 1 and 5

n = Random.rand(10..20)     # Random integer between 10 and 20

state = Random.seed(:exsplus)               # Use the explus algorithm (default), Xorshift116+, 58 bits, period = 2^116-1

state = Random.seed(:exs64)                 # Use the exs64 algorithm, Xorshift64, 64 bits, period = 2^64-1

state = Random.seed(:exs1024)               # Use the exs1024 algorithm, Xorshift1024, 64 bits, period = 2^1024-1

state = Random.seed3(:exsplus, {1, 2, 3})   # Seed using the three integers 1, 2, 3

state = Random.seed(:exsplus, state)        # Seed using the specified state

x = Random.uniform                          # Same as Random.rand

x = Random.normal                           # Same as Random.rand(:normal)

{x, state} = Random.rand(state)             # Specify state and return number and a new state

{x, state} = Random.rand(:normal, state)    # Specify state and return number (normal distribution) and new state

item = Random.sample(enum)                  # Grab one random item from any enumerable (such as a list)

list = Random.sample(enum, 3)               # Grab 3 random items from any enumerable (such as a list)

list = Random.shuffle(enum)                 # Randomize (shuffle) an enumerable (such as a list)

Notes

The sample and shuffle functions do not have state-sensitive variants.