Random: allow string seeds

We used to be able to seed RNGs with a string, but that string was interpreted
as the filename containing the seed. This was deprecated in #21359, in order
to allow later using a string seed directly, which this patch does.

Author: rfourquet

NEWS.md

@@ -49,6 +49,8 @@ Standard library changes
 
 #### Random
 * `rand` now supports sampling over `Tuple` types ([#50251]).
+* Most random number generators from `Random` can now be seeded by a string, e.g.
+  `seed!(rng, "a random seed")` ([#51527]).
 
 * When seeding RNGs provided by `Random`, negative integer seeds can now be used ([#51416]).
 

stdlib/Random/src/RNGs.jl

@@ -83,7 +83,7 @@ MersenneTwister(seed, state::DSFMT_state) =
 Create a `MersenneTwister` RNG object. Different RNG objects can have
 their own seeds, which may be useful for generating different streams
 of random numbers.
-The `seed` may be an integer or a vector of `UInt32` integers.
+The `seed` may be an integer, a string, or a vector of `UInt32` integers.
 If no seed is provided, a randomly generated one is created (using entropy from the system).
 See the [`seed!`](@ref) function for reseeding an already existing `MersenneTwister` object.
 
@@ -316,12 +316,22 @@ function hash_seed(seed::Union{AbstractArray{UInt32}, AbstractArray{UInt64}})
     SHA.digest!(ctx)
 end
 
+function hash_seed(str::AbstractString)
+    ctx = SHA.SHA2_256_CTX()
+    for chr in str
+        SHA.update!(ctx, reinterpret(NTuple{4, UInt8}, UInt32(chr)))
+    end
+    SHA.update!(ctx, (0x05,))
+    SHA.digest!(ctx)
+end
+
 
 """
     hash_seed(seed) -> AbstractVector{UInt8}
 
 Return a cryptographic hash of `seed` of size 256 bits (32 bytes).
-`seed` can currently be of type `Union{Integer, DenseArray{UInt32}, DenseArray{UInt64}}`,
+`seed` can currently be of type
+`Union{Integer, AbstractString, AbstractArray{UInt32}, AbstractArray{UInt64}}`,
 but modules can extend this function for types they own.
 
 `hash_seed` is "injective" : if `n != m`, then `hash_seed(n) != `hash_seed(m)`.

stdlib/Random/src/Xoshiro.jl

@@ -4,7 +4,7 @@
 # Lots of implementation is shared with TaskLocalRNG
 
 """
-    Xoshiro(seed::Integer)
+    Xoshiro(seed::Union{Integer, AbstractString})
     Xoshiro()
 
 Xoshiro256++ is a fast pseudorandom number generator described by David Blackman and
@@ -256,7 +256,6 @@ end
 seed!(rng::Union{TaskLocalRNG, Xoshiro}, seed) =
     initstate!(rng, reinterpret(UInt64, hash_seed(seed)))
 
-
 @inline function rand(x::Union{TaskLocalRNG, Xoshiro}, ::SamplerType{UInt64})
     s0, s1, s2, s3 = getstate(x)
     tmp = s0 + s3

stdlib/Random/test/runtests.jl

@@ -647,6 +647,7 @@ end
         # test that the following is not an error (#16925)
         @test Random.seed!(m..., typemax(UInt)) === m2
         @test Random.seed!(m..., typemax(UInt128)) === m2
+        @test Random.seed!(m..., "a random seed") === m2
     end
 end
 
@@ -701,7 +702,7 @@ end
 end
 
 @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), rand(UInt128, 3)...]
+    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)))
     end
@@ -714,7 +715,7 @@ end
 end
 
 @testset "Random.seed!(seed) sets Random.GLOBAL_SEED" begin
-    seeds = Any[0, rand(UInt128), rand(UInt64, 4)]
+    seeds = Any[0, rand(UInt128), rand(UInt64, 4), randstring(20)]
 
     for seed=seeds
         Random.seed!(seed)
@@ -923,6 +924,12 @@ end
         @test string(m) == "MersenneTwister(-3)"
         Random.seed!(m, typemin(Int8))
         @test string(m) == "MersenneTwister(-128)"
+
+        # string seeds
+        Random.seed!(m, "seed 1")
+        x = rand(m)
+        @test string(m) == "MersenneTwister(\"seed 1\")"
+        @test x == rand(MersenneTwister("seed 1"))
     end
 
     @testset "RandomDevice" begin
@@ -1179,4 +1186,8 @@ end
     hash32 = Random.hash_seed(seed32)
     @test Random.hash_seed(map(UInt64, seed32)) == hash32
     @test hash32 ∉ keys(vseeds)
+
+    seed_str = randstring()
+    seed_gstr = GenericString(seed_str)
+    @test Random.hash_seed(seed_str) == Random.hash_seed(seed_gstr)
 end