Formatting

Author: MilesCranmer

src/Equation.jl

@@ -131,7 +131,9 @@ constructorof(::Type{N}) where {N<:AbstractNode} = Base.typename(N).wrapper
 constructorof(::Type{<:Node}) = Node
 constructorof(::Type{<:GraphNode}) = GraphNode
 
-with_type_parameters(::Type{N}, ::Type{T}) where {N<:AbstractExpressionNode,T} = constructorof(N){T}
+function with_type_parameters(::Type{N}, ::Type{T}) where {N<:AbstractExpressionNode,T}
+    return constructorof(N){T}
+end
 with_type_parameters(::Type{<:Node}, ::Type{T}) where {T} = Node{T}
 with_type_parameters(::Type{<:GraphNode}, ::Type{T}) where {T} = GraphNode{T}
 

src/EquationUtils.jl

@@ -117,17 +117,16 @@ struct NodeIndex{T} <: AbstractNode
     NodeIndex(::Type{_T}) where {_T} = new{_T}(0, zero(_T))
     NodeIndex(::Type{_T}, val) where {_T} = new{_T}(0, convert(_T, val))
     NodeIndex(::Type{_T}, l::NodeIndex) where {_T} = new{_T}(1, zero(_T), l)
-    NodeIndex(::Type{_T}, l::NodeIndex, r::NodeIndex) where {_T} = new{_T}(2, zero(_T), l, r)
+    function NodeIndex(::Type{_T}, l::NodeIndex, r::NodeIndex) where {_T}
+        return new{_T}(2, zero(_T), l, r)
+    end
 end
 # Sharing is never needed for NodeIndex,
 # as we trace over the node we are indexing on.
 preserve_sharing(::Type{<:NodeIndex}) = false
 function Base.copy(node::NodeIndex{T}) where {T}
     return tree_mapreduce(
-        t -> NodeIndex(T, t.val),
-        (_, c...) -> NodeIndex(T, c...),
-        node,
-        NodeIndex{T};
+        t -> NodeIndex(T, t.val), (_, c...) -> NodeIndex(T, c...), node, NodeIndex{T};
     )
 end
 

src/base.jl

@@ -227,11 +227,7 @@ Apply a function to each node in a tree.
 """
 function foreach(f::Function, tree::AbstractNode; break_sharing::Val=Val(false))
     tree_mapreduce(
-        t -> (@inline(f(t)); nothing),
-        Returns(nothing),
-        tree,
-        Nothing;
-        break_sharing,
+        t -> (@inline(f(t)); nothing), Returns(nothing), tree, Nothing; break_sharing
     )
     return nothing
 end
@@ -245,8 +241,11 @@ specifying the `result_type` of `map_fnc` so the resultant array can
 be preallocated.
 """
 function filter_map(
-    filter_fnc::F, map_fnc::G, tree::AbstractNode, result_type::Type{GT};
-    break_sharing::Val=Val(false)
+    filter_fnc::F,
+    map_fnc::G,
+    tree::AbstractNode,
+    result_type::Type{GT};
+    break_sharing::Val=Val(false),
 ) where {F<:Function,G<:Function,GT}
     stack = Array{GT}(undef, count(filter_fnc, tree; init=0, break_sharing))
     filter_map!(filter_fnc, map_fnc, stack, tree; break_sharing)
@@ -259,8 +258,11 @@ end
 Equivalent to `filter_map`, but stores the results in a preallocated array.
 """
 function filter_map!(
-    filter_fnc::Function, map_fnc::Function, destination::Vector{GT}, tree::AbstractNode;
-    break_sharing::Val=Val(false)
+    filter_fnc::Function,
+    map_fnc::Function,
+    destination::Vector{GT},
+    tree::AbstractNode;
+    break_sharing::Val=Val(false),
 ) where {GT}
     pointer = Ref(0)
     foreach(tree; break_sharing) do t
@@ -291,15 +293,19 @@ end
 Map a function over a tree and return a flat array of the results in depth-first order.
 Pre-specifying the `result_type` of the function can be used to avoid extra allocations.
 """
-function map(f::F, tree::AbstractNode, result_type::Type{RT}=Nothing; break_sharing::Val=Val(false)) where {F<:Function,RT}
+function map(
+    f::F, tree::AbstractNode, result_type::Type{RT}=Nothing; break_sharing::Val=Val(false)
+) where {F<:Function,RT}
     if RT == Nothing
         return f.(collect(tree; break_sharing))
     else
         return filter_map(Returns(true), f, tree, result_type; break_sharing)
     end
 end
 
-function count(f::F, tree::AbstractNode; init=0, break_sharing::Val=Val(false)) where {F<:Function}
+function count(
+    f::F, tree::AbstractNode; init=0, break_sharing::Val=Val(false)
+) where {F<:Function}
     return tree_mapreduce(
         t -> @inline(f(t)) ? 1 : 0,
         +,
@@ -348,11 +354,15 @@ function mapreduce(
     if preserve_sharing(typeof(tree))
         @assert typeof(return_type) !== Undefined "Must specify `return_type` as a keyword argument to `mapreduce` if `preserve_sharing` is true."
     end
-    return tree_mapreduce(f, (n...) -> reduce(op, n), tree, return_type; f_on_shared, break_sharing)
+    return tree_mapreduce(
+        f, (n...) -> reduce(op, n), tree, return_type; f_on_shared, break_sharing
+    )
 end
 
 isempty(::AbstractNode) = false
-iterate(root::AbstractNode) = (root, collect(root; break_sharing=Val(true))[(begin + 1):end])
+function iterate(root::AbstractNode)
+    return (root, collect(root; break_sharing=Val(true))[(begin + 1):end])
+end
 iterate(::AbstractNode, stack) = isempty(stack) ? nothing : (popfirst!(stack), stack)
 in(item, tree::AbstractNode) = any(t -> t == item, tree)
 function length(tree::AbstractNode; break_sharing::Val=Val(false))

test/test_graphs.jl

@@ -260,13 +260,14 @@ end
     end
 
     @testset "Hashing" begin
-        x = GraphNode(feature=1)
-        x2 = GraphNode(feature=1)
+        x = GraphNode(; feature=1)
+        x2 = GraphNode(; feature=1)
         tree = GraphNode(1, x, x)
         tree2 = GraphNode(1, x2, x2)
         @test hash(tree) == hash(tree2)
         @test hash(tree) != hash(copy_node(tree; break_sharing=Val(true)))
-        @test hash(copy_node(tree; break_sharing=Val(true))) == hash(copy_node(tree; break_sharing=Val(true)))
+        @test hash(copy_node(tree; break_sharing=Val(true))) ==
+            hash(copy_node(tree; break_sharing=Val(true)))
         @test hash(Node(tree)) == hash(copy_node(tree; break_sharing=Val(true)))
     end
 
@@ -309,7 +310,7 @@ end
     end
 
     @testset "Various base utils" begin
-        x = GraphNode(feature=1)
+        x = GraphNode(; feature=1)
         tree = GraphNode(1, x, x)
         @test collect(tree) == [tree, x]
         @test collect(tree; break_sharing=Val(true)) == [tree, x, x]