The list of elements over which foreach iterates is on calculated before foreach starts. Changing the number of elements in the array should have no effect on the looping whatsoever.

Not what you want.

In practice, due to an optimisation and the fact that the stack isn't refcounted, changing the array over which you are iterating can cause the wrong values to be seen and fatal errors ("Use of freed value in iteration").

Not what you want.

You could use loop over the indexes (and use last as you should have been).

    my @fields = REQUIRED_FIELDS;
    for my $e (@$a) {
        for my $i (0..$#fields) {
            if ($e eq $fields[$i]) {
                $href->{$e} = 0;
                splice @fields, $i, 1;
                last;
            }
        }
    }
[download]

But a hash would be better.

    my %fields = map { $_ => 1 } REQUIRED_FIELDS;
    for my $e (@$a) {
        $href->{$e} = 0
            if $fields{$e};
    }
[download]

In fact, since the hash never changes, you only need to create the hash once, not every time verify is called.

Update: Fixed the OP's misuse of splice as per AnomalousMonk's post.

Wow! Thanks!

Once again, dealing with the converse ends up creating a far simpler solution.

And from the standpoint of Perl, hashes can really be one's friend.

Thanks, again for taking the time to answer my questions!

splice @$fields, $i, 0;
[download]

Furthermore, and notwithstanding that a hash-based approach is, indeed, better for what you seem to want to do, the quoted splice statement from the OPed code also does not do what you want, removing zero elements (LENGTH == 0) beginning at an OFFSET of  $i in the array, i.e., it's an expensive no-op.

>perl -wMstrict -le
"my $ar = [ qw(a b c d) ];
 ;;
 my $i = 0;
 for my $e (@$ar) {
   $e = uc $e;
   splice @$ar, $i, 0;
   ++$i;
   }
 ;;
 use Data::Dumper;
 print Dumper $ar;
"
$VAR1 = [
          'A',
          'B',
          'C',
          'D'
        ];
[download]

(As a reinforcement to ikegami's point that you really don't want to add or delete elements in an array over which you are iterating, try changing the 0 in the  splice statement in the example code of this reply to a 1.)

Oops, you're right. I did specific zero elements to be deleted. My bad.

My appreciation to both of your replies for setting me on a better path.

I personally would use a different return value, either a list or an array reference as the output rather than pervert (grossly modify) the input to such an extent that it no longer means what it did as the input.

I mean if the input is "here's what I have" and the output is "here's what you didn't have" - those are two very different things.

It looks to me like the output of verify() is of a different "type" or "unit" than the input. I would return a list like I did, or a reference to an array of the "new type".

#!/usr/bin/perl -w
use strict;

use constant REQUIRED_FIELDS => qw/zero one two three four five six se
+ven/;

my $a_ref = [qw/three one two/];

my @missing_fields = verify($a_ref);
print "missing fields: @missing_fields\n";

sub verify
{
    my $a_ref = shift;
    
    my %seen = map{$_ => 1}@$a_ref;
    
    return (grep{!$seen{$_}}REQUIRED_FIELDS);
}

__END__ 
Prints:
missing fields: zero four five six seven
[download]