Most of the stuff about "a list" vs "an array" so far in this thread is just bull; making up stuff to explain observations without actually hitting on anything real.

Perl has code that decides what to return when an array slice is done and it has code that decides what to return when a list slice is done. These different sections of code are not forced to return undef versus "nothing" based on some underlying difference in what an array is versus what a list is.

The real reason why those sections of code were written to handle these cases differently is documented just below the already quoted section of the documentation (perldata):

A slice of an empty list is still an empty list. Thus:

    @a = ()[1,0];           # @a has no elements
    @b = (@a)[0,1];         # @b has no elements
    @c = (0,1)[2,3];        # @c has no elements
[download]

But:

    @a = (1)[1,0];          # @a has two elements
    @b = (1,undef)[1,0,2];  # @b has three elements
[download]

This makes it easy to write loops that terminate when a null list is returned:

    while ( ($home, $user) = (getpwent)[7,0]) {
        printf "%-8s %s\n", $user, $home;
    }
[download]

And I think it is easy to see that somebody is much less likely to write like:

    while(  ( $home, $user )= @results[7,0]  ) {
        ...
    }
[download]

But I actually consider part of the documentation to be documenting a bug that was an accident of implementation. Quoting just the relevent parts:

A slice of an empty list is still an empty list. Thus:

    @c = (0,1)[2,3];        # @c has no elements
[download]

You see that @c is the result of a list slice of a non-empty list. The stated motivation explains why we want a list slice of an empty list to be empty (so that "failure" inside of the list slice gets communicated out to the "list assignment"). It doesn't explain why we want a slice of non-existent elements from the slicing of a list to magically disappear.

Sure, making out-of-bounds elements of a list slice disappear is one way to implement things in order to get "a slice of an empty list is empty". But I'd rather the implementation not have such side effects. That is, I'd rather the slicing of a non-empty list treated out-of-bound elements consistently with how they are handled with array slices (and hash slices). Heck, the documented behavior for all-out-of-bounds items is even inconsistent with how list slices themselves behave:

    @d= (1,2,3)[9,1,8];  # @d= (undef,2,undef);
[download]

I also believe that this behavior has changed subtly over the years. I know I've discussed/argued with Larry over this at least once.

BTW, if you want to avoid this particular bit of magic, you can rewrite your list slice as an array slice: [get_a_list()]->[7,0]. And, as quietly noted in the documentation, if you want this behavior for an array slice, just write it as a list slice: (@array)[7,0].