debugging - eltype 样式功能的 Julia 方法错误

Question

我有一个抽象容器 AbstractContainer 参数化了一个 T 类型，它指示容器中内容的类型。然后每个子类型(在本例中为 FloatContainer)指定容器中的实际内容(在本例中为 Float64)。

理想情况下，如果我只有容器类型，我就有办法返回容器中的类型。这样我就可以在另一个结构中使用它(在这个例子中 MultiplyBy)

我正在考虑以类似于 Julia 的内部 eltype 函数的方式来实现它，但我无法让它工作。我总是收到方法错误(请参阅最后一个片段以获取详细的错误消息)

abstract type AbstractContainer{T} end


gettype(::Type{AbstractContainer{T}}) where T = T

struct FloatContainer <: AbstractContainer{Float64}
  x::Float64
end


struct MultiplyBy{T<:AbstractContainer}
  x::gettype(T)
end


function process(m::MultiplyBy, v::AbstractContainer)
  return typeof(v)(m.x*v.x)
end


function main()
  x = FloatContainer(2.0)

  y = FloatContainer(3.0)
  op = MultiplyBy{FloatContainer}(y)

  z = process(op, x)
  println(z.x)
end


main()

ERROR: LoadError: MethodError: no method matching gettype(::TypeVar)
Closest candidates are:
  gettype(!Matched::Type{AbstractContainer{T}}) where T at /Users/.../test.jl:6

我必须承认我对 Julia 还很陌生，但我非常有兴趣了解它的更多信息。因此，我们将不胜感激任何提示 - 无论是关于如何以不同方式解决此问题还是我的错误所在。

Answer 1

确定元素类型

您的 gettype 不起作用，因为它分派(dispatch)抽象类型，但您的容器对象都将具有具体类型。你必须使用 subtype operator以便正确发送。

比较抽象类型的分派(dispatch):

julia> eltype1(::Type{AbstractContainer{T}}) where T = T
eltype1 (generic function with 1 method)

julia> eltype1(FloatContainer)
ERROR: MethodError: no method matching eltype1(::Type{FloatContainer})
Closest candidates are:
  eltype1(::Type{AbstractContainer{T}}) where T at REPL[4]:1
Stacktrace:
 [1] top-level scope at REPL[5]:1

julia> eltype1(AbstractContainer{Float64})
Float64

对抽象类型的子类型进行分派(dispatch):

julia> eltype2(::Type{<:AbstractContainer{T}}) where T = T
eltype2 (generic function with 1 method)

julia> eltype2(FloatContainer)
Float64

julia> eltype2(AbstractContainer{Float64})
Float64

优先分配变量而不是显式 eltype 调用

直接调用eltype通常是不必要的；您可以在调度期间显式设置参数类型。

此解决方案仅使用参数类型:

julia> struct Container{T}
           x::T
       end

julia> struct MultiplyBy{T}
           x::T
       end

julia> MulitplyBy(x::Container{T}) where T = MultiplyBy{T}(x.x)
MulitplyBy (generic function with 1 method)

julia> process(m::MultiplyBy, x::Container{T}) where T = Container{T}(m.x * x.x)
process (generic function with 1 method)

julia> a = Container(2.0)
Container{Float64}(2.0)

julia> b = Container(3.0)
Container{Float64}(3.0)

julia> op = MulitplyBy(b)
MultiplyBy{Float64}(3.0)

julia> process(op, a)
Container{Float64}(6.0)