make Sampler{E} encode the type E of elements which are generated

Before, a call like `rand(mm, Sampler(mm, 1:10), 3)`
generated an `Array{Any,1}`, so a way to get the `eltype`
of a Sampler is necessary. Instead of changing Sampler -> Sampler{E},
implementing appropriate eltype methods would have been possible,
to keep the helper Sampler subtypes more flexible, but it seemed
to be simpler this way.

base/random/generation.jl

@@ -40,7 +40,7 @@ rand(r::AbstractRNG, ::SamplerTrivial{CloseOpen01_64}) = rand(r, CloseOpen12())
 const bits_in_Limb = sizeof(Limb) << 3
 const Limb_high_bit = one(Limb) << (bits_in_Limb-1)
 
-struct SamplerBigFloat{I<:FloatInterval{BigFloat}} <: Sampler
+struct SamplerBigFloat{I<:FloatInterval{BigFloat}} <: Sampler{BigFloat}
     prec::Int
     nlimbs::Int
     limbs::Vector{Limb}
@@ -155,7 +155,7 @@ uint_sup(::Type{<:Union{Int128,UInt128}}) = UInt128
 
 #### Fast
 
-struct SamplerRangeFast{U<:BitUnsigned,T<:Union{BitInteger,Bool}} <: Sampler
+struct SamplerRangeFast{U<:BitUnsigned,T<:Union{BitInteger,Bool}} <: Sampler{T}
     a::T      # first element of the range
     bw::UInt  # bit width
     m::U      # range length - 1
@@ -215,7 +215,7 @@ maxmultiple(k::T, sup::T=zero(T)) where {T<:Unsigned} =
 unsafe_maxmultiple(k::T, sup::T) where {T<:Unsigned} =
     div(sup, k + (k == 0))*k - one(k)
 
-struct SamplerRangeInt{T<:Union{Bool,Integer},U<:Unsigned} <: Sampler
+struct SamplerRangeInt{T<:Union{Bool,Integer},U<:Unsigned} <: Sampler{T}
     a::T      # first element of the range
     bw::Int   # bit width
     k::U      # range length or zero for full range
@@ -270,7 +270,7 @@ end
 
 ### BigInt
 
-struct SamplerBigInt <: Sampler
+struct SamplerBigInt <: Sampler{BigInt}
     a::BigInt         # first
     m::BigInt         # range length - 1
     nlimbs::Int       # number of limbs in generated BigInt's (z ∈ [0, m])
@@ -336,9 +336,10 @@ end
 
 ## random values from Set
 
-Sampler(rng::AbstractRNG, t::Set, n::Repetition) = SamplerTag{Set}(Sampler(rng, t.dict, n))
+Sampler(rng::AbstractRNG, t::Set{T}, n::Repetition) where {T} =
+    SamplerTag{Set{T}}(Sampler(rng, t.dict, n))
 
-rand(rng::AbstractRNG, sp::SamplerTag{Set,<:Sampler}) = rand(rng, sp.data).first
+rand(rng::AbstractRNG, sp::SamplerTag{<:Set,<:Sampler}) = rand(rng, sp.data).first
 
 ## random values from BitSet
 

base/random/random.jl

@@ -26,6 +26,7 @@ export srand,
 
 abstract type AbstractRNG end
 
+
 ### integers
 
 # we define types which encode the generation of a specific number of bits
@@ -83,7 +84,9 @@ const BitFloatType = Union{Type{Float16},Type{Float32},Type{Float64}}
 
 ### Sampler
 
-abstract type Sampler end
+abstract type Sampler{E} end
+
+Base.eltype(::Sampler{E}) where {E} = E
 
 # temporarily for BaseBenchmarks
 RangeGenerator(x) = Sampler(GLOBAL_RNG, x)
@@ -109,41 +112,48 @@ Sampler(rng::AbstractRNG, ::Type{X}) where {X} = Sampler(rng, X, Val(Inf))
 #### pre-defined useful Sampler types
 
 # default fall-back for types
-struct SamplerType{T} <: Sampler end
+struct SamplerType{T} <: Sampler{T} end
 
 Sampler(::AbstractRNG, ::Type{T}, ::Repetition) where {T} = SamplerType{T}()
 
-Base.getindex(sp::SamplerType{T}) where {T} = T
+Base.getindex(::SamplerType{T}) where {T} = T
 
 # default fall-back for values
-struct SamplerTrivial{T} <: Sampler
+struct SamplerTrivial{T,E} <: Sampler{E}
     self::T
 end
 
-Sampler(::AbstractRNG, X, ::Repetition) = SamplerTrivial(X)
+SamplerTrivial(x::T) where {T} = SamplerTrivial{T,eltype(T)}(x)
+
+Sampler(::AbstractRNG, x, ::Repetition) = SamplerTrivial(x)
 
 Base.getindex(sp::SamplerTrivial) = sp.self
 
 # simple sampler carrying data (which can be anything)
-struct SamplerSimple{T,S} <: Sampler
+struct SamplerSimple{T,S,E} <: Sampler{E}
     self::T
     data::S
 end
 
+SamplerSimple(x::T, data::S) where {T,S} = SamplerSimple{T,S,eltype(T)}(x, data)
+
 Base.getindex(sp::SamplerSimple) = sp.self
 
 # simple sampler carrying a (type) tag T and data
-struct SamplerTag{T,S} <: Sampler
+struct SamplerTag{T,S,E} <: Sampler{E}
     data::S
-    SamplerTag{T}(s::S) where {T,S} = new{T,S}(s)
+    SamplerTag{T}(s::S) where {T,S} = new{T,S,eltype(T)}(s)
 end
 
 
 #### helper samplers
 
+# TODO: make constraining constructors to enforce that those
+# types are <: Sampler{T}
+
 ##### Adapter to generate a randome value in [0, n]
 
-struct LessThan{T<:Integer,S} <: Sampler
+struct LessThan{T<:Integer,S} <: Sampler{T}
     sup::T
     s::S    # the scalar specification/sampler to feed to rand
 end
@@ -155,7 +165,7 @@ function rand(rng::AbstractRNG, sp::LessThan)
     end
 end
 
-struct Masked{T<:Integer,S} <: Sampler
+struct Masked{T<:Integer,S} <: Sampler{T}
     mask::T
     s::S
 end
@@ -164,7 +174,7 @@ rand(rng::AbstractRNG, sp::Masked) = rand(rng, sp.s) & sp.mask
 
 ##### Uniform
 
-struct UniformT{T} <: Sampler end
+struct UniformT{T} <: Sampler{T} end
 
 uniform(::Type{T}) where {T} = UniformT{T}()