Base.last(::Tuple,::Integer) and Base.first(::Tuple,::Integer) return Vectors

[jecs]

When calling Base.last(::Tuple,::Int), the result is of type Vector, but when you manually index into the tuple, the result is a tuple. Is this an intentional design choice? It seems counter-intuitive. The same applies to Base.first.

1. The output of versioninfo():

Julia Version 1.10.4
Commit 48d4fd48430 (2024-06-04 10:41 UTC)
Build Info:
  Official https://julialang.org/ release
Platform Info:
  OS: macOS (arm64-apple-darwin22.4.0)
  CPU: 8 × Apple M2
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-15.0.7 (ORCJIT, apple-m1)
Threads: 4 default, 0 interactive, 2 GC (on 4 virtual cores)
Environment:
  JULIA_EDITOR = vim

2. I installed Julia using the Homebrew command brew install julia.
3. MWE:

t = (1,2,3,4); @show Base.last(t,2); @show t[end-1:end]; println(); @show Base.first(t,2); @show t[1:2];

with output

Base.last(t, 2) = [3, 4]
t[end - 1:end] = (3, 4)

Base.first(t, 2) = [1, 2]
t[1:2] = (1, 2)

A simple way to fix it would be to define the following functions.

function Base.last(t::Tuple,n::Integer)
    n < 0 && throw(ArgumentError("Number of elements must be nonnegative"))
    @inbounds t[range(stop=lastindex(t), length=min(n, Base.checked_length(t)))]
end
function Base.first(t::Tuple,n::Integer)
    n < 0 && throw(ArgumentError("Number of elements must be nonnegative"))
    @inbounds t[range(begin, length=min(n, Base.checked_length(t)))]
end

[nsajko]

If these invocations returned Tuple (instead of Vector), it wouldn't be possible to have a type stable implementation. I.e., the return type would depend on the value of the second argument.

[mbauman]

That's not necessarily a problem, and often these functions are called with constants. For example, the t[end-2:end] construct is type stable:

julia> last(t::Tuple, n::Int) =  t[max(begin,end-n+1):end];

julia> last((1,2.3,4,5//6), 2)
(4, 5//6)

julia> g(tup) = last(tup, 2)
g (generic function with 1 method)

julia> @code_warntype g((1,2.3,4,5//6))
MethodInstance for g(::Tuple{Int64, Float64, Int64, Rational{Int64}})
  from g(tup) @ Main REPL[3]:1
Arguments
  #self#::Core.Const(g)
  tup::Tuple{Int64, Float64, Int64, Rational{Int64}}
Body::Tuple{Int64, Rational{Int64}}
1 ─ %1 = Main.last(tup, 2)::Tuple{Int64, Rational{Int64}}
└──      return %1

As to whether return a Vector here is an intentional choice — no, it's just the default for any unspecialized iterator.

[jecs]

Another option is to have a specialized version taking ::Val{N} instead of ::Integer that would guarantee type stability.

Thanks for the clarification.