feat: allow nothing for operators

Author: MilesCranmer

src/Expression.jl

@@ -41,7 +41,7 @@ end
 Base.show(io::IO, x::Metadata) = print(io, "Metadata(", unpack_metadata(x), ")")
 @inline _copy(x) = copy(x)
 @inline _copy(x::NamedTuple) = copy_named_tuple(x)
-@inline _copy(x::Nothing) = nothing
+@inline _copy(::Nothing) = nothing
 @inline function copy_named_tuple(nt::NamedTuple)
     return NamedTuple{keys(nt)}(map(_copy, values(nt)))
 end
@@ -251,7 +251,13 @@ end
 function get_variable_names(
     ex::Expression, variable_names::Union{Nothing,AbstractVector{<:AbstractString}}=nothing
 )
-    return variable_names === nothing ? ex.metadata.variable_names : variable_names
+    return if variable_names !== nothing
+        variable_names
+    elseif hasproperty(ex.metadata, :variable_names)
+        ex.metadata.variable_names
+    else
+        nothing
+    end
 end
 function get_tree(ex::Expression)
     return ex.tree

src/ParametricExpression.jl

@@ -87,9 +87,9 @@ end
 function ParametricExpression(
     tree::ParametricNode{T1};
     operators::Union{AbstractOperatorEnum,Nothing},
-    variable_names,
+    variable_names=nothing,
     parameters::AbstractMatrix{T2},
-    parameter_names,
+    parameter_names=nothing,
 ) where {T1,T2}
     if !isnothing(parameter_names)
         @assert size(parameters, 1) == length(parameter_names)
@@ -202,18 +202,16 @@ function get_variable_names(
     ex::ParametricExpression,
     variable_names::Union{Nothing,AbstractVector{<:AbstractString}}=nothing,
 )
-    return variable_names === nothing ? ex.metadata.variable_names : variable_names
+    return if variable_names !== nothing
+        variable_names
+    elseif hasproperty(ex.metadata, :variable_names)
+        ex.metadata.variable_names
+    else
+        nothing
+    end
 end
-@inline _copy_with_nothing(x) = copy(x)
-@inline _copy_with_nothing(::Nothing) = nothing
 function Base.copy(ex::ParametricExpression; break_sharing::Val=Val(false))
-    return ParametricExpression(
-        copy(ex.tree; break_sharing=break_sharing);
-        operators=_copy_with_nothing(ex.metadata.operators),
-        variable_names=_copy_with_nothing(ex.metadata.variable_names),
-        parameters=_copy_with_nothing(ex.metadata.parameters),
-        parameter_names=_copy_with_nothing(ex.metadata.parameter_names),
-    )
+    return ParametricExpression(copy(ex.tree; break_sharing), copy(ex.metadata))
 end
 ###############################################################################
 

src/Strings.jl

@@ -139,7 +139,7 @@ function string_tree(
     operators::Union{AbstractOperatorEnum,Nothing}=nothing;
     f_variable::F1=string_variable,
     f_constant::F2=string_constant,
-    variable_names::Union{AbstractVector{<:AbstractString},Nothing}=nothing,
+    variable_names=nothing,
     pretty::Union{Bool,Nothing}=nothing, # Not used, but can be used by other types
     # Deprecated
     raw::Union{Bool,Nothing}=nothing,
@@ -190,7 +190,7 @@ for io in ((), (:(io::IO),))
         operators::Union{AbstractOperatorEnum,Nothing}=nothing;
         f_variable::F1=string_variable,
         f_constant::F2=string_constant,
-        variable_names::Union{AbstractVector{<:AbstractString},Nothing}=nothing,
+        variable_names=nothing,
         pretty::Union{Bool,Nothing}=nothing, # Not used, but can be used by other types
         # Deprecated
         raw::Union{Bool,Nothing}=nothing,

src/StructuredExpression.jl

@@ -143,7 +143,13 @@ function get_variable_names(
     e::AbstractStructuredExpression,
     variable_names::Union{AbstractVector{<:AbstractString},Nothing}=nothing,
 )
-    return variable_names === nothing ? get_metadata(e).variable_names : variable_names
+    return if variable_names !== nothing
+        variable_names
+    elseif hasproperty(get_metadata(e), :variable_names)
+        get_metadata(e).variable_names
+    else
+        nothing
+    end
 end
 function get_scalar_constants(e::AbstractStructuredExpression)
     # Get constants for each inner expression

test/test_expressions.jl

@@ -269,7 +269,7 @@ end
 
 @testitem "Miscellaneous expression calls" begin
     using DynamicExpressions
-    using DynamicExpressions: get_tree, get_operators
+    using DynamicExpressions: get_tree, get_operators, default_node_type
 
     ex = @parse_expression(x1 + 1.5, binary_operators = [+], variable_names = ["x1"])
     @test DynamicExpressions.ExpressionModule.node_type(ex) <: Node
@@ -278,6 +278,24 @@ end
 
     tree = get_tree(ex)
     @test_throws ArgumentError get_operators(tree, nothing)
+
+    # We can also define expressions without variable names, and it should work
+    operators = OperatorEnum(; binary_operators=[+])
+    for E in (Expression, ParametricExpression)
+        N = default_node_type(E)
+        kws = (; operators)
+        if E === ParametricExpression
+            kws = (; kws..., parameters=Matrix{Float64}(undef, 0, 0))
+        end
+        x1, x2 = (E(N(Float64; feature=i); kws...) for i in 1:2)
+        x1000 = E(N(Float64; feature=1000); kws...)
+        @test string(x1 + x2 + x1000) == "(x1 + x2) + x1000"
+        # And also with structured expressions
+        x1 = StructuredExpression(
+            (; x1, x2, x1000); operators, structure=nt -> nt.x1 + nt.x2 + nt.x1000
+        )
+        @test string(x1) == "(x1 + x2) + x1000"
+    end
 end
 
 @testitem "Expression Literate examples" begin