Just an idea, don't know if it might work:

You could use PadWalker to sniff your caller's lexicals and see if the reference address of any of them is equal to the reference you've got.

PadWalker provides a var_name function that takes the reference and does that for you. It's even more reliable than looping over the lexicals, when the lexical you want is hidden:

#!/usr/bin/perl -l
use strict;
use warnings;
use PadWalker ":all";

sub foo {
   my $x;
   for ($x) {
      my $x;
      bar(\$_);
   }
}

sub bar {
    print var_name(1, $_[0]);  # works
    my $vars = peek_my(1);
    print grep $vars->{$_} == $_[0], keys %$vars;  # doesn't work unle
+ss 2nd my $x is commented out
}

foo();
[download]

--
Online Fortune Cookie Search
Office Space merchandise

Dunno, but it makes little sense to me. For you can have an anonymous reference. (no name) or you can have a reference to a scalar that has more than one name (using Scalar::Alias or similar)

So the question "which is the name of the var referenced by $x" may have zero, one or more than one answer.

Is yours an academic question or have you a specific need in mind? Maybe it is an XY Problem.

If you need that information, you are breaking a number of encapsulation rules that are really bad to break.

Could you explain why you want to do this in the first place?

One could write a nice subroutine useful in debugging, whic when called in the following way:

my $aLex=25;
print(display($aLex),"\n");
[download]

would print

$aLex == 25
[download]

-- 
Ronald Fischer <ynnor@mm.st>

Try Data::Dumper::Simple or Data::Dumper::Names which do this.

I agree that there are uses for a subroutine that can return such names as requested, but usually when people ask for something like this, its a sign of a more mundane problem solved in the wrong way.