`Tuple` 中的 `Vararg` 类型参数的疑问

June-6th · 2019 年6 月 29 日 03:24

首先定义一些变量

julia> T1 = Tuple{Vararg{T, 2}} where T; T2 = Tuple{Vararg{T, 2} where T};

我感觉应该有 T1 == T2，可是在 Julia 中我得到了以下结果：

julia> T1 == T2
false

julia> T1 <: T2
true

julia> T1 >: T2
false

如果把 Vararg 替换成 Array，倒是会符合我的预测：

julia> (Tuple{Array{T, 2}} where T) == Tuple{Array{T, 2} where T}
true

以上关系成立的原因是什么，或者说这是一个 bug 吗？

woclass · 2019 年6 月 30 日 06:58

不带分号就能看出差别

julia> T1 = Tuple{Vararg{T, 2}} where T
Tuple{Vararg{T,2}} where T

julia> T2 = Tuple{Vararg{T, 2} where T}
Tuple{Any,Any}

julia> T1 == T2
false

julia> (1, 2) isa T1
true

julia> (1, 2) isa T2
true

julia> (1, 2.0) isa T1
false

julia> (1, 2.0) isa T2
true

T1 限定了两个参数必须是一样的类型；而 T2 两个参数的类型可以不一样

June-6th · 2019 年6 月 30 日 08:52

我就是对 T2 的值感到奇怪，我以为会等于 Tuple{T, T} where T（与 T1 相等），实际上却等于 Tuple{T, S} where {T, S}（与 Tuple{Any, Any} 相等），T2 定义里的类型约束平白无故就没了。此外，我还发现了一个奇怪的现象，见此 issue。

woclass · 2019 年6 月 30 日 15:05

@test isequal_type(Type{Tuple{Vararg{Int,N}} where N}, Type{Tuple{Vararg{Int,N} where N}})
@test Type{Tuple{Vararg{Int,N}} where N} !== Type{Tuple{Vararg{Int,N} where N}}

julia/subtype.jl at f77743ca1e2988d5bcfa68c0b1745e518827e2d3 · JuliaLang/julia

test 里测试了 where N 的位置是没有影响的，不知道为什么没有测试 where T

目前 v1.1.1 的情况

julia> Type{Tuple{Vararg{Int,N}} where N} == Type{Tuple{Vararg{Int,N} where N}}
true

julia> Type{Tuple{Vararg{T,2}} where T} == Type{Tuple{Vararg{T,2} where T}}
false

let A = Tuple{Vararg{Val{N}, N} where N},
    B = Tuple{Vararg{Val{N}, N}} where N,
    C = Tuple{Val{2}, Val{2}}

    @test isequal_type(A, B)
    @test issub(C, B)
    @test issub(C, A)
end

julia/subtype.jl at f77743ca1e2988d5bcfa68c0b1745e518827e2d3 · JuliaLang/julia

julia> Tuple{Vararg{Val{N}, N} where N} == Tuple{Vararg{Val{N}, N}} where N
true

julia> Tuple{Vararg{Val{N}, 2} where N} == Tuple{Vararg{Val{N}, 2}} where N
false

julia> Tuple{Vararg{Val{2}, 2}} == Tuple{Vararg{Val{2}, 2}}
true

julia> Tuple{Vararg{Val{N}, 2} where N <: Integer} == Tuple{Vararg{Val{N}, 2}} where N <: Integer
false

不是很懂

又看到一个相关的测试，不过没搞清楚 @testintersect 宏的功能

    # part of issue #20344
    @testintersect(Tuple{Type{Tuple{Vararg{T, N} where N}}, Tuple} where T,
                   Tuple{Type{Tuple{Vararg{T, N}}} where N where T, Any},
                   Bottom)

julia/subtype.jl at f77743ca1e2988d5bcfa68c0b1745e518827e2d3 · JuliaLang/julia

shilu1984 · 2019 年7 月 1 日 09:58

T2的约束是有的，如果定义成T2 = Tuple{Vararg{T, 2} where T<:Real};
那么T2的两个元素必须为Real，可能是两个int的组合，也可能是int和float的组合，这点手册里面有说道UnionAll Types，如果是Tuple{T, S} where {T, S}，两个元素可一点关联都没有。

woclass · 2019 年7 月 2 日 11:02

楼主想说的是，像 T2 应该和 T1 一样，有两个参数都是同类型的约束。
而不是两个 Any，两个 Any 就可以是不一样的类型（例子见我的第一个回复）。

julia> T2 = Tuple{Vararg{T, 2} where T}
Tuple{Any,Any}

Jun · 2019 年7 月 31 日 17:29

我最近也遇到了类似的问题，梳理下，也许对其它人有用。

假如我想定义一个函数，可以接受任意长度任意类型的positional arguments，那么可以这么定义：

f(x...) = nothing

其实也就等效于

f(x::Any...) = nothing

表明这里的每个参数都是Any类型。

假如我希望，每个参数都需要有相同的类型，那么，一般来说会这么写：

julia> g(x::T...) where T = nothing
g (generic function with 1 method)

julia> g(1,2)

julia> g(1,:a)
ERROR: MethodError: no method matching g(::Int64, ::Symbol)
Closest candidates are:
  g(::T...) where T at REPL[6]:1
Stacktrace:
 [1] top-level scope at none:0

而不会这么写：

julia> h(x::T where T...) = nothing
ERROR: syntax: invalid variable expression in "where"

上面可以看到，这么写其实都会报错。

不过，前面我们使用了...这个语法，其实是可以拿掉的，也就变成了Vararg。接下来看下有什么不同：

如果想接收任意个数的positional parameter，那么可以直接这么定义：

julia> m(x::Vararg) = x
m (generic function with 1 method)

julia> m
m (generic function with 1 method)

julia> methods(m)
# 1 method for generic function "m":
[1] m(x...) in Main at REPL[24]:

如果希望所有的参数都有相同的类型，那么这样写：

julia> n(x::Vararg{T}) where T = x
n (generic function with 1 method)

julia> methods(n)
# 1 method for generic function "n":
[1] n(x::T...) where T in Main at REPL[27]:

终于到了这个帖子的主题了，问题在于，还有下面这种写法：

julia> o(x::Vararg{T} where T) = x
o (generic function with 1 method)

julia> methods(o)
# 1 method for generic function "o":
[1] o(x...) in Main at REPL[30]:

可以看到，这里其实等于没有修饰，类似地也就导致了楼主的问题。

为啥这样子呢，反正我还没弄懂

shilu1984 · 2019 年8 月 1 日 04:40

Jun:

终于到了这个帖子的主题了，问题在于，还有下面这种写法：
julia> o(x::Vararg{T} where T) = x
o (generic function with 1 method)

julia> methods(o)
# 1 method for generic function "o":
[1] o(x...) in Main at REPL[30]:  

说说我的理解，欢迎轻拍，这里的确很迷惑人。因为我觉得这里涉及到了函数（方法）参数与类型参数（UnionAll类型）混合的事情，那么我们要弄清楚这个参数到底是①函数的参数还是②类型的参数。
我的理解是：

放在函数括弧外面的就是函数的参数
跟在类型后面就是类型参数

第一个要说的是where T等效于where T<:Any，所以Vararg{T} where T 就是Vararg{<:Any}。需要说明的UnionAll的Vararg和NTuple比较奇怪,与一般的UnionAll类型有差别,举例：

julia> Vararg{Int, 4} <: Vararg{Any, 4}
true

julia> Array{Int, 1} <: Array{Any, 1}
false

julia> Array{Int, 1} <: Array{<:Any, 1}
true

上面主要还是扯UnionAll类型
我们现在再看函数参数

t3(x::Vararg{T} where T) = println(typeof(x))
t4(x::Vararg{T})  where T = println(typeof(x))

运行后

julia> t3(1, 2, 'c')
Tuple{Int64,Int64,Char}

julia> t4(1, 2, 'c')
ERROR: MethodError: no method matching t4(::Int64, ::Int64, ::Char)
Closest candidates are:
  t4(::T...) where T at REPL[21]:1
Stacktrace:
 [1] top-level scope at none:0

对于t3函数，其where只是UnionAll类型的表达方式，且Tuple{Int64,Int64,Char} <: Vararg{<:Any}是成立的。

而对于t4，函数参数就必须用一个concrete类型来取代，比如Int，Float64，对应的分别为t4(x::Vararg{Int})和t4(x::Vararg{Float64})，这样每给一个不同的参数，函数被编译一次从而获得该函数的不同方法。这也解释了为什么上面o和n函数不同的行为。

June-6th · 2019 年8 月 1 日 05:58

julia> f(x::Vararg{T} where T) = println(typeof(x), T)
f (generic function with 1 method)

julia> f(1)
ERROR: UndefVarError: T not defined

这种写法的类型参数在函数里不可见，所以说它取什么值意义不大。