The difference between a list and an array is often ignored...

Indeed; for never iterates over an array. for always iterates over a list.

The difference between a list and an array is often ignored...

Indeed; for never iterates over an array. for always iterates over a list.

What do either of those mean? Based on later replies, it seems like people are interpretting it in terms of whether or not $_ is an alias or a copy. But saying "$_ is an alias" or "$_ is a copy" actually means something clear.

Is there some other meaning? For example, when foreach is given an array, it might make a new list of aliases to each array member and then iterate over that list, and thus not ever directly iterating through the array. Now that I think of that, it fits what you wrote quite well, but doesn't match how others interpretted it. I guess this behavior matters if you modify the array (adding or removing members) while you are in the loop and I suspect that is what foreach does.

Is that all that you meant or are there other aspects?

imp, what did you mean?

- tye        

In the first draft of this document I discussed list versus array, but decided to trim it down before posting since it was outside of my intended scope.

In that version I referenced a post by you that provided what I thought was a nice explanation:
Re: Differ. array and List (there is no List)

Indeed; for never iterates over an array. for always iterates over a list.

Doesn't this suggest that for iterates over the array, rather than over a list generated from the array?

c:\test>perl -wle"@a = 'a'..'f'; for( @a) { ++$_ }; print qq[@a]"
b c d e f g
[download]

Maybe this is semantics, but I'd like to understand.

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

Lingua non convalesco, consenesco et abolesco. -- Rule 1 has a caveat! -- Who broke the cabal?

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

No.

C:\>perl -wle"my $bar = 'NN';my @foo = 'b'..'c';for ( $bar, @foo ){ ++
+$_ } print qq! $bar @foo!"
 NO c d

C:->
[download]

After further thought, and a little caffeine, I have to confess that I'm not sure I understand the difference in this case. Doesn't the following example show that for does iterate over the array elements?

my @array= (1,2,3,4);
for my $item (@array) {
    pop @array;
    printf "Item: %s Array: %s\n",$item,join(', ', @array);
}
[download]

Output:

Item: 1 Array: 1, 2, 3
Item: 2 Array: 1, 2
[download]

If for was iterating over a list that would imply that it wa s divorced from the @array object, and that modifying the @array object would not affect the loop - no?

It does modify the elements because the elements are not copied to the list, instead, they are referenced there:

use Devel::Peek;

my @array = (1,2,3);
Dump \@array;

print "====\n";

foreach (@array) {
    Dump $_;
    print "----\n";
}
[download]

Will output:

SV = RV(0x193de54) at 0x22593c
  REFCNT = 1
  FLAGS = (TEMP,ROK)
  RV = 0x226680
  SV = PVAV(0x22a95c) at 0x226680
    REFCNT = 2
    FLAGS = (PADBUSY,PADMY)
    IV = 0
    NV = 0
    ARRAY = 0x19240d4
    FILL = 2
    MAX = 3
    ARYLEN = 0x0
    FLAGS = (REAL)
    Elt No. 0
    SV = IV(0x1926b90) at 0x225858
      REFCNT = 1
      FLAGS = (IOK,pIOK)
      IV = 1
    Elt No. 1
    SV = IV(0x1926b94) at 0x225918
      REFCNT = 1
      FLAGS = (IOK,pIOK)
      IV = 2
    Elt No. 2
    SV = IV(0x1926b98) at 0x225930
      REFCNT = 1
      FLAGS = (IOK,pIOK)
      IV = 3
====
SV = IV(0x1926b90) at 0x225858
  REFCNT = 2
  FLAGS = (IOK,pIOK)
  IV = 1
----
SV = IV(0x1926b94) at 0x225918
  REFCNT = 2
  FLAGS = (IOK,pIOK)
  IV = 2
----
SV = IV(0x1926b98) at 0x225930
  REFCNT = 2
  FLAGS = (IOK,pIOK)
  IV = 3
----
[download]

As you can see, the IVs printed in the for loop are the same ones from the array (same pointer value) but they now have a reference count REFCNT=2

This means that the IVs were referenced in the new list, so that's why modifying them there will also modify them in the array.

--
Leviathan.

No. Example Re^3: RFC - FAQ for Modification of a read-only value attempted Also see perlsyn (RTFM is good for you):

If any element of LIST is an lvalue, you can modify it by modifying VAR inside the loop. Conversely, if any element of LIST is NOT an lvalue, any attempt to modify that element will fail. In other words, the "foreach" loop index variable is an implicit alias for each item in the list that you're looping over.

Good point. I need to clarify that and iterate over a list of values in an array, versus the list of literals. Thanks.

The builtins for, map, grep, sort all operate on lists of references; same with foreach.

If for weren't iterating over a list of references, constructs like for(sort keys %hash) would not work as expected (or as they do ;-)

Consider this thospel code snippet

perl -le '@a=qw(a e f c b d); $_=$i++ for sort @a; print @a'
045213
[download]

which prints out the sequence of array indices needed to access the unsorted array elements in sorted order.

--shmem

_($_=" "x(1<<5)."?\n".q·/)Oo.  G°\        /
                              /\_¯/(q    /
----------------------------  \__(m.====·.(_("always off the crowd"))."·
");sub _{s./.($e="'Itrs `mnsgdq Gdbj O`qkdq")=~y/"-y/#-z/;$e.e && print}

post 300

Modification of a read-only value attempted

Common causes:

1. Treating a loop variable as an lvalue
2. Modifying $_ inside foreach, map or grep
3. Modifying elements of @_ directly
4. Modifying $a or $b inside sort
5. Autovivifying $a or $b inside sort
6. Modifying an unlocalized $_

Treating a loop variable as an lvalue

for my $x (1,2) {
  $x++;
}
[download]

Modifying $_ inside foreach, map or grep

for (1,2) {
  chomp;
}

for ("foo", @list) {
  s/foo/bar/;
}

@array = map  { $_++ } (1,2);
@array = grep { $_++ } (1,2);
[download]

sub incr {
  $_[0]++;
}
my $n = 1;
incr($n); # good
incr(1);  # bad
[download]

Modifying $a or $b inside sort

@array = sort { $a++ } (1,2);
[download]

Autovivifying $a or $b inside sort

my @bad;
$bad[0] = [1];
$bad[2] = [2];
@bad = sort {$a->[0] <=> $b->[0]} @bad;
[download]

for (1,2) {
  my $data = prompt_user();
}

sub prompt_user {
   print "Enter a number\n";
   while (<STDIN>) {
     # Do stuff
   }
}
[download]

The error will also occur in this simplified scenario:

for (1,2) {
    while (<STDIN>) {
    }
}
[download]

Guidelines to avoid read-only errors:

1. Don't treat loop variables as a lvalue if there is any chance a constant value will be included
2. Don't modify an unlocalized $_
3. Don't modify $_ inside map or grep
4. Don't modify $a or $b inside sort
5. Don't dereference $a or $b inside sort without checking that they exist and are references
6. Don't use $_ for the loop variable unless it is a very trivial loop
7. Don't modify elements of @_ directly

Notes

$_++ for (1,2);
$_++ for (1,@array);
@array = map {$_++} (1,@array);
[download]

my @array = (1,2);
for (@array) {
  $_++;
}
[download]

my ($x,$y) = (1,2);
for ($x,$y) {
  $_++;
}
[download]

• Re: Differ. array and List (there is no List)
• "List" Is a Four-Letter Word

You spend far too much time mentioning $_ when you and I both know it's irrelevant. Whether my alias is accessed via $_ or a named variable, it's the aliasing that's screwing up the person that's running into this message.

Good point - I let my original intent of covering the cases that appear most frequently in SoPW take control of the document.

I'll rework the examples to focus on the common problem areas more directly, and add a separate section for cautions related to $_.

Thanks for the feedback.