Always returns an array which contains only one kind of value.

The random builder is three to five times slower than raw PRNG functions. Performance tuning is desired.

A suspected cause is that each call creates a new instance of RandomBuilder; for instance, xorshift seed and RandomBuilder (xorshiftPrng, seed) are equivalent. RandomBuilder should take only Prng function to instantiate, and random seeds should be passed outside of random computation expression like the following code.

type RandomBuilder (prng : Prng<'s>) = ...
let random prng = RandomBuilder (prng)
let xorshift = random xorshiftPrng

let state = xorshift { return! ``[0, 1)`` }
let rec randoms initialSeed =
   seq {
      let u, nextSeed = run state initialSeed  // no instantiation
      yield u
      yield! randoms nextSeed
   }

Computation expressions like draw ``[0, 1)`` into x?

See Perl's String::Random.

It may be helpful for cases such like Metropolis algorithm.

http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/JUMP/index.html

MUST.

http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/JUMP/index.html

Loops should be available in the random computation expression.

Utility function to pick up one or more random samples from an array.

Suppose we would like to obtain a random number on (0, 3).
uniform (0.0, 3.0) is not available because `uniform returns a random number on [0, 1].

So the current workflow may become as the following.

let triple x = 3.0 * x
let r, _ =
   xorshift seed {
      let! u = ``(0, 1)``
      return triple u
   }

And, the following code may be nicer.

let triple x = 3.0 * x
let r, _ = xorshift seed { return! getRandomBy triple ``(0, 1)`` }

Two random numbers can generate one 53-bit resolution random number on [0, 1), (0, 1] or [0, 1], or one 52-bit resolution (0, 1).

Functions like uniform and normal are statistical functions. They can be split into another module.

Some of functions in Array module are availabe as seq<'a> instead of 'a [].

Like Array.sample, takes indices.