sorted children

Author: Alessandro Cheli

src/TermInterface.jl

@@ -51,10 +51,33 @@ export head
 """
     children(x)
 Returns the children (aka tail) of the S-expression.
+
+
+Depending on the type and internal representation of `x`,
+`children(x)` may return an unsorted collection nondeterministically,
+This is to make sure to retrieve the children of an AST node when the order of children does not matter,
+but the speed of the operation does.
+To ensure to retrieve children in a sorted manner, you can use 
+and implement the function `sorted_children`.
 """
 function children end
 export children
 
+"""
+    sorted_children(x::T)
+
+Returns the children of an AST node, in a **sorted fashion**.
+`isexpr(x)` must be true as a precondition. Analogous to `children`, 
+but ensures that the operation is deterministic and always returns 
+the children in the order they are stored.
+
+By default, this redirects to `children`, therefore implementing 
+it is optional.
+"""
+sorted_children(x) = children(x)
+export sorted_children
+
+
 """
     operation(x)
 

test/runtests.jl

@@ -23,24 +23,25 @@ end
 
 @testset "Unsorted arguments" begin
     struct Sum
-        d::Dict{Int, Any}
-        Sum(xs...) = new(Dict{Int, Any}(xs...))
+        d::Dict{Int,Any}
+        Sum(xs...) = new(Dict{Int,Any}(xs...))
     end
 
-    TermInterface.isexpr(s::Sum) = true 
+    TermInterface.isexpr(s::Sum) = true
     TermInterface.head(::Sum) = (+)
     TermInterface.operation(s::Sum) = head(s)
-    TermInterface.arguments(s::Sum) = [:($coeff * $val) for (coeff, val) in s.d]
-    TermInterface.children(s::Sum) = sorted_arguments(s)
-    TermInterface.sorted_arguments(s::Sum) = [:($coeff * $val) for (coeff, val) in sort!(collect(pairs(s.d)))]
+    TermInterface.children(s::Sum) = [:($coeff * $val) for (coeff, val) in s.d]
+    TermInterface.sorted_children(s::Sum) = [:($coeff * $val) for (coeff, val) in sort!(collect(pairs(s.d)))]
+    TermInterface.arguments(s::Sum) = children(s)
+    TermInterface.sorted_arguments(s::Sum) = sorted_children(s)
 
     s = Sum(1 => :A, 2 => :B, 3 => :C)
     @test operation(s) == head(s) == (+)
     args = arguments(s)
     @test :(1A) in args
     @test :(2B) in args
     @test :(3C) in args
-    
+
     @test sorted_arguments(s) == [:(1A), :(2B), :(3C)]
-    @test children(s) == sorted_arguments(s)
+    @test sorted_children(s) == sorted_arguments(s)
 end