enable Sampler(rng, Tuple{...})

Author: rfourquet

src/sampling.jl

@@ -195,35 +195,12 @@ Sampler(RNG::Type{<:AbstractRNG}, ::Type{Complex{T}}, n::Repetition) where {T<:R
 
 ### sampler for tuples
 
-@generated function Sampler(RNG::Type{<:AbstractRNG}, ::Type{T}, n::Repetition) where {T<:Tuple}
-    d = Dict{DataType,Int}()
-    sps = []
-    for t in T.parameters
-        i = get(d, t, nothing)
-        if i === nothing
-            push!(sps, :(Sampler(RNG, $t, n)))
-            d[t] = length(sps)
-        else
-            push!(sps, Val(i))
-        end
-    end
-    :(SamplerTag{Cont{T}}(tuple($(sps...))))
-end
+#### "simple scalar" (non-make) version
 
-@generated function rand(rng::AbstractRNG, sp::SamplerTag{Cont{T},S}) where {T<:Tuple,S<:Tuple}
-    @assert fieldcount(T) == fieldcount(S)
-    rands = []
-    for i = 1:fieldcount(T)
-        j = fieldtype(S, i) <: Val ?
-              fieldtype(S, i).parameters[1] :
-              i
-        push!(rands, :(convert($(fieldtype(T, i)),
-                               rand(rng, sp.data[$j]))))
-    end
-    :(tuple($(rands...)))
-end
+Sampler(RNG::Type{<:AbstractRNG}, ::Type{T}, n::Repetition) where {T<:Tuple} =
+    Sampler(RNG, make(T), n)
 
-#### with make
+#### make
 
 # implement make(Tuple, S1, S2...), e.g. for rand(make(Tuple, Int, 1:3)),
 # and       make(NTuple{N}, S)
@@ -293,18 +270,43 @@ make(::Type{T}, ::Type{X}, Y,         ::Type{Z}) where {T<:Tuple,X,Z}   = _make(
 make(::Type{T}, X,         ::Type{Y}, ::Type{Z}) where {T<:Tuple,Y,Z}   = _make(T, X, Y, Z)
 make(::Type{T}, ::Type{X}, ::Type{Y}, ::Type{Z}) where {T<:Tuple,X,Y,Z} = _make(T, X, Y, Z)
 
-##### Sampler for general tuples (rand is already implemented above, like for rand(Tuple{...})
+#### Sampler for general tuples
 
 @generated function Sampler(RNG::Type{<:AbstractRNG}, c::Make1{T,X}, n::Repetition) where {T<:Tuple,X<:Tuple}
     @assert fieldcount(T) == fieldcount(X)
     sps = [:(sampler(RNG, c.x[$i], n)) for i in 1:length(T.parameters)]
     :(SamplerTag{Cont{T}}(tuple($(sps...))))
 end
 
-Sampler(RNG::Type{<:AbstractRNG}, ::Make0{T}, n::Repetition) where {T<:Tuple} =
-    Sampler(RNG, T, n)
+@generated function Sampler(RNG::Type{<:AbstractRNG}, ::Make0{T}, n::Repetition) where {T<:Tuple}
+    d = Dict{DataType,Int}()
+    sps = []
+    for t in T.parameters
+        i = get(d, t, nothing)
+        if i === nothing
+            push!(sps, :(Sampler(RNG, $t, n)))
+            d[t] = length(sps)
+        else
+            push!(sps, Val(i))
+        end
+    end
+    :(SamplerTag{Cont{T}}(tuple($(sps...))))
+end
+
+@generated function rand(rng::AbstractRNG, sp::SamplerTag{Cont{T},S}) where {T<:Tuple,S<:Tuple}
+    @assert fieldcount(T) == fieldcount(S)
+    rands = []
+    for i = 1:fieldcount(T)
+        j = fieldtype(S, i) <: Val ?
+              fieldtype(S, i).parameters[1] :
+              i
+        push!(rands, :(convert($(fieldtype(T, i)),
+                               rand(rng, sp.data[$j]))))
+    end
+    :(tuple($(rands...)))
+end
 
-##### for "NTuple-like"
+#### for "NTuple-like"
 
 # should catch Tuple{Integer,Integer} which is not NTuple, or even Tuple{Int,UInt}, when only one sampler was passed
 

test/runtests.jl

@@ -1,5 +1,5 @@
 using RandomExtensions, Random, SparseArrays
-using Random: Sampler
+using Random: Sampler, gentype
 using Test
 
 @testset "Distributions" begin
@@ -309,6 +309,15 @@ end
         @test rand(T) isa Tuple{tlist...}
     end
     @test rand(Tuple{}) === ()
+    sp = Sampler(MersenneTwister, Tuple)
+    @test gentype(sp) == Tuple{}
+    @test rand(sp) == ()
+    sp = Sampler(MersenneTwister, NTuple{3})
+    @test gentype(sp) == NTuple{3,Float64}
+    @test rand(sp) isa NTuple{3,Float64}
+    sp = Sampler(MersenneTwister, Tuple{Int8,UInt8})
+    @test gentype(sp) == Tuple{Int8,UInt8}
+    @test rand(sp) isa Tuple{Int8,UInt8}
 end
 
 @testset "rand(make(Tuple, ...))" begin