Julia中的函数类型

如何解决Julia中的函数类型

请考虑以下代码：

julia> function foo(x::Float64)::Float64
           return 2x
       end
foo (generic function with 1 method)

julia> typeof(foo)
typeof(foo)

肯定有一个原因，为什么typeof(foo)不会返回更有意义的内容，例如(Float64 -> Float64)。什么事？

我在看Zygote code时遇到了这个问题。

解决方法

编写typeof(foo)时，您在询问功能 foo的类型。该函数可以具有多个方法（类型稳定与否---但这是另一个问题），并且这些方法具有不同的签名（参数的类型），对于某些方法，编译器可能能够推断返回类型，而对于其他人则不然（您不应该依赖它AFAICT ---只需假设大多数情况下编译器做正确的工作即可。）

举个例子，考虑下面的代码（1个函数，2个方法）：

julia> f1(::Int) = 1
f1 (generic function with 1 method)

julia> f1(::Bool) = 2
f1 (generic function with 2 methods)

julia> typeof(f1)
typeof(f1)

julia> methods(f1)
# 2 methods for generic function "f1":
[1] f1(::Bool) in Main at REPL[21]:1
[2] f1(::Int64) in Main at REPL[20]:1

现在像您编写的那样参考返回值规范：

f(x)::Float64 = x

它们不仅仅是断言。朱莉娅实际上做了两件事：

它将返回值转换为请求的类型
断言转换成功

这与例如在上面的函数f中，您可以编写：

julia> f(1)
1.0

julia> f(true)
1.0

您会看到转换（不仅是断言）发生了。

此类型与类型不稳定的代码（例如，使用DataFrame是类型不稳定的数据结构）非常相关，因为这样的断言可以帮助“破坏代码中的类型不稳定链”（如果有一部分）类型不稳定）

编辑

使用Union{Int,Bool} -> Int无法解决此问题吗？例如f1？同样对于类型不稳定性？我猜想这将需要针对所有输入类型编译代码，从而失去JIT的优势？

但是如果为Int返回了Int，而对于Bool返回了Bool，该怎么办？考虑例如identity函数。

也采用以下示例：

julia> f(x) = ("a",)[x]
f (generic function with 1 method)

julia> @code_warntype f(2)
Variables
  #self#::Core.Compiler.Const(f,false)
  x::Int64

Body::String
1 ─ %1 = Core.tuple("a")::Core.Compiler.Const(("a",),false)
│   %2 = Base.getindex(%1,x)::String
└──      return %2

julia> Base.return_types(f)
1-element Array{Any,1}:
 Any

@code_warntype正确地标识出，如果该函数返回某些内容，则可以肯定是String，但是，正如Przemysław建议的return_types告诉您它是Any。因此，您可以看到这是一件困难的事情，您不应盲目地依赖它-只需假设由编译器决定可以推断出什么即可。特别是出于性能原因，即使理论上可能，编译器也可能会放弃推理。

在您的问题中，您可能指的是例如Haskell提供了，但是在Haskell中有一个限制，即函数的返回值可能不取决于传递的参数的运行时值，而仅取决于参数的类型。朱莉娅没有这种限制。

让我给你看一下以供比较：

julia> struct var"typeof(foo)" end

julia> const foo = var"typeof(foo)"()
var"typeof(foo)"()

julia> (::var"typeof(foo)")(x::Float64) = 2x

julia> (::var"typeof(foo)")(x::String) = x * x

julia> foo(0.2)
0.4

julia> foo("sdf")
"sdfsdf"

julia> typeof(foo)
var"typeof(foo)"

这大约是内部发生的情况。当您编写function foo时，编译器会生成类似带有内部名称typeof(foo)和实例foo的匿名单例结构。然后，所有方法或“调度组合”都按其类型注册。

您看到给foo这样的类型Float -> Float或String -> String毫无意义-函数只是单例值，并且它的类型结构的类型。该结构对其方法一无所知（在内部，在真正的编译器中，它当然知道，但不是以类型系统可访问的方式）。

从理论上讲，您可以设计一个系统，在该系统中，函数的所有方法都以某种联合类型收集，但是由于函数类型在其共域中是协变的而在它们的共变量中是互变的，因此它变得异常庞大且复杂域。因此尚未完成。话虽这么说，人们使用are discussing语法来指代 method 实例本身的类型，这正是您所考虑的。

函数定义末尾的::Float64只是类型声明（如果可能的话，还可以进行转换）-它不会以任何方式直接帮助编译器。

要了解它，让我们考虑以下功能：

f(a,b) = a//b

对于一对Int值，将返回Rational{Int}。让我们检查一下Julia编译器可以做什么：

julia> code_warntype(f,[Int,Int])
Variables
  #self#::Core.Compiler.Const(f,false)
  a::Int64
  b::Int64

Body::Rational{Int64}
1 ─ %1 = (a // b)::Rational{Int64}
└──      return %1

或者对于其他输入对：

julia> code_warntype(f,[Int16,Int16])
Variables
  #self#::Core.Compiler.Const(f,false)
  a::Int16
  b::Int16

Body::Rational{Int16}
1 ─ %1 = (a // b)::Rational{Int16}
└──      return %1

您可以看到编译器可以基于输入类型来计算输出类型。因此，Julia代码中的唯一规则是“始终编写类型稳定的代码”。考虑一下功能：

g(a,b) = b != 0 ? a/b : a

让我们测试一下类型：

julia> code_warntype(g,Int])
Variables
  #self#::Core.Compiler.Const(g,false)
  a::Int64
  b::Int64

Body::Union{Float64,Int64}
1 ─ %1 = (b != 0)::Bool
└──      goto #3 if not %1
2 ─ %3 = (a / b)::Float64
└──      return %3
3 ─      return a

在Julia REPL Union{Float64,Int64}中以红色显示，这意味着代码类型不稳定（返回int或float）。

最后但并非最不重要的一点是，还可以要求函数输出类型：

julia> Base.return_types(f,(Int8,Int16))
1-element Array{Any,1}:
 Rational{Int16}

julia> Base.return_types(g,(Int,Float64))
1-element Array{Any,1}:
 Union{Float64,Int64}

结论：

无需声明Julia函数的输出类型-这是编译器的工作
定义自己的输出类型就像类型声明一样（或可用于结果类型转换-请参阅Bogumil的答案）
为了在Julia中确定函数的输出类型，需要所有输入的类型（不仅仅是方法名称）

Julia中的函数类型

如何解决Julia中的函数类型

解决方法

相关推荐