Replace Dict with NamedTuple for StatsSpec

Author: junyuan-chen

src/DiffinDiffsBase.jl

@@ -14,6 +14,7 @@ export @fieldequal,
        unpack,
        kwarg,
        @unpack,
+       ≊,
        exampledata,
        sprintcompact,
 

src/did.jl

@@ -43,8 +43,6 @@ function did(d::Type{<:DiffinDiffsEstimator}, @nospecialize(formula::FormulaTerm
         yterm=formula.lhs, treatname=treat.sym, ints..., xterms..., kwargs...)
 end
 
-argpair(arg::Type{<:DiffinDiffsEstimator}) = :d => arg
-argpair(arg::AbstractString) = :name => String(arg)
 argpair(arg::AbstractTreatment) = :tr => arg
 argpair(arg::AbstractParallel) = :pr => arg
 argpair(::Any) = throw(ArgumentError("unacceptable positional arguments"))
@@ -61,14 +59,20 @@ that can be accepted by [`did`](@ref).
 # Returns
 - `Type{<:DiffinDiffsEstimator}`: either the type found in positional arguments or `DefaultDID`.
 - `String`: either a string found in positional arguments or `""` if no instance of any subtype of `AbstractString` is found.
-- `Dict`: up to two key-value pairs for instances of [`AbstractTreatment`](@ref) and [`AbstractParallel`](@ref) with keys being `:tr` and `:pr`.
-- `Dict`: keyword arguments with possibly additional pairs after parsing positional arguments.
+- `NamedTuple`: contain at most one instance of [`AbstractTreatment`](@ref) and [`AbstractParallel`](@ref) with associated keys being `:tr` and `:pr` respectively.
+- `NamedTuple`: keyword arguments with possibly additional elements after parsing positional arguments.
 """
 function parse_didargs(args...; kwargs...)
+    sptypes = Type{<:DiffinDiffsEstimator}[]
+    names = String[]
     pargs = Pair{Symbol,Any}[]
     pkwargs = Pair{Symbol,Any}[kwargs...]
     for arg in args
-        if arg isa FormulaTerm
+        if arg isa Type{<:DiffinDiffsEstimator}
+            push!(sptypes, arg)
+        elseif arg isa AbstractString
+            push!(names, String(arg))
+        elseif arg isa FormulaTerm
             treat, intacts, xs = parse_treat(arg)
             push!(pargs, argpair(treat.tr), argpair(treat.pr))
             push!(pkwargs, :yterm => arg.lhs, :treatname => treat.sym)
@@ -81,12 +85,22 @@ function parse_didargs(args...; kwargs...)
             push!(pargs, argpair(arg))
         end
     end
-    args = Dict{Symbol,Any}(pargs...)
-    kwargs = Dict{Symbol,Any}(pkwargs...)
-    length(args) == length(pargs) && length(kwargs) == length(pkwargs) ||
+    if length(sptypes) > 1 || length(names) > 1
         throw(ArgumentError("redundant arguments encountered"))
-    sptype = pop!(args, :d, DefaultDID)
-    name = pop!(args, :name, "")
+    else
+        keyargs = first.(pargs)
+        if length(keyargs) != length(unique(keyargs))
+            throw(ArgumentError("redundant arguments encountered"))
+        else
+            keykwargs = first.(pkwargs)
+            length(keykwargs) != length(unique(keykwargs)) &&
+                throw(ArgumentError("redundant arguments encountered"))
+        end
+    end
+    sptype = isempty(sptypes) ? DefaultDID : sptypes[1]
+    name = isempty(names) ? "" : names[1]
+    args = (; pargs...)
+    kwargs = (; pkwargs...)
     return sptype, name, args, kwargs
 end
 

src/procedures.jl

@@ -20,10 +20,10 @@ iterate(p::AbstractStatsProcedure{T}, state=1) where T =
     state > length(p) ? nothing : (p[state], state+1)
 
 """
-    StatsSpec{T<:AbstractStatsProcedure, IsComplete}
+    StatsSpec{T<:AbstractStatsProcedure, IsValidated}
 
 Record the specification for a statistical procedure of type `T`
-that may or may not be verified to be complete as indicated by `IsComplete`.
+that may or may not be verified to be valid as indicated by `IsValidated`.
 
 The specification is recorded based on the arguments
 for a function that will conduct the procedure.
@@ -32,21 +32,40 @@ can be constructed solely based on the type of each argument.
 
 # Fields
 - `name::String`: an optional name for the specification.
-- `args::Dict{Symbol}`: positional arguments indexed based on their types.
-- `kwargs::Dict{Symbol}`: keyword arguments.
+- `args::NamedTuple`: positional arguments indexed based on their types.
+- `kwargs::NamedTuple`: keyword arguments.
 """
-struct StatsSpec{T<:AbstractStatsProcedure, IsComplete}
+struct StatsSpec{T<:AbstractStatsProcedure, IsValidated}
     name::String
-    args::Dict{Symbol}
-    kwargs::Dict{Symbol}
+    args::NamedTuple
+    kwargs::NamedTuple
 end
 
 StatsSpec(T::Type{<:AbstractStatsProcedure}, name::String,
-    args::Dict{Symbol}, kwargs::Dict{Symbol}, IsComplete::Bool=false) =
-        StatsSpec{T,IsComplete}(name, args, kwargs)
+    args::NamedTuple, kwargs::NamedTuple, IsValidated::Bool=false) =
+        StatsSpec{T,IsValidated}(name, args, kwargs)
 
-==(a::StatsSpec{T}, b::StatsSpec{T}) where {T<:AbstractStatsProcedure} =
-    a.args == b.args && a.kwargs == b.kwargs
+"""
+    ==(x::StatsSpec{T}, y::StatsSpec{T}) where T
+
+Test whether two instances of [`StatsSpec`](@ref)
+with the same parameter `T` also have the same fields `args` and `kwargs`.
+
+See also [`≊`](@ref).
+"""
+==(x::StatsSpec{T}, y::StatsSpec{T}) where T =
+    x.args == y.args && x.kwargs == y.kwargs
+
+"""
+    ≊(x::StatsSpec{T}, y::StatsSpec{T}) where T
+
+Test whether two instances of [`StatsSpec`](@ref)
+with the same parameter `T` also have the fields `args` and `kwargs`
+containing the same sets of key-value pairs
+while ignoring the orders.
+"""
+≊(x::StatsSpec{T}, y::StatsSpec{T}) where T =
+    x.args ≊ y.args && x.kwargs ≊ y.kwargs
 
 isnamed(sp::StatsSpec) = sp.name != ""
 

src/terms.jl

@@ -62,7 +62,7 @@ Return a `Tuple` of three objects extracted from the right-hand-side of `formula
 Error will be raised if either existence or uniqueness of the `TreatmentTerm` is violated.
 """
 function parse_treat(@nospecialize(formula::FormulaTerm))
-    # Use Array instead of Dict for detecting duplicate terms
+    # Use Array for detecting duplicate terms
     treats = Pair{TreatmentTerm,Tuple}[]
     for term in eachterm(formula.rhs)
         if hastreat(term)

src/utils.jl

@@ -6,9 +6,9 @@ such that `==` returns true if two instances have the same field values.
 """
 macro fieldequal(Supertype)
     return esc(quote
-        function ==(a::T, b::T) where T <: $Supertype
+        function ==(x::T, y::T) where T <: $Supertype
             f = fieldnames(T)
-            getfield.(Ref(a),f) == getfield.(Ref(b),f)
+            getfield.(Ref(x),f) == getfield.(Ref(y),f)
         end
     end)
 end
@@ -110,6 +110,18 @@ function args_kwargs(exprs)
     return args, kwargs
 end
 
+"""
+    ≊(x::NamedTuple, y::NamedTuple)
+
+Test whether two instances of `NamedTuple` contain
+the same set of key-value pairs while ignoring the order.
+
+See https://discourse.julialang.org/t/check-equality-of-two-namedtuples-with-order-of-the-fields-ignored
+"""
+≊(x::NamedTuple{N1,T1}, y::NamedTuple{N2,T2}) where {N1,T1,N2,T2} =
+    length(N1) === length(union(N1,N2)) &&
+        all(k->getfield(x,k)==getfield(y,k), keys(x))
+
 """
     exampledata()
 

test/did.jl

@@ -13,6 +13,7 @@ did(::Type{TestDID}, ::AbstractTreatment, ::AbstractParallel;
     @test eltype(d) == Function
     @test_throws BoundsError d[1]
     @test collect(d) == Function[]
+    @test iterate(d) === nothing
 
     d = TestDID()
     @test length(d) == 2
@@ -23,6 +24,9 @@ did(::Type{TestDID}, ::AbstractTreatment, ::AbstractParallel;
     @test_throws BoundsError d[3]
     @test_throws MethodError d[:a]
     @test collect(d) == Function[print, println]
+    @test iterate(d) == (print, 2)
+    @test iterate(d, 2) == (println, 3)
+    @test iterate(d, 3) === nothing
 end
 
 @testset "did wrapper" begin
@@ -68,26 +72,26 @@ end
 end
 
 @testset "parse_didargs" begin
-    @test parse_didargs() == (DefaultDID, "", Dict{Symbol,Any}(), Dict{Symbol,Any}())
-    @test parse_didargs("test") == (DefaultDID, "test", Dict{Symbol,Any}(), Dict{Symbol,Any}())
+    @test parse_didargs() == (DefaultDID, "", NamedTuple(), NamedTuple())
+    @test parse_didargs("test") == (DefaultDID, "test", NamedTuple(), NamedTuple())
 
     sptype, name, args, kwargs = parse_didargs(TestDID, TR, PR, a=1, b=2)
     @test sptype == TestDID
     @test name == ""
-    @test args == Dict(:tr=>TR, :pr=>PR)
-    @test kwargs == Dict(:a=>1, :b=>2)
+    @test args == (tr=TR, pr=PR)
+    @test kwargs == (a=1, b=2)
 
     sptype, name, args, kwargs = parse_didargs("test", testterm, TestDID)
     @test sptype == TestDID
     @test name == "test"
-    @test args == Dict(:tr=>TR, :pr=>PR)
-    @test kwargs == Dict(:treatname=>:g)
+    @test args == (tr=TR, pr=PR)
+    @test kwargs == (treatname=:g,)
 
     sptype, name, args0, kwargs0 = parse_didargs(TestDID, term(:y) ~ testterm, "test")
     @test sptype == TestDID
     @test name == "test"
-    @test args0 == Dict(:tr=>TR, :pr=>PR)
-    @test kwargs0 == Dict(:yterm=>term(:y), :treatname=>:g)
+    @test args0 == (tr=TR, pr=PR)
+    @test kwargs0 == (yterm=term(:y), treatname=:g)
 
     sptype, name, args1, kwargs1 = parse_didargs(TestDID, @formula(y ~ treat(g, ttreat(t, 0), tpara(0))))
     @test sptype == TestDID
@@ -96,9 +100,8 @@ end
     @test kwargs1 == kwargs0
 
     sptype, name, args0, kwargs0 = parse_didargs(TestDID, term(:y) ~ testterm & term(:z) + term(:x))
-    @test args0 == Dict(:tr=>TR, :pr=>PR)
-    @test kwargs0 == Dict(:yterm=>term(:y), :treatname=>:g,
-        :treatintterms=>(term(:z),), :xterms=>(term(:x),))
+    @test args0 == (tr=TR, pr=PR)
+    @test kwargs0 == (yterm=term(:y), treatname=:g, treatintterms=(term(:z),), xterms=(term(:x),))
 
     sptype, name, args1, kwargs1 = parse_didargs(TestDID,
         @formula(y ~ treat(g, ttreat(t, 0), tpara(0)) & z + x))
@@ -111,30 +114,52 @@ end
 end
 
 @testset "StatsSpec" begin
+    @testset "== ≊" begin
+        sp1 = StatsSpec(DefaultDID, "", NamedTuple(), NamedTuple())
+        sp2 = StatsSpec(DefaultDID, "name", NamedTuple(), NamedTuple())
+        @test sp1 == sp2
+        @test sp1 ≊ sp2
+
+        sp1 = StatsSpec(DefaultDID, "", (tr=TR, pr=PR), (a=1, b=2))
+        sp2 = StatsSpec(DefaultDID, "", (pr=PR, tr=TR), (b=2, a=1))
+        @test sp1 != sp2
+        @test sp1 ≊ sp2
+
+        sp2 = StatsSpec(DefaultDID, "", (tr=TR, pr=PR), (a=1.0, b=2.0))
+        @test sp1 == sp2
+        @test sp1 ≊ sp2
+
+        sp2 = StatsSpec(DefaultDID, "", (tr=TR, pr=PR), (a=1, b=2, c=3))
+        @test !(sp1 ≊ sp2)
+
+        sp2 = StatsSpec(DefaultDID, "", (tr=TR, pr=PR), (a=1, b=1))
+        @test !(sp1 ≊ sp2)
+    end
+
     @testset "show" begin
-        sp = StatsSpec(DefaultDID, "", Dict{Symbol,Any}(), Dict{Symbol,Any}())
+        sp = StatsSpec(DefaultDID, "", NamedTuple(), NamedTuple())
         @test sprint(show, sp) == "StatsSpec{DefaultDID}"
         @test sprintcompact(sp) == "StatsSpec{DefaultDID}"
 
-        sp = StatsSpec(DefaultDID, "name", Dict{Symbol,Any}(), Dict{Symbol,Any}())
+        sp = StatsSpec(DefaultDID, "name", NamedTuple(), NamedTuple())
         @test sprint(show, sp) == "StatsSpec{DefaultDID}: name"
         @test sprintcompact(sp) == "StatsSpec{DefaultDID}: name"
 
-        sp = StatsSpec(TestDID, "", Dict(:tr=>dynamic(:time,-1), :pr=>nevertreated(-1)),
-            Dict{Symbol,Any}())
+        sp = StatsSpec(TestDID, "", (tr=dynamic(:time,-1), pr=nevertreated(-1)),
+            NamedTuple())
         @test sprint(show, sp) == """
             StatsSpec{TestDID}:
               Dynamic{S}(-1)
               NeverTreated{U,P}([-1])"""
         @test sprintcompact(sp) == "StatsSpec{TestDID}"
 
-        sp = StatsSpec(TestDID, "", Dict(:tr=>dynamic(:time,-1)), Dict{Symbol,Any}())
+        sp = StatsSpec(TestDID, "", (tr=dynamic(:time,-1),), NamedTuple())
         @test sprint(show, sp) == """
             StatsSpec{TestDID}:
               Dynamic{S}(-1)"""
         @test sprintcompact(sp) == "StatsSpec{TestDID}"
 
-        sp = StatsSpec(TestDID, "name", Dict(:pr=>nevertreated(-1)), Dict{Symbol,Any}())
+        sp = StatsSpec(TestDID, "name", (pr=nevertreated(-1),), NamedTuple())
         @test sprint(show, sp) == """
             StatsSpec{TestDID}: name
               NeverTreated{U,P}([-1])"""
@@ -145,11 +170,11 @@ end
 @testset "didspec" begin
     testname = "name"
 
-    sp = StatsSpec(DefaultDID, "", Dict{Symbol,Any}(), Dict{Symbol,Any}())
+    sp = StatsSpec(DefaultDID, "", NamedTuple(), NamedTuple())
     @test didspec() == sp
     @test sp.name == ""
 
-    sp = StatsSpec(DefaultDID, "name", Dict{Symbol,Any}(), Dict{Symbol,Any}())
+    sp = StatsSpec(DefaultDID, "name", NamedTuple(), NamedTuple())
     @test didspec("") == sp
     @test sp.name == "name"
 
@@ -165,31 +190,30 @@ end
     @test sp == didspec()
     @test sp.name == "name"
 
-    sp0 = StatsSpec(TestDID, "", Dict(:tr=>TR, :pr=>PR), Dict(:a=>1, :b=>2))
+    sp0 = StatsSpec(TestDID, "", (tr=TR, pr=PR), (a=1, b=2))
     sp1 = didspec(TestDID, TR, PR, a=1, b=2)
-    @test sp1 == sp0
-    @test sp0 == @didspec TR a=1 b=2 PR TestDID
+    @test sp1 === sp0
+    @test sp0 === @didspec TR a=1 b=2 PR TestDID
 
-    sp2 = StatsSpec(TestDID, "name", Dict(:tr=>TR, :pr=>PR), Dict(:a=>1, :b=>2))
+    sp2 = StatsSpec(TestDID, "name", (tr=TR, pr=PR), (a=1, b=2))
     sp3 = didspec("name", TR, PR, TestDID, b=2, a=1)
-    @test sp3 == sp2
-    @test sp3 == sp1
-    @test sp2 == @didspec TR PR TestDID "name" b=2 a=1
+    @test sp2 == sp1
+    @test sp3 ≊ sp2
+    @test sp3 === @didspec TR PR TestDID "name" b=2 a=1
 
-    sp4 = StatsSpec(TestDID, testname, Dict(:tr=>TR, :pr=>PR), Dict(:treatname=>:g))
+    sp4 = StatsSpec(TestDID, testname, (tr=TR, pr=PR), (treatname=:g,))
     sp5 = didspec(TestDID, testterm)
     @test sp5 == sp4
-    @test sp4 == @didspec TestDID testterm testname
+    @test sp4 === @didspec TestDID testterm testname
 
-    sp6 = StatsSpec(TestDID, "name", Dict(:tr=>TR, :pr=>PR),
-        Dict(:yterm=>term(:y), :treatname=>:g,
-        :treatintterms=>(term(:z),), :xterms=>(term(:x),)))
+    sp6 = StatsSpec(TestDID, "", (tr=TR, pr=PR),
+        (yterm=term(:y), treatname=:g, treatintterms=(term(:z),), xterms=(term(:x),)))
     sp7 = didspec(TestDID, term(:y) ~ testterm & term(:z) + term(:x))
     sp8 = didspec(TestDID, @formula(y ~ treat(g, ttreat(t, 0), tpara(0)) & z + x))
     @test sp7 == sp6
-    @test sp8 == sp7
-    @test sp6 == @didspec TestDID term(:y) ~ testterm & term(:z) + term(:x)
-    @test sp6 == @didspec TestDID @formula(y ~ treat(g, ttreat(t, 0), tpara(0)) & z + x)
+    @test sp8 === sp7
+    @test sp6 === @didspec TestDID term(:y) ~ testterm & term(:z) + term(:x)
+    @test sp6 === @didspec TestDID @formula(y ~ treat(g, ttreat(t, 0), tpara(0)) & z + x)
 end
 
 @testset "@did" begin