9

我注意到在执行代码单态化的语言（例如：C++、Rust 等）中实现多态递归类型是非常困难的，如果不是不可能的话。这通常是因为编译器需要为该类型的每个可能的实例化生成代码，这通常会导致无限递归。

支持这一点的语言通常使用类型擦除。编译器不会尝试实例化下一个递归调用，因为它已经知道类型的布局。

Julia 执行代码单态化，但它支持多态递归。我的猜测是，它通过延迟实例化泛型类型或函数直到它被实际调用来做到这一点。但是，我认为这最终可能会使用大量内存，尤其是当递归非常深时。所以我的问题是，julia 是否仍会为多态递归类型执行代码单态化，还是回退到类型擦除或其他方法？

4

1 回答 1

6

这个问题看起来非常类似于Reducing JIT time with recursive calls in Julia

为了回答这个问题，我将调整、更正和详细说明那里给出的代码。

首先是一些定义：

abstract type BiTree{T} end

struct Branch{T} <: BiTree{T} 
    left::BiTree{T}
    right::BiTree{T}
end

struct Leaf{T} <: BiTree{T}
    value::T
end

Base.foldl(f, b::Branch) = f(foldl(f, b.left), foldl(f, b.right))
Base.foldl(f, l::Leaf) = f(l.value)


# fancy and concise constructor operations
(⊕)(l::Branch, r::Branch) = Branch(l, r) # just for illustration
(⊕)(l, r::Branch) = Branch(Leaf(l), r)
(⊕)(l::Branch, r) = Branch(l, Leaf(r))
(⊕)(l, r) = Branch(Leaf(l), Leaf(r))

这里我们有一个抽象类型和两个子类型，一个组合用于树中的内部节点，一个组合用于叶子。我们还有一个两行递归操作来定义如何折叠或减少树中的值，以及一个简洁的树中缀构造函数。

如果我们定义my_tree然后用加法折叠它，我们会得到：

julia> my_tree = ((((6 ⊕ 7) ⊕ (6 ⊕ 7)) ⊕ ((7 ⊕ 7) ⊕ (0 ⊕ 7))) ⊕ (((8 ⊕ 7) ⊕ (7 ⊕ 7)) ⊕ ((8 ⊕ 8) ⊕ (8 ⊕ 0)))) ⊕ ((((2 ⊕ 4) ⊕ 7) ⊕ (6 ⊕ (0 ⊕ 5))) ⊕ (((6 ⊕ 8) ⊕ (2 ⊕ 8)) ⊕ ((2 ⊕ 1) ⊕ (4 ⊕ 5))));

julia> typeof(my_tree)
Branch{Int64}

julia> foldl(+, my_tree)
160

请注意，类型my_tree完全暴露了它是具有某种子节点的内部节点，但我们无法真正看到它有多深。我们没有像Branch{Branch{Leaf{Int32}, Branch{.... Branch{Int64}这是 a的事实BiTree{Int64}是可见的

julia> isa(my_tree, BiTree{Int64})
true

但是仅从my_tree单独的值看不到它，并且在类型中看不到深度。

如果我们将生成的方法视为迄今为止我们工作的副作用，我们会看到

julia> using MethodAnalysis

julia> methodinstances(⊕)
4-element Vector{Core.MethodInstance}:
 MethodInstance for ⊕(::Branch{Int64}, ::Branch{Int64})
 MethodInstance for ⊕(::Int64, ::Branch{Int64})
 MethodInstance for ⊕(::Branch{Int64}, ::Int64)
 MethodInstance for ⊕(::Int64, ::Int64)

julia> methodinstances(foldl)
3-element Vector{Core.MethodInstance}:
 MethodInstance for foldl(::typeof(+), ::Branch{Int64})
 MethodInstance for foldl(::typeof(+), ::Leaf{Int64})
 MethodInstance for foldl(::typeof(+), ::BiTree{Int64})

无论我们尝试构建什么样的 32 位整数树，这就是我们所需要的。无论我们尝试用 减少什么树+，这就是我们所需要的。

如果我们尝试用不同的操作符折叠，我们可以获得更多的方法

julia> foldl(max, my_tree)
8

julia> methodinstances(foldl)
6-element Vector{Core.MethodInstance}:
 MethodInstance for foldl(::typeof(+), ::Branch{Int64})
 MethodInstance for foldl(::typeof(max), ::Branch{Int64})
 MethodInstance for foldl(::typeof(+), ::Leaf{Int64})
 MethodInstance for foldl(::typeof(max), ::Leaf{Int64})
 MethodInstance for foldl(::typeof(+), ::BiTree{Int64})
 MethodInstance for foldl(::typeof(max), ::BiTree{Int64})

这里有趣的是方法的数量增加了，但并没有爆炸。

于 2021-12-25T22:47:22.443 回答