refactor: remove redundant parts of interface

Author: MilesCranmer

src/ArrayNode.jl

@@ -337,8 +337,6 @@ function get_children(n::ArrayNode{T,D,S}, ::Val{d}) where {T,D,S,d}
     end, Val(Int(d)))
 end
 
-get_children(n::ArrayNode, d::Integer) = get_children(n, Val(d))
-
 function set_children!(n::ArrayNode{T,D,S}, cs::Tuple) where {T,D,S}
     tree = getfield(n, :tree)
     idx = getfield(n, :idx)
@@ -384,167 +382,4 @@ end
 
 Base.copy(n::ArrayNode) = copy_node(n)
 
-# count_nodes - optimized version that checks if we're at root
-function count_nodes(n::ArrayNode)
-    tree = getfield(n, :tree)
-    idx = getfield(n, :idx)
-    # Optimization: if this is the root of the tree, just return total nodes
-    if tree.root_idx == idx
-        return Int(tree.n_nodes)
-    else
-        # Fall back to tree_mapreduce for subtrees
-        return tree_mapreduce(_ -> 1, +, n, Int)
-    end
-end
-
-# Equality and hash
-function Base.:(==)(a::ArrayNode, b::ArrayNode)
-    a.degree != b.degree && return false
-
-    if a.degree == 0
-        a.constant != b.constant && return false
-        if a.constant
-            return a.val == b.val
-        else
-            return a.feature == b.feature
-        end
-    else
-        a.op != b.op && return false
-
-        # Compare children recursively
-        for i in 1:(a.degree)
-            ca = get_children(a, Val(Int(a.degree)))[i]
-            cb = get_children(b, Val(Int(b.degree)))[i]
-            ca != cb && return false
-        end
-        return true
-    end
-end
-
-function Base.hash(n::ArrayNode, h::UInt=zero(UInt))
-    if n.degree == 0
-        if n.constant
-            return hash((0, n.val), h)
-        else
-            return hash((1, n.feature), h)
-        end
-    else
-        children_hashes = ntuple(
-            i -> begin
-                child = get_children(n, Val(Int(n.degree)))[i]
-                hash(child, h)
-            end, Val(Int(n.degree))
-        )
-        return hash((n.degree + 1, n.op, children_hashes), h)
-    end
-end
-
-# set_node! implementation
-function set_node!(dst::ArrayNode, src::ArrayNode)
-    dst_tree = getfield(dst, :tree)
-    src_tree = getfield(src, :tree)
-    dst_idx = getfield(dst, :idx)
-    src_idx = getfield(src, :idx)
-
-    dst.degree = src.degree
-
-    if src.degree == 0
-        dst.constant = src.constant
-        if src.constant
-            dst.val = src.val
-        else
-            dst.feature = src.feature
-        end
-    else
-        dst.op = src.op
-
-        D = max_degree(typeof(dst))
-        child_indices = ntuple(
-            i -> begin
-                if i <= src.degree
-                    child_idx = @inbounds src_tree.nodes.children[src_idx][i]
-                    if child_idx > 0
-                        if dst_tree === src_tree
-                            # Same tree
-                            child_idx
-                        else
-                            # Different tree - need to copy
-                            copy_subtree!(dst_tree, src_tree, child_idx)
-                        end
-                    else
-                        UInt16(0)
-                    end
-                else
-                    UInt16(0)
-                end
-            end,
-            Val(D),
-        )
-        dst_tree.nodes.children[dst_idx] = child_indices
-    end
-
-    return nothing
-end
-
-# tree_mapreduce and any
-function tree_mapreduce(
-    f::F,
-    op::G,
-    n::ArrayNode,
-    (::Type{RT})=Any;
-    f_on_shared=nothing,
-    break_sharing=Val(false),
-    kwargs...,
-) where {F<:Function,G<:Function,RT}
-    tree = getfield(n, :tree)
-    return mapreduce_impl(f, op, tree, getfield(n, :idx))
-end
-
-@inline function mapreduce_impl(f::F, op::G, tree::ArrayTree{T,D,S}, idx::UInt16) where {F,G,T,D,S}
-    degree = @inbounds tree.nodes.degree[idx]
-    node = ArrayNode{T,D,S}(tree, idx)
-    result = @inline f(node)
-
-    if degree > 0
-        child_results = ntuple(
-            i -> begin
-                child_idx = @inbounds tree.nodes.children[idx][i]
-                if child_idx > 0
-                    mapreduce_impl(f, op, tree, child_idx)
-                else
-                    nothing
-                end
-            end, Val(Int(degree))
-        )
-
-        # Filter out nothings and apply op
-        valid_results = filter(x -> !isnothing(x), child_results)
-        if !isempty(valid_results)
-            return op(result, valid_results...)
-        end
-    end
-
-    return result
-end
-
-function any(f::F, n::ArrayNode) where {F<:Function}
-    tree = getfield(n, :tree)
-    return any_impl(f, tree, getfield(n, :idx))
-end
-
-function any_impl(f::F, tree::ArrayTree{T,D,S}, idx::UInt16) where {F,T,D,S}
-    node = ArrayNode{T,D,S}(tree, idx)
-    f(node) && return true
-
-    degree = @inbounds tree.nodes.degree[idx]
-    for i in 1:degree
-        child_idx = @inbounds tree.nodes.children[idx][i]
-        if child_idx > 0 && any_impl(f, tree, child_idx)
-            return true
-        end
-    end
-
-    return false
-end
-
 end # module