First off, while not exactly perfectly worded for this question (is push different from splice?), the foreach documentation in perlsyn says, in part:

       If any part of LIST is an array, "foreach" will get very confus
+ed if
       you add or remove elements within the loop body, for example wi
+th
       "splice".   So don’t do that.
[download]

Now, as to how to do this: no, I don't know a clean way to do that, either. map doesn't quite do it:

  @foo = map { 'd' eq $_ ? ($_,'h') : $_ } @foo;
  # puts 'h' right after 'd'
[download]

my @extras;
foreach my $x (@foo) {
  push @extras, 'h' if $x eq 'd';
  print $x;
}
push @foo, @extras;
# didn't print 'h'.  But if we add:
print foreach @extras;
# that works ... but duplicates code.
[download]

{
  my @extras;
  foreach my $x (@foo) {
    push @extras, 'h' if $x eq 'd';
  }
  push @foo, @extras;
}
foreach my $x (@foo)
{
  print $x;
}
[download]

If any part of LIST is an array, "foreach" will get very 
confused if you add or remove elements within the loop 
body, for example with "splice".   So don’t do that.

Isn't this just saying if one is manipulating an element that is itself an array, not the LIST itself? I would think as long as one stuck to scalars, it should be OK, although one would have to be careful.

Update: This one works... iffy (same ballpark), but works:

@foo = qw/a b c d e f g/;

map{ push @foo, 'h' if /^d$/ } @foo;

print @foo, "\n";
[download]


I think it's a case of simply having enough rope to hang yourself.

Your last description calls for reprocessing @extras until it is empty:

my @foo = qw/a b c d e f g/;
my $sub = 'h';
for (my @extras = @foo; @extras; @extras = my @new_extras) {
    foreach my $x (@extras) {
    push @new_extras, $sub++ if $x =~ /[dhij]/;
    }
    push @foo, @new_extras;
}
print for @foo;
# Tacks on h when it hits the d, then
# i for the h, j for the i, and k for the j
# yielding abcdefghijk
[download]

I like how the for replaces the bare block for scoping.

You can also do it without the @new_extras variable by replacing the foreach loop/push combination with a map:

my @foo = qw/a b c d e f g/;
my $sub = 'h';
for (my @extras = @foo; @extras;) {
    @extras = map { /[dhij]/ ? $sub++ : () } @extras;
    push @foo, @extras;
}
print for @foo;
[download]

---

Caution: Contents may have been coded under pressure.

my @foo = qw/a b c d e f g/;
for my $x (@foo) {
    push @foo, 'd' if $x eq 'd';
    print $x;
}
[download]

push @foo, map {$_ eq 'd' ? 'd' : ()} @foo;
print for @foo;
[download]

Still, it's not a nice trick to play. Here's an even more diabolical one:

for (@foo) {
  print;
  shift(@foo) if $_ eq 'c';
}
print "\n@foo\n";
[download]

Elements in for are flattened to a list before processing. The array should be ignored after the initial entry into the loop--it will only process the list it created. It should be safe to add elements to the array, though I would hesitate to rely on this behavior.

That's not the behavior the OP was seeing, so you definitely can't rely on it. The iterator will process elements that were added on to the end of the array within the loop.

---

Caution: Contents may have been coded under pressure.

Yeah that's a definite "don't do that". You should either make a duplicate of the array, or in the case that you're just appending you could iterate over indices instead of the array itself.

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.

my $i = 0;
while ($i <= $#foo)
{
    push @foo, 'h' if $foo[$i] eq 'd';
    print $foo[$i];
    $i++;
}
[download]

It occurred to me that in my real code I don't actually need the value of @foo afterwards, so I should just use shift:

while (@foo) {
   my $x = shift @foo;
   push @foo, 'h' if whatever();
}
[download]