update according to feedback, with option 2)

Author: rfourquet

stdlib/Random/src/Random.jl

@@ -35,23 +35,24 @@ export srand,
 abstract type AbstractRNG end
 
 """
-    Random.gentype(x)
+    Random.gentype(T)
 
-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`.
+Determine the type of the elements generated by calling `rand([rng], x)`,
+where `x::T`, and `x` is not a type.
+The definition `gentype(x) = gentype(typeof(x))` is provided for convenience,
+and `gentype(T)` defaults to `eltype(T)`.
+NOTE: `rand([rng], X)`, where `X` is a type, is always assumed to produce
+an object of type `X`.
 
 # Examples
 ```jldoctest
 julia> gentype(1:10)
 Int64
-
-julia> gentype(Float64)
-Float64
 ```
 """
-gentype(x) = eltype(x)
-gentype(::Type{X}) where {X} = X
+gentype(::Type{X}) where {X} = eltype(X)
+gentype(x) = gentype(typeof(x))
+
 
 ### integers
 
@@ -90,7 +91,7 @@ for UI = (:UInt10, :UInt10Raw, :UInt23, :UInt23Raw, :UInt52, :UInt52Raw,
     end
 end
 
-gentype(::UniformBits{T}) where {T} = T
+gentype(::Type{<:UniformBits{T}}) where {T} = T
 
 ### floats
 
@@ -106,15 +107,15 @@ const CloseOpen12_64   = CloseOpen12{Float64}
 CloseOpen01(::Type{T}=Float64) where {T<:AbstractFloat} = CloseOpen01{T}()
 CloseOpen12(::Type{T}=Float64) where {T<:AbstractFloat} = CloseOpen12{T}()
 
-gentype(::FloatInterval{T}) where {T<:AbstractFloat} = T
+gentype(::Type{<:FloatInterval{T}}) where {T<:AbstractFloat} = T
 
 const BitFloatType = Union{Type{Float16},Type{Float32},Type{Float64}}
 
 ### Sampler
 
 abstract type Sampler{E} end
 
-gentype(::Sampler{E}) where {E} = E
+gentype(::Type{<:Sampler{E}}) where {E} = E
 
 # temporarily for BaseBenchmarks
 RangeGenerator(x) = Sampler(GLOBAL_RNG, x)
@@ -151,7 +152,7 @@ struct SamplerTrivial{T,E} <: Sampler{E}
     self::T
 end
 
-SamplerTrivial(x::T) where {T} = SamplerTrivial{T,gentype(x)}(x)
+SamplerTrivial(x::T) where {T} = SamplerTrivial{T,gentype(T)}(x)
 
 Sampler(::AbstractRNG, x, ::Repetition) = SamplerTrivial(x)
 
@@ -163,14 +164,14 @@ struct SamplerSimple{T,S,E} <: Sampler{E}
     data::S
 end
 
-SamplerSimple(x::T, data::S) where {T,S} = SamplerSimple{T,S,gentype(x)}(x, data)
+SamplerSimple(x::T, data::S) where {T,S} = SamplerSimple{T,S,gentype(T)}(x, data)
 
 Base.getindex(sp::SamplerSimple) = sp.self
 
 # simple sampler carrying a (type) tag T and data
 struct SamplerTag{T,S,E} <: Sampler{E}
     data::S
-    SamplerTag{T}(s::S) where {T,S} = new{T,S,eltype(T)}(s)
+    SamplerTag{T}(s::S) where {T,S} = new{T,S,gentype(T)}(s)
 end
 
 
@@ -250,7 +251,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{gentype(X)}(undef, dims), X)
+rand(r::AbstractRNG, ::Type{X}, dims::Dims) where {X} = rand!(r, Array{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...)))