add rand(make(Dict, ...))

Author: rfourquet

src/containers.jl

@@ -96,49 +96,19 @@ end
 @make_array_container(BitArray)
 
 
-## dicts
+## sets/dicts
 
-# again same inference bug
-# TODO: extend to AbstractDict ? (needs to work-around the inderence bug)
-default_sampling(::Type{<:Dict{K,V}}) where {K,V} = Pair{K,V}
-default_sampling(D::Type{<:Dict}) = throw(ArgumentError("under-specified scalar type for $D"))
-
-rand!(A::AbstractDict{K,V}, dist::Union{Type{<:Pair},Distribution{<:Pair}}=make(Pair, K, V)) where {K,V} =
-    rand!(GLOBAL_RNG, A, dist)
-
-rand!(rng::AbstractRNG, A::AbstractDict{K,V},
-      dist::Union{Type{<:Pair},Distribution{<:Pair}}=make(Pair, K, V)) where {K,V} =
-          rand!(rng, A, Sampler(rng, dist))
-
-function _rand!(rng::AbstractRNG, A::Union{AbstractDict,AbstractSet}, n::Integer, sp::Sampler)
+function _rand!(rng::AbstractRNG, A::SetDict, n::Integer, sp::Sampler)
     empty!(A)
     while length(A) < n
         push!(A, rand(rng, sp))
     end
     A
 end
 
-rand!(rng::AbstractRNG, A::AbstractDict{K,V}, sp::Sampler) where {K,V} = _rand!(rng, A, length(A), sp)
-
-rand(rng::AbstractRNG, dist::Distribution{P}, ::Type{T}, n::Integer) where {P<:Pair,T<:AbstractDict} =
-    _rand!(rng, deduce_type(T, fieldtype(P, 1), fieldtype(P, 2))(), n, Sampler(rng, dist))
-
-rand(rng::AbstractRNG, ::Type{P}, ::Type{T}, n::Integer) where {P<:Pair,T<:AbstractDict} = rand(rng, Uniform(P), T, n)
-
-rand(rng::AbstractRNG, ::Type{T}, n::Integer) where {T<:AbstractDict} = rand(rng, default_sampling(T), T, n)
-
-rand(u::Distribution{<:Pair}, ::Type{T}, n::Integer) where {T<:AbstractDict} = rand(GLOBAL_RNG, u, T, n)
-
-rand(::Type{P}, ::Type{T}, n::Integer) where {P<:Pair,T<:AbstractDict} = rand(GLOBAL_RNG, Uniform(P), T, n)
-
-rand(::Type{T}, n::Integer) where {T<:AbstractDict} = rand(GLOBAL_RNG, default_sampling(T), T, n)
-
-
-## sets
-
-rand!(                  A::AbstractSet{T}, X)                             where {T}   = rand!(GLOBAL_RNG, A, X)
-rand!(rng::AbstractRNG, A::AbstractSet,    X)                                         = _rand!(rng, A, length(A), sampler(rng, X))
-rand!(                  A::AbstractSet{T}, ::Type{X}=default_sampling(A)) where {T,X} = rand!(GLOBAL_RNG, A, X)
-rand!(rng::AbstractRNG, A::AbstractSet{T}, ::Type{X}=default_sampling(A)) where {T,X} = rand!(rng, A, Sampler(rng, X))
+rand!(                  A::SetDict, X)                                       = rand!(GLOBAL_RNG, A, X)
+rand!(rng::AbstractRNG, A::SetDict, X)                                       = _rand!(rng, A, length(A), sampler(rng, X))
+rand!(                  A::SetDict, ::Type{X}=default_sampling(A)) where {X} = rand!(GLOBAL_RNG, A, X)
+rand!(rng::AbstractRNG, A::SetDict, ::Type{X}=default_sampling(A)) where {X} = rand!(rng, A, Sampler(rng, X))
 
-@make_container(T::Type{<:AbstractSet}, n::Integer)
+@make_container(T::Type{<:SetDict}, n::Integer)

src/sampling.jl

@@ -247,25 +247,28 @@ end
 
 ## collections
 
-### sets
-
-default_sampling(::Type{<:AbstractSet}) = Float64
-default_sampling(::Type{<:AbstractSet{T}}) where {T} = T
+### sets/dicts
 
-make(T::Type{<:AbstractSet},            n::Integer)           = make(T, default_sampling(T), Int(n))
+const SetDict = Union{AbstractSet,AbstractDict}
 
-make(T::Type{<:AbstractSet}, X,         n::Integer)           = Make2{find_type(T, X, n)}(X , Int(n))
-make(T::Type{<:AbstractSet}, ::Type{X}, n::Integer) where {X} = Make2{find_type(T, X, n)}(X , Int(n))
+make(T::Type{<:SetDict}, X,         n::Integer)           = Make2{find_type(T, X, n)}(X , Int(n))
+make(T::Type{<:SetDict}, ::Type{X}, n::Integer) where {X} = Make2{find_type(T, X, n)}(X , Int(n))
+make(T::Type{<:SetDict},            n::Integer)           = make(T, default_sampling(T), Int(n))
 
-Sampler(RNG::Type{<:AbstractRNG}, c::Make2{T}, n::Repetition) where {T<:AbstractSet} =
+Sampler(RNG::Type{<:AbstractRNG}, c::Make2{T}, n::Repetition) where {T<:SetDict} =
     SamplerTag{Cont{T}}((sampler(RNG, c.x, n), c.y))
 
-function rand(rng::AbstractRNG, sp::SamplerTag{Cont{S}}) where {S<:AbstractSet}
-    # assuming S() creates an empty set
+function rand(rng::AbstractRNG, sp::SamplerTag{Cont{S}}) where {S<:SetDict}
+    # assuming S() creates an empty set/dict
     s = sizehint!(S(), sp.data[2])
     _rand!(rng, s, sp.data[2], sp.data[1])
 end
 
+### sets
+
+default_sampling(::Type{<:AbstractSet}) = Float64
+default_sampling(::Type{<:AbstractSet{T}}) where {T} = T
+
 #### Set
 
 find_type(::Type{Set},    X, _)           = Set{val_gentype(X)}
@@ -278,6 +281,23 @@ default_sampling(::Type{BitSet}) = Int8 # almost arbitrary, may change
 find_type(::Type{BitSet}, _, _) = BitSet
 
 
+### dicts
+
+# again same inference bug
+# TODO: extend to AbstractDict ? (needs to work-around the inderence bug)
+default_sampling(::Type{Dict{K,V}}) where {K,V} = Pair{K,V}
+default_sampling(D::Type{<:Dict})               = throw(ArgumentError("under-specified scalar type for $D"))
+
+find_type(D::Type{<:AbstractDict{K,V}}, _,      ::Integer) where {K,V} = D
+find_type(D::Type{<:AbstractDict{K,V}}, ::Type, ::Integer) where {K,V} = D
+
+#### Dict
+
+find_type(::Type{Dict{K}},           X, ::Integer) where {K} = Dict{K,fieldtype(val_gentype(X), 2)}
+find_type(::Type{Dict{K,V} where K}, X, ::Integer) where {V} = Dict{fieldtype(val_gentype(X), 1),V}
+find_type(::Type{Dict},              X, ::Integer)           = Dict{fieldtype(val_gentype(X), 1),fieldtype(val_gentype(X), 2)}
+
+
 ### AbstractArray
 
 default_sampling(::Type{<:AbstractArray{T}}) where {T} = T

test/runtests.jl

@@ -360,6 +360,18 @@ end
     end
 end
 
+@testset "rand(make(Dict, ...))" begin
+    for (D, S) = (Dict{Int16,Int16}     => [],
+                Dict{Int16}           => [Pair{Int8,Int16}],
+                Dict{K,Int16} where K => [Pair{Int16,Int8}],
+                Dict                  => [Pair{Int16,Int16}])
+
+        d = rand(make(D, S..., 3))
+        @test d isa Dict{Int16,Int16}
+        @test length(d) == 3
+    end
+end
+
 @testset "rand(make(Array/BitArray, ...))" begin
     for (T, Arr) = (Bool => BitArray, Float64 => Array{Float64}),
         k = ([], [T], [Bernoulli(T, 0.3)]),