The direly needed improvements:

• Avoid having to know exactly how many groups there are.
• Avoid having to know the name of each of those groups in multiple places.
• Avoid having to know exactly how many items are in each group.

One of many ways:

my %items = map { $_ => 1 } (
    'APPLES',
    'SILVER',
);

my %groups = (
    'cookies'         => ['CHOCOLATE CHIP', 'PEANUT BUTTER'],
    'previous metals' => ['SILVER', 'GOLD', 'PLATINUM'],
);

my $lover;
for my $group_name (keys(%groups)) {
    if ( grep $items{$_}, @{ $groups{$group_name} } ) {
        print "This guy loves $group_name.\n";
        ++$lover;
    }
}

if (!$lover) {
    print "This guy loves nothing.\n";
}
[download]

Agreed upon the direly needed improvements. This is definitely a step in the right direction, but it strays slightly from the technical requirements which I failed to communicate. -Ordering is important. Does this indicate that I should be using an AoA? -I would like to preserve the key-value relationship if at all possible.

Yeah, you can use an array instead of a hash.

my %items = map { $_ => 1 } (
    'APPLES',
    'SILVER',
);

my @groups = (
    [ 'cookies',         [ 'CHOCOLATE CHIP', 'PEANUT BUTTER' ] ],
    [ 'previous metals', [ 'SILVER', 'GOLD', 'PLATINUM' ]      ],
);

my $lover;
for my $group (@groups) {
    my ($group_name, $group_members) = @$group;
    if ( grep $items{$_}, @$group_members ) {
        print "This guy loves $group_name.\n";
        ++$lover;
    }
}

if (!$lover) {
    print "This guy loves nothing.\n";
}
[download]

EDIT: I should have made it clear that ordering is important and that 'this guy' is a simple man and can only love one thing. I know that this hints that I should be using an array of arrays instead of a hash of arrays, but the key-value relationship is something I would like to preserve if at all possible.

After reading your EDIT, I am confused as to what the requirements really are. What does "ordering is important" mean? Order of "what" exactly?

A hash has no intrinsic "order" to the keys - you should assume that hash keys will come out in any order when you access a hash via (keys %hash) or (keys %$ref_2_hash).

It would help at least me, if you could back up a bit.. Write some more text describing what data you have and the kind of "look-up" that you desire. It could be that excellent solutions are being offered to the "wrong problem".

For a "list" of stuff, ordered or not, think: "array".
For a subset of an array, think: "grep"

The code below uses an uncommon feature, a label.
However it seemed to be appropriate in this situation.
"Seldom used" doesn't mean "never used".

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

my @values = ('CHOCOLATE CHIP', 'PLATINUM', 'GASOLINE', 'GOLD');

my %hash = (
    'COOKIE' => ['CHOCOLATE CHIP', 'PEANUT BUTTER'],
    'METAL'  => ['SILVER', 'GOLD', 'PLATINUM'],
    );    

THING: foreach my $thing (@values)
{
   foreach my $type (keys %hash)
   {
      if (grep{$_ eq $thing}@{$hash{$type}} )
      {
         print "$thing is a $type\n";
         next THING;
      }
   } 
   print "$thing is UNKOWN\n";
}

__END__
CHOCOLATE CHIP is a COOKIE
PLATINUM is a METAL
GASOLINE is UNKOWN
GOLD is a METAL
[download]

Assuming it is, then it seems grep and array are pretty much what you're after (try as you might to avoid them), since you're asking for $k such that grep { $values->{$_} } @{$hash->{$k}} is nonempty.

OK, this isn't going to work that well for large lists, because grep can't short-circuit and you'll waste time after you "already" know the answer is yes. Maybe wait for Perl 6? No, probably not a good idea. So you'll need to do your own short-circuiting by iterating over @{$hash->{$k}} and quitting when you've found something that matches.

Since nothing is sorted anywhere in this exercise, I don't think you'll do much better than "iterate over the keys of %$hash, then iterate over the entries in the arrayref and check each one".

If you want grep to short circuit, try first from List::Util.

jaydstein:

If you're trying to determine the category of a particular item, and you're doing it frequently in your code, then you might want to use a reverse lookup table (inverted hash). Basically, it's just a hash where each value points to the category name in your list:

$ cat 952190.pl
#!/usr/bin/perl
use strict;
use warnings;

my $hash = {
    'COOKIES'   => ['CHOCOLATE CHIP', 'PEANUT BUTTER', 'OATMEAL'],
    'METALS'    => ['SILVER', 'GOLD', 'PLATINUM'],
    'BREAKFAST' => ['OATMEAL', 'WAFFLES', 'CEREAL'],
};

my $values = {
    'COOKIES' => '1',
    'SILVER'  => '1',
};

my $revLookup;
for my $k (%$hash) {
    for my $v (@{$$hash{$k}}) {
        $$revLookup{$v} = $k;
    }
}

print who_do_ya_love('CHOCOLATE CHIP');
print who_do_ya_love('PLATINUM');
print who_do_ya_love('OATMEAL');

sub who_do_ya_love {
    my $item = shift;
    my $category = $$revLookup{$item} // 'NOTHING';
    "This guy loves $category\n";
}

$ perl 952190.pl
This guy loves COOKIES
This guy loves METALS
This guy loves BREAKFAST
[download]

The downsides of using an inverted hash:

• You actually have to build the inverted hash: That can be expensive for large quantities of data.
• Each time your list of values changes, you have to build it again--or add code to maintain the reverse hash with the rest of the data.
• Since values may be in multiple lists, you'll have to either:
  • (a) bear with it (as I did in this example), or
  • (b) decide how to handle (and then write code for) multiple lists.

...roboticus

When your only tool is a hammer, all problems look like your thumb.

May I ask why you're trying to steer clear from arrays (I'm assuming you mean loops instead of arrays) and grep?

Also, I'm pretty sure the code you provided does not run. Your $hash hashref has keys that point to arrayrefs, so you would need to dereference them like so:

print $hash->{COOKIES}->[0]; # Gives you: CHOCOLATE CHIP
[download]

EDIT: I stand corrected. $hash->{COOKIES}[0] works just fine. Seems weird to me, but there you go.

That's quite simple. If the only thing you could ever write between the curly and the square bracket is a -> and you have to write it always, then why should you have to write it at all?

It's a convenient shortcut that may be used no matter whether you are chaining array or hash subscriptions. $AoA[1][4], $HoH{some}{thing}, $AoH[1]{whatever}, $HoA{barf}[42], ...

The arrow at the beginning though is important. $A[0] is the first element of the array @A, $A->[0] on the other hand is the first element of the array referenced by $A. Because arrays and hashes may only store scalars (strings, numbers or references) you do not need the arrow between the subscriptions to distinguish such two cases.

Jenda
Enoch was right!
Enjoy the last years of Rome.

Ah, that makes sense. Thanks for enlightening me! It always amazes me when I learn about small things like this that make Perl so easy to use.