use gentype instead of eltype

This allows stricter typing for few containers.

Author: rfourquet

src/RandomExtensions.jl

@@ -2,7 +2,7 @@ module RandomExtensions
 
 export Combine, Uniform, Normal, Exponential, CloseOpen, Rand
 
-import Random: Sampler, rand, rand!
+import Random: Sampler, rand, rand!, gentype
 
 using Random
 using Random: GLOBAL_RNG, SamplerTrivial, SamplerSimple, SamplerTag, Repetition

src/containers.jl

@@ -44,7 +44,7 @@ rand!(rng::AbstractRNG, A::AbstractSet, sp::Sampler) = _rand!(rng, A, length(A),
 rand(r::AbstractRNG, ::Type{T}, n::Integer) where {T<:AbstractSet} = rand(r, Float64, T, n)
 rand(                ::Type{T}, n::Integer) where {T<:AbstractSet} = rand(GLOBAL_RNG, T, n)
 
-rand(r::AbstractRNG, X, ::Type{T}, n::Integer) where {T<:AbstractSet} = _rand0!(r, deduce_type(T, eltype(X))(), n, X)
+rand(r::AbstractRNG, X, ::Type{T}, n::Integer) where {T<:AbstractSet} = _rand0!(r, deduce_type(T, gentype(X))(), n, X)
 rand(                X, ::Type{T}, n::Integer) where {T<:AbstractSet} = rand(GLOBAL_RNG, X, T, n)
 
 rand(r::AbstractRNG, ::Type{X}, ::Type{T}, n::Integer) where {X,T<:AbstractSet} = _rand0!(r, deduce_type(T, X)(), n, X)
@@ -70,7 +70,7 @@ rand(r::AbstractRNG, ::Type{X}, p::AbstractFloat, m::Integer) where {X} =
 rand(X, p::AbstractFloat, m::Integer) = rand(GLOBAL_RNG, X, p, m)
 
 rand(r::AbstractRNG, X::Sampler, p::AbstractFloat, m::Integer, n::Integer) =
-    sprand(r, m, n, p, (r, n)->rand(r, X, n), eltype(X))
+    sprand(r, m, n, p, (r, n)->rand(r, X, n), gentype(X))
 
 rand(r::AbstractRNG, X, p::AbstractFloat, m::Integer, n::Integer) =
     rand(r, Sampler(r, X), p, m, n)

src/distributions.jl

@@ -30,8 +30,8 @@ Combine(::Type{T}, ::Type{X}, y::Y) where {T,X,Y} = Combine2{deduce_type(T,X,Y),
 Combine(::Type{T}, x::X, ::Type{Y}) where {T,X,Y} = Combine2{deduce_type(T,X,Y),X,Type{Y}}(x, Y)
 Combine(::Type{T}, ::Type{X}, ::Type{Y}) where {T,X,Y} = Combine2{deduce_type(T,X,Y),Type{X},Type{Y}}(X, Y)
 
-deduce_type(::Type{T}, ::Type{X}, ::Type{Y}) where {T,X,Y} = _deduce_type(T, Val(isconcretetype(T)), eltype(X), eltype(Y))
-deduce_type(::Type{T}, ::Type{X}) where {T,X} = _deduce_type(T, Val(isconcretetype(T)), eltype(X))
+deduce_type(::Type{T}, ::Type{X}, ::Type{Y}) where {T,X,Y} = _deduce_type(T, Val(isconcretetype(T)), gentype(X), gentype(Y))
+deduce_type(::Type{T}, ::Type{X}) where {T,X} = _deduce_type(T, Val(isconcretetype(T)), gentype(X))
 
 _deduce_type(::Type{T}, ::Val{true},  ::Type{X}, ::Type{Y}) where {T,X,Y} = T
 _deduce_type(::Type{T}, ::Val{false}, ::Type{X}, ::Type{Y}) where {T,X,Y} = deduce_type(T{X}, Y)
@@ -55,7 +55,7 @@ struct UniformWrap{T,E} <: Uniform{E}
     val::T
 end
 
-Uniform(x::T) where {T} = UniformWrap{T,eltype(T)}(x)
+Uniform(x::T) where {T} = UniformWrap{T,gentype(T)}(x)
 
 Base.getindex(x::UniformWrap) = x.val
 

test/runtests.jl

@@ -113,3 +113,12 @@ Random.rand(rng::AbstractRNG, ::Random.SamplerTrivial{PairDistrib}) = 1=>2
     @test d == Dict(1=>2)
     @test typeof(d) == Dict{Any,Any}
 end
+
+@testset "some tight typing" begin
+    UI = Random.UInt52()
+    @test eltype(rand(MersenneTwister(), Random.Sampler(MersenneTwister, UI), .6, 1, 0)) == UInt64
+    @test eltype(rand(UI, Set, 3)) == UInt64
+    @test eltype(rand(Uniform(UI), 3)) == UInt64
+    a = rand(RandomExtensions.Combine(Pair, Int, UI))
+    @test fieldtype(typeof(a), 2) == UInt64
+end