Adding to or removing from an array you're iterating over is a bad idea. If you create a loop over two elements (indices 0 and 1) and, on the first iteration, remove one element, what will happen on the second iteration?

An alternate approach would be to build up a third data structure to hold the difference of the two sets. I think perlfaq4 has the right idea. The code might be (warning, untested!):

my @AoH_all = (
{
    name => "Bill",
    id   => 1,
},
{
    name => "Mike",
    id   => 3
});
                  
my @AoH_one = (
{
    name => "Bill",
    id   => 1,
} );
            
my %keep_ids = map { $_->{id} => 1 } @AoH_all;
delete @keep_ids{ map { $_->{id} } @AoH_one };

my @difference = grep { exists $keep_ids{ $_->{id} } } @AoH_all;
[download]

Update: two typos fixed.

Adding to or removing from an array you're iterating over is a bad idea. If you create a loop over two elements (indices 0 and 1) and, on the first iteration, remove one element, what will happen on the second iteration?

However, if you would iterate in reverse order (1,0) then there would be no problem at all.

Liz

Thanks chromatic, it looks like an elegant solution. But I'm still rather new at things like map and grep. I've been trying hard to make your code work, but am reaching the head-banging stage.

I did add the final right curly bracket to the "delete" line:

delete @keep_ids{ map { $_->{id} } @AoH_one };

print Dumper (%keep_ids);
[download]

which prints:

$VAR1 = '3';
$VAR2 = 1;
[download]

So, I have the id of the hash I want to keep, but I'm not sure what is happening on the grep line. Also, I'm not quite sure of how to build the AoH I need for my tmpl_loop from just knowing that resulting id.

I'm going to continue to work on it, but in the meantime, if another monk comes along that can fill in some of the details, I'm very teachable right now ;^). Thanks!


—Brad
"A little yeast leavens the whole dough."

map and grep are really pretty easy, once you know the secret: read them right to left.

map iterates over a list, executing the code block for each element in turn, returning a list of whatever the code block returns. Use it to transform one list into another.

grep iterates over a list, executing the code block for each element in turn, returning a list of only those elements for which the code block returns true. Use it to filter out list elements.

If you phrase your problem as: "how do I construct a new list of hrefs that excludes hrefs with certain IDs?", then the grep solution becomes much more obvious.

  # build a hash that contains only excluded IDs
  my %exclude = map { ( $_->{id} => 1 ) } @AoH_one;

  # now keep only those that are not excluded:
  my @keepers = grep { not $exclude{ $_->{id} } } @AoH_all;
[download]

If you actually want to replace @AoH_all with this new list, there is nothing wrong with just assigning back into the same variable:

  @AoH_all = grep { not $exclude{ $_->{id} } } @AoH_all;
[download]

As liz points out, you can use splice if you traverse the indexes in reverse order. You can also track the number of elements remaining.

  # use liz's technique
  foreach my $i ( reverse 0 .. $#AoH_all )
  {
      if ( $exclude{ $AoH_all[$i]{id} } )
      {
          splice @AoH_all, $i, 1;
      }
  }

  # keep track of things manually
  my $n_elt = @AoH_all;
  for ( my $i = 0; $i < $n_elt; ++$i )
  {
      if ( $exclude{ $AoH_all[$i]{id} } )
      {
          splice @AoH_all, $i, 1;
          --$n_elt;
          # whoops, bug here, see update...
      }
  }

  # finally, perl updates the length of @AoH_all for us, so:
  for ( my $i = 0; $i < @AoH_all; ++$i )
  {
      if ( $exclude{ $AoH_all[$i]{id} } )
      {
          splice @AoH_all, $i, 1;
          # whoops, bug here, see update...
      }
  }
[download]

Update

Both of the last two loops have a serious error. After you splice out an element, everything else is shifted down — but the value shifted into $AoH_all[$i] is never examined again. Oops. We can either subvert the increment, or we can switch to only increment if we didn't do any replacement:

  # adjust $i after replacement so it is reexamined:
  for ( my $i = 0; $i < @AoH_all; ++$i )
  {
      if ( $exclude{ $AoH_all[$i]{id} } )
      {
          splice @AoH_all, $i, 1;
          --$i;
      }
  }

  # or, only increment $i if we didn't do a replacement:
  for ( my $i = 0; $i < @AoH_all; )
  {
      if ( $exclude{ $AoH_all[$i]{id} } )
      {
          splice @AoH_all, $i, 1;
      }
      else
      {
          ++$i;
      }
  }
[download]