You mean something like this? (Super search terms: "search name code ref")

Oooooooh, great find, didn't run across that one myself. Looks like B includes all sorts of funky black magic for me to play with :-)
Remember rule one...

sub bar {
    print +(caller 0)[3];
}

sub foo { bar }

my $baz = \&foo;
$baz->();

__END__
main::foo
[download]

sub bob { print 'bob'; }

my $match = \&bob;
my $nomatch = sub { print 'nob'; };
*alias = \&bob;

for my $key (keys %main::) {
    if ($match == \&{$key}) {
        print "matched to $key\n";
    }
    if ($nomatch == \&{$key}) {
        print "matched to $key\n";
    }
}
[download]

This will only find subroutines in the main package.

Update: Added Alias for completness.

Good start, now recurse down the entire symbol table, and you've got something that's a bit more useful.

Oh, and it would return a list of many things that point to the that coderef.

#!/usr/bin/perl

sub foo {
  print "In foo\n";
}

sub findit {
  my $ref = shift;
  local(*alias);

  *stash = *{"main::"};
  while ((my $varname, my $globvalue) = each %stash){
    next if $varname eq "alias";
    *alias = $globvalue;
    if (defined(&alias)){
      if ($ref eq \&alias){
        return $varname;
      }
    }
  }
}

my $fref = \&foo;

my $fname = findit($fref);
print "ref points to $fname\n";
[download]

bryan@web ~$ ./ns
ref points to foo
bryan@web ~$

You may also be interested in Can an anonymous sub in a hash value know its key?.

This question gets asked from time to time. The usual answer is, why do you want to do that? It is a strange thing to want, and when you consider that something may be called by many names, or even no name at all, it is nearly pointless as well.

The main reason I want to do this is because I'm working on a small script that executes a certain subroutine with certain arguments after x amount of time, a timed event so to say. In order to facilitate ease of use I was hoping to find a way to provide a list of all timed events currently in the queue, with the subroutines they're pointing to, the arguments and the amount of time left till execution.
Remember rule one...

I would solve that by passing a label along with the coderef when I added the timed event to the queue. Something along the lines of:

add_to_queue(foo => \&foo, [ @fooargs ], $footime);
add_to_queue(bar => \&bar, [ @barargs ], $bartime);

dump_queue();

{
  my @queue;

  sub add_to_queue {
    my ($label, $code, $args, $time) = @_;
    push @queue, [ $label, $code, $args, $time ];
  }

  sub dump_queue {
    for (@queue) {
      my ($label, $code, $args, $time) = @$_;
      print "Will execute $label with @$args at $time\n";
    }
  }
}
[download]

Of course, your exact calling conventions will likely be different, but this is just to give you the general idea.

#!/usr/bin/perl

use strict;
use warnings;

my $anon = sub { return "foo " . "bar" };

my $retVal = &$anon;

print $retVal ;
[download]

#!/usr/bin/perl

use strict;
use warnings;

my $anon = bar->new;
my $retVal = &{$anon->{a}};

print $retVal ;

package bar;

sub new{
   my $self = bless{};
   $self->{a} = sub { return "bar"; } ;
   $self;
}
[download]

I think the OP was more interested in this:

sub foo {
  # do groovy things here
}

my $coderef = \&foo;


my $method_name = mythical_coderef_name_fetcher($coderef);

print $method_name;  # output is 'foo'
[download]

AFAIK there's no way to do this. Any takers?

code example moved to original post for ease of reading.

return '&foo' unless shift;
[download]