Random: allow seeding from an RNG

Seeding from an RNG is the most flexible way: the caller doesn't need to
know anything about the internals of the fed RNG, which can request all
the entropy it needs from the parent PRG in whatever form it needs.

Author: rfourquet

stdlib/Random/src/RNGs.jl

@@ -365,12 +365,13 @@ function initstate!(r::MersenneTwister, data::StridedVector, seed)
 end
 
 # When a seed is not provided, we generate one via `RandomDevice()` rather
-# than calling directly `initstate!` with `rand(RandomDevice(), UInt32, whatever)` because the
+# than calling directly `initstate!` with `rand(RandomDevice(), UInt32, 8)` because the
 # seed is printed in `show(::MersenneTwister)`, so we need one; the cost of `hash_seed` is a
-# small overhead compared to `initstate!`, so this simple solution is fine.
-# A random seed with 128 bits is a good compromise for almost surely always getting distinct
+# small overhead compared to `initstate!`.
+# A random seed with 128 bits is a good compromise for almost surely getting distinct
 # seeds, while having them printed reasonably tersely.
-seed!(r::MersenneTwister, ::Nothing) = seed!(r, rand(RandomDevice(), UInt128))
+seed!(r::MersenneTwister, seeder::AbstractRNG) = seed!(r, rand(seeder, UInt128))
+seed!(r::MersenneTwister, ::Nothing) = seed!(r, RandomDevice())
 seed!(r::MersenneTwister, seed) = initstate!(r, hash_seed(seed), seed)
 
 

stdlib/Random/src/Random.jl

@@ -414,8 +414,10 @@ sequence of numbers if and only if a `seed` is provided. Some RNGs
 don't accept a seed, like `RandomDevice`.
 After the call to `seed!`, `rng` is equivalent to a newly created
 object initialized with the same seed.
+
 The types of accepted seeds depend on the type of `rng`, but in general,
-integer seeds should work.
+integer seeds should work. Providing `nothing` as the seed should be
+equivalent to not providing one.
 
 If `rng` is not specified, it defaults to seeding the state of the
 shared task-local generator.
@@ -455,11 +457,12 @@ julia> rand(Xoshiro(), Bool) # not reproducible either
 true
 ```
 """
-seed!(rng::AbstractRNG) = seed!(rng, nothing)
-#=
-We have this generic definition instead of the alternative option
-`seed!(rng::AbstractRNG, ::Nothing) = seed!(rng)`
-because it would lead too easily to ambiguities, e.g. when we define `seed!(::Xoshiro, seed)`.
-=#
+function seed!(rng::AbstractRNG, seed=nothing)
+    if seed === nothing
+        seed!(rng, RandomDevice())
+    else
+        throw(MethodError(seed!, (rng, seed)))
+    end
+end
 
 end # module

stdlib/Random/src/Xoshiro.jl

@@ -243,10 +243,10 @@ copy!(dst::Union{TaskLocalRNG, Xoshiro}, src::Union{TaskLocalRNG, Xoshiro}) = se
 # use a magic (random) number to scramble `h` so that `hash(x)` is distinct from `hash(getstate(x))`
 hash(x::Union{TaskLocalRNG, Xoshiro}, h::UInt) = hash(getstate(x), h + 0x49a62c2dda6fa9be % UInt)
 
-function seed!(rng::Union{TaskLocalRNG, Xoshiro}, ::Nothing)
-    # as we get good randomness from RandomDevice, we can skip hashing
-    initstate!(rng, rand(RandomDevice(), NTuple{4, UInt64}))
-end
+seed!(rng::Union{TaskLocalRNG, Xoshiro}, seeder::AbstractRNG) =
+    initstate!(rng, rand(seeder, NTuple{4, UInt64}))
+
+seed!(rng::Union{TaskLocalRNG, Xoshiro}, ::Nothing) = @invoke seed!(rng::AbstractRNG, nothing::Any)
 
 seed!(rng::Union{TaskLocalRNG, Xoshiro}, seed) =
     initstate!(rng, reinterpret(UInt64, hash_seed(seed)))

stdlib/Random/test/runtests.jl

@@ -675,6 +675,7 @@ end
         @test Random.seed!(m..., typemax(UInt)) === m2
         @test Random.seed!(m..., typemax(UInt128)) === m2
         @test Random.seed!(m..., "a random seed") === m2
+        @test Random.seed!(m..., Random.default_rng()) === m2
     end
 end
 
@@ -728,7 +729,7 @@ end
     @test rand(m, Int) ∉ (a, b, c, d)
 end
 
-@testset "$RNG(seed) & Random.seed!(m::$RNG, seed) produce the same stream" for RNG=(MersenneTwister,Xoshiro)
+@testset "$RNG(seed) & Random.seed!(m::$RNG, seed) produce the same stream" for RNG=(MersenneTwister, Xoshiro)
     seeds = Any[0, 1, 2, 10000, 10001, rand(UInt32, 8), randstring(), randstring(), rand(UInt128, 3)...]
     if RNG == Xoshiro
         push!(seeds, rand(UInt64, rand(1:4)))
@@ -739,6 +740,11 @@ end
         Random.seed!(m, seed)
         @test a == [rand(m) for _=1:100]
     end
+    # rng as a seed
+    m = RNG(Xoshiro(0))
+    a = [rand(m) for _=1:100]
+    Random.seed!(m, Xoshiro(0))
+    @test a == [rand(m) for _=1:100]
 end
 
 @testset "Random.seed!(seed) sets Random.GLOBAL_SEED" begin