Random: introduce gentype, instead of punning on eltype

In some cases it makes sense to define what type of value `rand(rng, x)`
will produce, via the newly introduced `gentype(x)`, without having
`eltype(x)` be meaningful.

Author: rfourquet

stdlib/Random/src/Random.jl

@@ -34,6 +34,24 @@ export srand,
 
 abstract type AbstractRNG end
 
+"""
+    Random.gentype(x)
+
+Determine the type of the elements generated by calling `rand([rng], x)`.
+When `x` is not a type, `gentype(x)` defaults to `eltype(x)`,
+and for types, `gentype(x)` defaults to `x`.
+
+# Examples
+```jldoctest
+julia> gentype(1:10)
+Int64
+
+julia> gentype(Float64)
+Float64
+```
+"""
+gentype(x) = eltype(x)
+gentype(::Type{X}) where {X} = X
 
 ### integers
 
@@ -72,7 +90,7 @@ for UI = (:UInt10, :UInt10Raw, :UInt23, :UInt23Raw, :UInt52, :UInt52Raw,
     end
 end
 
-Base.eltype(::Type{<:UniformBits{T}}) where {T} = T
+gentype(::UniformBits{T}) where {T} = T
 
 ### floats
 
@@ -88,15 +106,15 @@ const CloseOpen12_64   = CloseOpen12{Float64}
 CloseOpen01(::Type{T}=Float64) where {T<:AbstractFloat} = CloseOpen01{T}()
 CloseOpen12(::Type{T}=Float64) where {T<:AbstractFloat} = CloseOpen12{T}()
 
-Base.eltype(::Type{<:FloatInterval{T}}) where {T<:AbstractFloat} = T
+gentype(::FloatInterval{T}) where {T<:AbstractFloat} = T
 
 const BitFloatType = Union{Type{Float16},Type{Float32},Type{Float64}}
 
 ### Sampler
 
 abstract type Sampler{E} end
 
-Base.eltype(::Type{<:Sampler{E}}) where {E} = E
+gentype(::Sampler{E}) where {E} = E
 
 # temporarily for BaseBenchmarks
 RangeGenerator(x) = Sampler(GLOBAL_RNG, x)
@@ -133,7 +151,7 @@ struct SamplerTrivial{T,E} <: Sampler{E}
     self::T
 end
 
-SamplerTrivial(x::T) where {T} = SamplerTrivial{T,eltype(T)}(x)
+SamplerTrivial(x::T) where {T} = SamplerTrivial{T,gentype(x)}(x)
 
 Sampler(::AbstractRNG, x, ::Repetition) = SamplerTrivial(x)
 
@@ -145,7 +163,7 @@ struct SamplerSimple{T,S,E} <: Sampler{E}
     data::S
 end
 
-SamplerSimple(x::T, data::S) where {T,S} = SamplerSimple{T,S,eltype(T)}(x, data)
+SamplerSimple(x::T, data::S) where {T,S} = SamplerSimple{T,S,gentype(x)}(x, data)
 
 Base.getindex(sp::SamplerSimple) = sp.self
 
@@ -223,7 +241,7 @@ end
 rand(r::AbstractRNG, dims::Integer...) = rand(r, Float64, Dims(dims))
 rand(                dims::Integer...) = rand(Float64, Dims(dims))
 
-rand(r::AbstractRNG, X, dims::Dims)  = rand!(r, Array{eltype(X)}(undef, dims), X)
+rand(r::AbstractRNG, X, dims::Dims)  = rand!(r, Array{gentype(X)}(undef, dims), X)
 rand(                X, dims::Dims)  = rand(GLOBAL_RNG, X, dims)
 
 rand(r::AbstractRNG, X, d::Integer, dims::Integer...) = rand(r, X, Dims((d, dims...)))
@@ -232,7 +250,7 @@ rand(                X, d::Integer, dims::Integer...) = rand(X, Dims((d, dims...
 # rand(r, ()) would match both this method and rand(r, dims::Dims)
 # moreover, a call like rand(r, NotImplementedType()) would be an infinite loop
 
-rand(r::AbstractRNG, ::Type{X}, dims::Dims) where {X} = rand!(r, Array{eltype(X)}(undef, dims), X)
+rand(r::AbstractRNG, ::Type{X}, dims::Dims) where {X} = rand!(r, Array{gentype(X)}(undef, dims), X)
 rand(                ::Type{X}, dims::Dims) where {X} = rand(GLOBAL_RNG, X, dims)
 
 rand(r::AbstractRNG, ::Type{X}, d::Integer, dims::Integer...) where {X} = rand(r, X, Dims((d, dims...)))

stdlib/Random/test/runtests.jl

@@ -667,8 +667,8 @@ end
     end
 end
 
-@testset "eltype for UniformBits" begin
-    @test eltype(Random.UInt52()) == UInt64
-    @test eltype(Random.UInt52(UInt128)) == UInt128
-    @test eltype(Random.UInt104()) == UInt128
+@testset "gentype for UniformBits" begin
+    @test Random.gentype(Random.UInt52()) == UInt64
+    @test Random.gentype(Random.UInt52(UInt128)) == UInt128
+    @test Random.gentype(Random.UInt104()) == UInt128
 end