My question is this: Is there a way that an anonymous sub stored as a hash value can have access to its associated key?

#!/usr/bin/perl

use strict;
use warnings;

package Cute;

sub TIEHASH {bless {}, shift}
sub STORE   {my ($self, $key, $sub) = @_; 
             $$self{$key} = sub {$sub->($key)}}
sub FETCH   {${$_[0]}{$_[1]}}

package main;

tie my %hash, 'Cute';

my $greeting = sub {print "Hello, $_[0]\n"};

$hash{world} = $greeting;
$hash{earth} = $greeting;

foreach my $key (qw /world earth/) {
    &{$hash{$key}};
}
 
__END__
Hello, world
Hello, earth
[download]

I like the package name.

I think the lesson to be learned from this is that, with tie, the counterintuitive can be made to work! :-)

Very nice! That does exactly what I was thinking of. I only wish I had a prize to award!

PCS
I was recently asked, "Does your program know when it isn't running?"

sub make_sub_for_given_key
{
   my( $key ) = @_; # amongst other arguments

   return sub {
      # this sub "knows" what $key is, forever.
      print "Hi! I belong to key '$key'\n";
   }
}

my $key = "Tuesday";

my %hash;
$hash{ $key } = make_sub_for_given_key( $key );

# later on, ask each sub what key it belongs to:

for $key ( keys %hash ) {
   $hash{$key}->();
}
[download]

Not really. What happens if you associate the same sub with two keys?

my $code = sub {
  #
  # some sort of magic currently unknown to me
  #
};

$h{'abc','xyz'} = ($code) x 2;
[download]

The only way I can see is if you embed a self-referential closure to the coderef within the sub and then grep the hash looking for a key with that coderef as it's value.

You could probably use someting in the B::* set of modules to walk the optree and locate yourself (you own coderef) from within the sub, but you're still back to searching the hash for keys with that as a value.

There are a couple of ways to do this, although I wouldn't recommend any of these for code that is actually supposed to do anything other than show up in some contest entry.

1. Bless the anonymous sub into a package with the same name as the key. It still acts like an anonymous sub, but it has this extra package name. Use ref() to get the package name back.
2. Enchant the code ref by blessing it into a package and overloading the stringification operator, sorta like I did in Re: Track the filename/line number of an anonymous coderef. That was just for giggles, so don't put that in any code that means anything to you.
3. Create a reverse index and use the stringified value of the anonymous sub as the key. You can handle duplicate values by not allowing them or making the reverse index store multiple keys.

my $sr=sub{print shift() . qq(\n)}; # Subref for Hash

my %h=(a=>$sr, b=>$sr);

sub gh{ # Sub to access the hash value and call the sub..
  my $p=shift; # Get the KEY requested
    # In real life, you would first check to see if it was a coderef..
  &{$h{$p}}($p);  # Call the anon sub, passing it the key
  # Returns the result of the call..
}; 

gh($_) for qw(a b b a);

### Prints
a
b
b
a
[download]