How does this Perl grep work to determine the union of several hashes?

I don't understand the last line of this function from Programming Perl 3e.

Here's how you might write a function that does a kind of set intersection by returning a list of keys 开发者_开发技巧occurring in all the hashes passed to it:

@common = inter( \%foo, \%bar, \%joe );
sub inter {
    my %seen;
    for my $href (@_) {
        while (my $k = each %$href) {
            $seen{$k}++;
        }
    }
    return grep { $seen{$_} == @_ } keys %seen;
}

I understand that %seen is a hash which maps each key to the number of times it was encountered in any of the hashes provided to the function.

grep will take a list passed to it (in this case, every element seen in any of the hashrefs); and return a list of only those elements where the expression in the block is true (locally setting $_ variable to each element in the list).

Let's look at how that expression is evaluated:

• @_ is an array of all the parameters passed to the subroutine - in our case a list of hash references passed in.

• In $seen{$_} == @_ expression that list is forced into a scalar context (due to ==).

• When used in a scalar context, a list evaluates to the number of elements in a list - in the example call above, to 3, since 3 hashrefs were passed in.

So, for each key in %seen (e.g. each key seen in any of N hashrefs); the expression $seen{$_} == @_ is numerically comparing the # of times the element was seen in the hashes to the total number of hashes - it's only going to be equal, of course, if the element is in ALL the hashes that were passed in, and thus a member of the intersection we want.

So, to sum up the analysis, the grep will return a list of all keys that occur in EVERY hash (aka occur N times where N is the # of hashes). E.g. an intersection.

grep block list 

This will apply block to each element of list in turn, the element is aliased as $_. If the block returns true, the element is added to the returned array.

in this case:

grep { $seen{$_} == @_ } keys %seen

The block is $seen{$_} == @_ , which compares the value of the seen hash against @_ . @_ is evaluated in scalar context and thus returns the number of elements in the @_ array. @_ represents the arguments to the current function. In this case ( \%foo, \%bar, \%joe ), which returns 3 in scalar context. Our list is keys %seen, which is an array containing all the keys present in %seen.

equivalent english statements:

• "give me a list of all the keys from %seen where the value associated with that key is equal to the number of elements passed to this function"
• "give me a list of all the keys from %seen where the value associated with that key is 3"
• "give me a list of all the keys from %seen that have value 3, ie all the keys from %seen that are present in each of the 3 hashrefs passed to this function"

The purpose of the function is to find the elements that appear in all the hashes passed to it.

The last line greps the list returned from keys %seen. To determine if a given key appears in all the hashes that were passed to the function, we can compare that key's value in %seen to the number of arguments to inter.

In the grep block, $_ is set to each element of the keys list, and tested for some condition.

An array in scalar context evaluates to its length. @_ is the array of arguments passed into the subroutine. And the == operator puts its operands in scalar context, so we can just compare the value of $seen{$_} to the length @_. If they're the same, then that key appeared in all the hashes.