Юлия Сплат, оператор распаковки

Question

В Python можно использовать * оператор в распаковке итерируемый.

In [1]: head, *tail = [1, 2, 3, 4, 5]

In [2]: head
Out[2]: 1

In [3]: tail
Out[3]: [2, 3, 4, 5]

Я хотел бы показать такое же поведение в Юлии. Я понял, что эквивалент ... оператор будет работать, но, похоже, просто выдаст ошибку в этом контексте.

julia> head, tail... = [1, 2, 3, 4, 5]
ERROR: syntax: invalid assignment location "tail..."

Я смог получить желаемые результаты, используя следующее, но это уродливое решение.

julia> head, tail = A[1], A[2:end]
(1,[2,3,4,5])

Можно ли распаковать массив так, чтобы tail будет содержать остальные предметы после head используя сплат (...) оператор? Если нет, то какая самая чистая альтернатива?

---

Изменить: эта функция была предложена в # 2626. Похоже, что это будет частью версии 1.0.

Answer 1

Это действительно похоже на работу для макроса:

function unpack(lhs, rhs) 
    len = length(lhs.args)
    if len == 1
        # just remove the splatting
        l, is_splat = remove_splat(lhs.args[1])
        return :($l = $(esc(rhs)))
    else
        new_lhs = :()
        new_rhs = quote 
            tmp = $(esc(rhs))
            $(Expr(:tuple)) 
        end
        splatted = false
        for (i, e) in enumerate(lhs.args)
            l, is_splat = remove_splat(e)
            if is_splat
                splatted && error("Only one splatting operation allowed on lhs")
                splatted = true
                r = :(tmp[$i:end-$(len-i)])
            elseif splatted
                r = :(tmp[end-$(len-i)])
            else
                r = :(tmp[$i])
            end
            push!(new_lhs.args, l)
            push!(new_rhs.args[4].args, r)
        end
        return :($new_lhs =  $new_rhs)
    end
end

remove_splat(e::Symbol) = esc(e),  false

function remove_splat(e::Expr)
    if e.head == :(...)
        return esc(e.args[1]), true
    else
        return esc(e), false
    end
end

macro unpack(expr)
    if Meta.isexpr(expr, :(=))
        if Meta.isexpr(expr.args[1], :tuple)
            return unpack(expr.args[1], expr.args[2])
        else
            return unpack(:(($(expr.args[1]),)), expr.args[2])
        end
    else
        error("Cannot parse expression")
    end
end

Это не очень хорошо проверено, но основные вещи работают:

julia> @unpack head, tail... = [1,2,3,4]
(1,[2,3,4])

julia> @unpack head, middle..., tail = [1,2,3,4,5]
(1,[2,3,4],5)

Несколько джулийских ошибок:

x,y = [1,2,3] #=> x = 1, y = 2

a = rand(3)
a[1:3], y = [1,2,3] #=> a = [1.0,1.0,1.0], y = 2

Макрос следует за этим поведением

@unpack a[1:3], y... = [1,2,3]
#=> a=[1.0,1.0,1.0], y=[2,3]

Answer 2

Начиная с Юлии 1.6

Теперь можно использовать ... в левой части деструктурированных назначений для получения любого количества элементов из передней части итерируемой коллекции, а также для сбора остальных.

Пример присвоения первых двух пунктов, прихлебывая остальные:

      julia> a, b, c... = [4, 8, 15, 16, 23, 42]
# 6-element Vector{Int64}:
#   4
#   8
#  15
#  16
#  23
#  42

julia> a
# 4

julia> b
# 8

julia> c
# 4-element Vector{Int64}:
#  15
#  16
#  23
#  42

Этот синтаксис реализован с использованием Base.rest, который можно перегрузить, чтобы настроить его поведение.

Пример перегрузки Base.rest(s::Union{String, SubString{String}}, i::Int) отхлебать Vector{Char} вместо значения по умолчанию SubString:

      julia> a, b... = "hello"
julia> b
# "ello"

julia> Base.rest(s::Union{String, SubString{String}}, i=1) = collect(SubString(s, i))
julia> a, b... = "hello"
julia> b
# 4-element Vector{Char}:
#  'e': ASCII/Unicode U+0065 (category Ll: Letter, lowercase)
#  'l': ASCII/Unicode U+006C (category Ll: Letter, lowercase)
#  'l': ASCII/Unicode U+006C (category Ll: Letter, lowercase)
#  'o': ASCII/Unicode U+006F (category Ll: Letter, lowercase)