G'day 7stud,

"1) From perldata/Slices: ... Why is indexing beyond the end of the list legal for a slice?"

Your question here seems to imply an assumption. This might be:

"Why is indexing beyond the end of the list legal for a slice when it's illegal for an array?"

which would be a false assumption.

You may want to correct or clarify that; however, in case that is the assumption you're making, consider this code:

#!/usr/bin/env perl -l

use strict;
use warnings;

print '*** Create @x with no elements ***';
my @x;
print 'Elements in @x: ', scalar @x;

print '*** Use array index beyond end as RHS of assignment ***';
my $y = $x[42];
print 'Value assigned from beyond end of @x: ', defined $y ? $y : '<un
+def>';
print 'Elements in @x: ', scalar @x;

print '*** Use array index beyond end as LHS of assignment ***';
$x[21] = 'hello';
for my $i (0, 10, 21, 32) {
    print "Index: $i";
    print 'Value: ', defined $x[$i] ? $x[$i] : '<undef>';
}
print 'Elements in @x: ', scalar @x;
[download]

Output:

*** Create @x with no elements ***
Elements in @x: 0
*** Use array index beyond end as RHS of assignment ***
Value assigned from beyond end of @x: <undef>
Elements in @x: 0
*** Use array index beyond end as LHS of assignment ***
Index: 0
Value: <undef>
Index: 10
Value: <undef>
Index: 21
Value: hello
Index: 32
Value: <undef>
Elements in @x: 22
[download]

"2) I think the slice docs should mention the case when you assign an empty list to a hash slice, like this:"

I can't find any specific mention of that in perldata. Someone else may be able to point you to another manual page that does explain this. In any event, you can always use perlbug to request changes or additions to documentation.

"It's not obvious(to me at least) why the value undef gets assigned to the sliced keys. It seems to me that the hash could just as well look like:"

Instead of the hash slice assignment:

@hash{'goodbye', 'world'} = ();
[download]

Consider the individual assignments to each key:

#!/usr/bin/env perl

use strict;
use warnings;

use Data::Dumper;

my %hash = ('hello', 1, 'goodbye', 2, 'world', 3, 'mars', 4);
print Dumper \%hash;

$hash{goodbye} = ()[0];
$hash{world} = ()[1];
print Dumper \%hash;
[download]

Output:

$VAR1 = {
          'hello' => 1,
          'goodbye' => 2,
          'world' => 3,
          'mars' => 4
        };
$VAR1 = {
          'hello' => 1,
          'goodbye' => undef,
          'world' => undef,
          'mars' => 4
        };
[download]

That may help in understanding what is going on when an empty list is assigned to a hash slice.

Here's a further example where the list being assigned has less elements than the hash slice has keys:

#!/usr/bin/env perl

use strict;
use warnings;

use Data::Dumper;

my %hash = ('hello', 1, 'goodbye', 2, 'world', 3, 'mars', 4);
print Dumper \%hash;

@hash{'goodbye', 'world'} = ('farewell');
print Dumper \%hash;
[download]

Output:

$VAR1 = {
          'hello' => 1,
          'goodbye' => 2,
          'world' => 3,
          'mars' => 4
        };
$VAR1 = {
          'hello' => 1,
          'goodbye' => 'farewell',
          'world' => undef,
          'mars' => 4
        };
[download]

Your question here seems to imply an assumption. This might be: "Why is indexing beyond the end of the list legal for a slice when it's illegal for an array?

Yes, I think I was confused by that because I did this:

use strict;
use warnings;
use 5.014;  

my @arr = ();

if (exists $arr[0]) {
    say 'yes';
}
else {
    say 'no';
}

say $arr[0];

--output:--
no
Use of uninitialized value in say at 1.pl line 15.
[download]

And the error convinced me that you can't index beyond the end of the array, but as you pointed out and as "Learning Perl" (6th) says on p. 45:

If the subscript indicates an element that would be beyond the end of the array, the corresponding value will be undef.

For comparison:

my @arr = (undef);

if (exists $arr[0]) {
    say 'yes';
}
else {
    say 'no';
}

say $arr[0];

--output:--
yes
Use of uninitialized value $arr[0] in say at 1.pl line 14.
[download]

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

But a slice of an empty array (or beyond the present size of the array) is a list of undefs.

So:

• @slice = ()[1,0,2];       # @slice is empty
• @slice = (@slice)[1,0,2]; # @slice is still empty
• @slice = @slice[1,0,2];   # now @slice contains three undefs

Right, it's just that the following is a bit confusing:

@b = (1..3)[3, 4];  # "empty" slice of a non-empty list;
                    # @b is empty, which is fine

@b = (1..3)[2, 3];  # the slice is "half empty",
                    # and yet @b now has TWO elements, not one
[download]

I understand you find it confusing, but there is a valid reason for it.

The basic principle is that you get a slice of exactly the length you asked it to be, padded with undefs if necessary, UNLESS the whole slice would have to be padded with undefs, in which case you get an empty list which is FALSE in any boolean test.

Actually it is a clear application of the principle of least surprise:

• It is the simplest way to distinguish between a slice from an empty list and a slice of a list of undefs. The former is FALSE, the latter is TRUE in a test.
• The slice returns you exactly the number of elements you asked it to return, not some unexpected or unpredictable smaller number.

Sometimes I like to think that the authors of Perl have thought long and hard and deep about all these issues. It is a comforting thought.

CountZero

A program should be light and agile, its subroutines connected like a string of pearls. The spirit and intent of the program should be retained throughout. There should be neither too little or too much, neither needless loops nor useless variables, neither lack of structure nor overwhelming rigidity." - The Tao of Programming, 4.1 - Geoffrey James

My blog: Imperial Deltronics

More generally, a slice yields the empty list if it indexes only beyond the end of a list

    @a = (1)[1,0];          # @a has two elements
                            # OK, this one is fine

    # but what about these:

    @b = (1,undef)[1,0,2];  # @b has three elements
                            # where does that third element come from?

    # or we could rewrite the above B case like this
    # and still get three elements:
    @b = (1)[1,0,2];        # why three and not *TWO*?

    @a = (1)[  1,2];        # @a has no elements
                            # !?
[download]