Schema application to solitary term (#208)

* add broken cases to tests

* reduce(+,...) instead of unconditionally sum

* actually do some tests for singleton tuple term

* patch version bump

* add unary +operator for AbstractTerm

* make codecov happy, tuple everything

Author: palday

Project.toml

@@ -1,6 +1,6 @@
 name = "StatsModels"
 uuid = "3eaba693-59b7-5ba5-a881-562e759f1c8d"
-version = "0.6.18"
+version = "0.6.19"
 
 [deps]
 DataAPI = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a"

src/schema.jl

@@ -60,7 +60,7 @@ Base.haskey(schema::Schema, key) = haskey(schema.schema, key)
 Compute all the invariants necessary to fit a model with `terms`.  A schema is a dict that
 maps `Term`s to their concrete instantiations (either `CategoricalTerm`s or
 `ContinuousTerm`s.  "Hints" may optionally be supplied in the form of a `Dict` mapping term
-names (as `Symbol`s) to term or contrast types.  If a hint is not provided for a variable, 
+names (as `Symbol`s) to term or contrast types.  If a hint is not provided for a variable,
 the appropriate term type will be guessed based on the data type from the data column: any
 numeric data is assumed to be continuous, and any non-numeric data is assumed to be
 categorical.
@@ -93,7 +93,7 @@ StatsModels.Schema with 1 entry:
   y => y
 ```
 
-Note that concrete `ContinuousTerm` and `CategoricalTerm` and un-typed `Term`s print the 
+Note that concrete `ContinuousTerm` and `CategoricalTerm` and un-typed `Term`s print the
 same in a container, but when printed alone are different:
 
 ```jldoctest 1
@@ -203,9 +203,9 @@ end
 Return a new term that is the result of applying `schema` to term `t` with
 destination model (type) `Mod`.  If `Mod` is omitted, `Nothing` will be used.
 
-When `t` is a `ContinuousTerm` or `CategoricalTerm` already, the term will be returned 
-unchanged _unless_ a matching term is found in the schema.  This allows 
-selective re-setting of a schema to change the contrast coding or levels of a 
+When `t` is a `ContinuousTerm` or `CategoricalTerm` already, the term will be returned
+unchanged _unless_ a matching term is found in the schema.  This allows
+selective re-setting of a schema to change the contrast coding or levels of a
 categorical term, or to change a continuous term to categorical or vice versa.
 
 When defining behavior for custom term types, it's best to dispatch on
@@ -214,7 +214,7 @@ in _most_ cases, but cause method ambiguity in some.
 """
 apply_schema(t, schema) = apply_schema(t, schema, Nothing)
 apply_schema(t, schema, Mod::Type) = t
-apply_schema(terms::TupleTerm, schema, Mod::Type) = sum(apply_schema.(terms, Ref(schema), Mod))
+apply_schema(terms::TupleTerm, schema, Mod::Type) = reduce(+, apply_schema.(terms, Ref(schema), Mod))
 
 apply_schema(t::Term, schema::Schema, Mod::Type) = schema[t]
 apply_schema(ft::FormulaTerm, schema::Schema, Mod::Type) =
@@ -284,7 +284,7 @@ function apply_schema(t::FormulaTerm, schema::Schema, Mod::Type{<:StatisticalMod
 end
 
 # strategy is: apply schema, then "repair" if necessary (promote to full rank
-# contrasts).  
+# contrasts).
 #
 # to know whether to repair, need to know context a term appears in.  main
 # effects occur in "own" context.

src/terms.jl

@@ -42,7 +42,7 @@ width(::ConstantTerm) = 1
     FormulaTerm{L,R} <: AbstractTerm
 
 Represents an entire formula, with a left- and right-hand side.  These can be of
-any type (captured by the type parameters).  
+any type (captured by the type parameters).
 
 # Fields
 
@@ -64,7 +64,7 @@ data table.
 
 The `FunctionTerm` _also_ captures the arguments of the original call and parses
 them _as if_ they were part of a special DSL call, applying the rules to expand
-`*`, distribute `&` over `+`, and wrap symbols in `Term`s.  
+`*`, distribute `&` over `+`, and wrap symbols in `Term`s.
 
 By storing the original function as a type parameter _and_ pessimistically
 parsing the arguments as if they're part of a special DSL call, this allows
@@ -78,7 +78,7 @@ on `apply_schema(f::FunctionTerm{typeof(special_syntax)}, schema,
 * `forig::Forig`: the original function (e.g., `log`)
 * `fanon::Fanon`: the generated anonymous function (e.g., `(a, b) -> log(1+a+b)`)
 * `exorig::Expr`: the original expression passed to `@formula`
-* `args_parsed::Vector`: the arguments of the call passed to `@formula`, each 
+* `args_parsed::Vector`: the arguments of the call passed to `@formula`, each
   parsed _as if_ the call was a "special" DSL call.
 
 # Type parameters
@@ -113,7 +113,7 @@ julia> modelcols(f.rhs, (a=3, b=4))
 julia> modelcols(f.rhs, (a=[3, 4], b=[4, 5]))
 2-element Array{Float64,1}:
  2.0794415416798357
- 2.302585092994046 
+ 2.302585092994046
 ```
 """
 struct FunctionTerm{Forig,Fanon,Names} <: AbstractTerm
@@ -132,7 +132,7 @@ Base.:(==)(a::FunctionTerm, b::FunctionTerm) = a.forig == b.forig && a.exorig ==
 """
     InteractionTerm{Ts} <: AbstractTerm
 
-Represents an _interaction_ between two or more individual terms.  
+Represents an _interaction_ between two or more individual terms.
 
 Generated by combining multiple `AbstractTerm`s with `&` (which is what calls to
 `&` in a `@formula` lower to)
@@ -223,8 +223,8 @@ Represents a categorical term, with a name and [`ContrastsMatrix`](@ref)
 # Fields
 
 * `sym::Symbol`: The name of the variable
-* `contrasts::ContrastsMatrix`: A contrasts matrix that captures the unique 
-  values this variable takes on and how they are mapped onto numerical 
+* `contrasts::ContrastsMatrix`: A contrasts matrix that captures the unique
+  values this variable takes on and how they are mapped onto numerical
   predictors.
 """
 struct CategoricalTerm{C,T,N} <: AbstractTerm
@@ -242,9 +242,9 @@ CategoricalTerm(sym::Symbol, contrasts::ContrastsMatrix{C,T}) where {C,T} =
 
 A collection of terms that should be combined to produce a single numeric matrix.
 
-A matrix term is created by [`apply_schema`](@ref) from a tuple of terms using 
+A matrix term is created by [`apply_schema`](@ref) from a tuple of terms using
 [`collect_matrix_terms`](@ref), which pulls out all the terms that are matrix
-terms as determined by the trait function [`is_matrix_term`](@ref), which is 
+terms as determined by the trait function [`is_matrix_term`](@ref), which is
 true by default for all `AbstractTerm`s.
 """
 struct MatrixTerm{Ts<:TupleTerm} <: AbstractTerm
@@ -311,7 +311,7 @@ is_matrix_term(::Type{<:AbstractTerm}) = true
 
 
 """
-    capture_call(f_orig::Function, f_anon::Function, argnames::NTuple{N,Symbol}, 
+    capture_call(f_orig::Function, f_anon::Function, argnames::NTuple{N,Symbol},
                  ex_orig::Expr, args_parsed::Vector{AbstractTerm})
 
 When the [`@formula`](@ref) macro encounters a call to a function that's not
@@ -404,6 +404,7 @@ Base.:&(terms::AbstractTerm...) = InteractionTerm(terms)
 Base.:&(term::AbstractTerm) = term
 Base.:&(it::InteractionTerm, terms::AbstractTerm...) = InteractionTerm((it.terms..., terms...))
 
+Base.:+(a::AbstractTerm) = a
 Base.:+(a::AbstractTerm, b::AbstractTerm) = a==b ? a : (a, b)
 Base.:+(as::TupleTerm, b::AbstractTerm) = b in as ? as : (as..., b)
 Base.:+(a::AbstractTerm, bs::TupleTerm) = a in bs ? bs : (a, bs...)
@@ -437,7 +438,7 @@ end
 """
     modelcols(ts::NTuple{N, AbstractTerm}, data) where N
 
-When a tuple of terms is provided, `modelcols` broadcasts over the individual 
+When a tuple of terms is provided, `modelcols` broadcasts over the individual
 terms.  To create a single matrix, wrap the tuple in a [`MatrixTerm`](@ref).
 
 # Example
@@ -448,7 +449,7 @@ julia> using StableRNGs; rng = StableRNG(1);
 julia> d = (a = [1:9;], b = rand(rng, 9), c = repeat(["d","e","f"], 3));
 
 julia> ts = apply_schema(term.((:a, :b, :c)), schema(d))
-a(continuous) 
+a(continuous)
 b(continuous)
 c(DummyCoding:3→2)
 
@@ -498,8 +499,8 @@ modelcols(t::CategoricalTerm, d::NamedTuple) = t.contrasts[d[t.sym], :]
 """
     reshape_last_to_i(i::Int, a)
 
-Reshape `a` so that its last dimension moves to dimension `i` (+1 if `a` is an 
-`AbstractMatrix`).  
+Reshape `a` so that its last dimension moves to dimension `i` (+1 if `a` is an
+`AbstractMatrix`).
 """
 reshape_last_to_i(i, a) = a
 reshape_last_to_i(i, a::AbstractVector) = reshape(a, ones(Int, i-1)..., :)
@@ -557,7 +558,7 @@ Return the name(s) of column(s) generated by a term.  Return value is either a
 StatsBase.coefnames(t::FormulaTerm) = (coefnames(t.lhs), coefnames(t.rhs))
 StatsBase.coefnames(::InterceptTerm{H}) where {H} = H ? "(Intercept)" : []
 StatsBase.coefnames(t::ContinuousTerm) = string(t.sym)
-StatsBase.coefnames(t::CategoricalTerm) = 
+StatsBase.coefnames(t::CategoricalTerm) =
     ["$(t.sym): $name" for name in t.contrasts.termnames]
 StatsBase.coefnames(t::FunctionTerm) = string(t.exorig)
 StatsBase.coefnames(ts::TupleTerm) = reduce(vcat, coefnames.(ts))
@@ -580,7 +581,7 @@ omitsintercept(t::TermOrTerms) =
 
 hasresponse(t) = false
 hasresponse(t::FormulaTerm) =
-    t.lhs !== nothing && 
+    t.lhs !== nothing &&
     t.lhs !== ConstantTerm(0) &&
     t.lhs !== InterceptTerm{false}()
 

test/schema.jl

@@ -9,6 +9,12 @@
         @test f == apply_schema(f, schema(f, df))
     end
 
+    @testset "lonely term in a tuple" begin
+        d = (a = [1,1],)
+        @test apply_schema(ConstantTerm(1), schema(d)) == apply_schema((ConstantTerm(1),), schema(d))
+        @test apply_schema(Term(:a), schema(d)) == apply_schema((Term(:a),), schema(d))
+    end
+
     @testset "hints" begin
         f = @formula(y ~ 1 + a)
         d = (y = rand(10), a = repeat([1,2], outer=2))
@@ -20,7 +26,7 @@
         @test sch1[term(:a)] isa CategoricalTerm{DummyCoding}
         f1 = apply_schema(f, sch1)
         @test f1.rhs.terms[end] == sch1[term(:a)]
-        
+
         sch2 = schema(f, d, Dict(:a => DummyCoding()))
         @test sch2[term(:a)] isa CategoricalTerm{DummyCoding}
         f2 = apply_schema(f, sch2)
@@ -39,7 +45,7 @@
         using StatsModels: has_schema
 
         d = (y = rand(10), a = rand(10), b = repeat([:a, :b], 5))
-        
+
         f = @formula(y ~ a*b)
         @test !has_schema(f)
         @test !has_schema(f.rhs)
@@ -63,5 +69,5 @@
         @test has_schema(sch[a] & sch[b])
 
     end
-    
+
 end

test/terms.jl

@@ -51,7 +51,7 @@ StatsModels.apply_schema(mt::MultiTerm, sch::StatsModels.Schema, Mod::Type) =
         @test mimestring(t2full) == "aaa(StatsModels.FullDummyCoding:2→2)"
         @test string(t2full) == "aaa"
     end
-    
+
     @testset "term operators" begin
         a = term(:a)
         b = term(:b)
@@ -84,6 +84,9 @@ StatsModels.apply_schema(mt::MultiTerm, sch::StatsModels.Schema, Mod::Type) =
         @test b+ab == ab
         @test ab+ab == ab
         @test ab+bc == abc
+        @test sum((a,b,c)) == abc
+        @test sum((a,)) == a
+        @test +a == a
     end
 
     @testset "uniqueness of FunctionTerms" begin
@@ -169,5 +172,5 @@ StatsModels.apply_schema(mt::MultiTerm, sch::StatsModels.Schema, Mod::Type) =
         end
 
     end
-    
+
 end