Add useful fallbacks

Author: blegat

src/conversion.jl

@@ -36,6 +36,16 @@ function Base.convert(::Type{M}, t::AbstractTerm) where M <: AbstractMonomialLik
         throw(InexactError(:convert, M, t))
     end
 end
+function Base.convert(TT::Type{<:AbstractTerm{T}}, m::AbstractMonomialLike) where T
+    return convert(TT, one(T) * m)
+end
+function Base.convert(TT::Type{<:AbstractTerm{T}}, t::AbstractTerm) where T
+    return convert(TT, convert(T, coefficient(t)) * monomial(t))
+end
+function Base.convert(::Type{T}, t::T) where T <: AbstractTerm
+    return t
+end
+
 function Base.convert(::Type{T}, p::AbstractPolynomial) where T <: AbstractTermLike
     if iszero(nterms(p))
         convert(T, zeroterm(p))

src/monomial.jl

@@ -25,6 +25,7 @@ Note that the variables of `m` does not necessarily have nonzero degree.
 For instance, `variables([x^2*y, y*z][1])` is usually `(x, y, z)` since the two monomials have been promoted to a common type.
 """
 function variables end
+variables(t::AbstractTerm) = variables(monomial(t))
 
 """
     nvariables(p::AbstractPolynomialLike)
@@ -36,6 +37,7 @@ Returns the number of variables in `p`, i.e. `length(variables(p))`. It could be
 Calling `nvariables(x^2*y)` should return at least 2 and calling `nvariables(x)` should return at least 1.
 """
 nvariables(::Union{AbstractVariable, Type{<:AbstractVariable}}) = 1
+nvariables(p::APL) = length(variables(p))
 
 """
     exponents(t::AbstractTermLike)

src/promote.jl

@@ -15,6 +15,16 @@ Base.promote_rule(::Type{RS}, ::Type{RT}) where {RS<:RationalPoly, RT<:RationalP
 Base.promote_rule(::Type{PT}, ::Type{RT}) where {PT<:APL, RT<:RationalPoly} = promote_rule_rational(PT, RT)
 Base.promote_rule(::Type{RT}, ::Type{PT}) where {PT<:APL, RT<:RationalPoly} = promote_rule_rational(PT, RT)
 
+# Promotion with Term
+function Base.promote_rule(ST::Type{<:AbstractTermLike{S}}, TT::Type{<:AbstractTerm{T}}) where {S, T}
+    U = promote_type(S, T)
+    UT = termtype(ST, U)
+    if UT != termtype(TT, U)
+        error("Cannot promote `$ST` and `$TT` to the same type.")
+    end
+    return UT
+end
+
 #promote_rule(::Type{Term{C, U}}, ::Type{RationalPoly{C, S, T}}) where {C, S, T, U} = RationalPoly{C, promote_type(U, S), T}
 #promote_rule(::Type{RationalPoly{C, S, T}}, ::Type{Term{C, U}}) where {C, S, T, U} = RationalPoly{C, promote_type(U, S), T}
 #promote_rule(::Type{Polynomial{C, U}}, ::Type{RationalPoly{C, S, T}}) where {C, S, T, U} = RationalPoly{C, promote_type(U, S), T}

src/term.jl

@@ -51,6 +51,8 @@ Calling `coefficient` on ``4x^2y`` should return ``4``.
 Calling `coefficient(2x + 4y^2 + 3, y^2)` should return ``4``.
 Calling `coefficient(2x + 4y^2 + 3, x^2)` should return ``0``.
 """
+function coefficient end
+coefficient(t::AbstractTerm) = t.coefficient # by convention, the field should be `coefficient`
 coefficient(m::AbstractMonomialLike) = 1
 function coefficient(p::AbstractPolynomialLike{T}, m::AbstractMonomialLike) where T
     for t in terms(p)
@@ -116,6 +118,7 @@ Returns the monomial of the term `t`.
 Calling `monomial` on ``4x^2y`` should return ``x^2y``.
 """
 function monomial end
+monomial(t::AbstractTerm) = t.monomial # by convention, the field should be `monomial`.
 monomial(m::AbstractMonomial) = m
 
 """

src/variable.jl

@@ -35,27 +35,6 @@ This operation is not type stable for the TypedPolynomials implementation if `nv
 """
 variable(t::APL) = convert(variable_union_type(t), t)
 
-_errormono2var() = error("Monomial cannot be converted to a variable")
-_mono2var() = _errormono2var()
-function _checknovar() end
-function _checknovar(ve, ves...)
-    if iszero(ve[2])
-        _checknovar(ves...)
-    else
-        _errormono2var()
-    end
-end
-function _mono2var(ve, ves...)
-    if iszero(ve[2])
-        _mono2var(ves...)
-    elseif isone(ve[2])
-        _checknovar(ves...)
-        ve[1]
-    else
-        _errormono2var()
-    end
-end
-
 """
     name(v::AbstractVariable)::AbstractString
 

test/commutativetests.jl

@@ -1,4 +1,4 @@
-include("mutable_arithmetics.jl")
+#include("mutable_arithmetics.jl")
 
 include("zip.jl")
 include("variable.jl")