$globref = \do{ local *GLOB} };
{local *X = $globref; *X = sub {"bar"}};
[download]

Maybe I'm missing something, but this Works For Me:

sub foo { "foo" }
$fooref = \*foo;

print *bar{SCALAR};
*bar = *$fooref{CODE};
print *bar{SCALAR};

print *foo{CODE};
print *bar{CODE};
[download]

Update: I just noticed you want to assign to a globref. This works too:

sub foo { "foo" }
$fooref = \*foo;

$bar = 1;
$barref = \*bar;

print *bar{SCALAR};
*$barref = *foo{CODE};
print *bar{SCALAR};

print *foo{CODE};
print *bar{CODE};
[download]

Another Update: assigning an anonymous coderef to the glob ref doesn't overwrite the scalar slot of the glob for me either:

$bar = 1;
$barref = \*bar;

print *bar{SCALAR};
*$barref = sub { "bar" };
print *bar{SCALAR};
[download]

Doesn't for me:

sub foo { "foo" }
$fooref = \*foo;
&$fooref();
[download]

gives

Not a CODE reference at testing.pl line 3.
[download]

"Another Update" doesn't work for either:

$bar = 1;
$barref = \*bar;
*$barref = sub { "bar" };
&$barref();
[download]

gives

Not a CODE reference at testing.pl line 4.
[download]

That's because it's a glob reference, not a code reference:

sub foo { "foo" }
$fooref = \*foo;
print *$fooref{CODE}->();
[download]

Thanks guys. You poked me in the right direction.

I knew I had this work before. I turns out that if the base GLOB has something assigned to the CODE slot before you take the reference to it, then you can use any of:

1.  *{ *$glob } = sub{ "Anon 4: $_[ 0 ]" };
2.  *$glob = sub{ "Anon 5: $_[ 0 ]"; };
3.  *{ $glob } = sub{ "Anon 6: $_[ 0 ]"; };

And they all work.

But if the original GLOB has nothing assigned to the code slot, nothing works. Seems like a bug to me?

if the original GLOB has nothing assigned to the code slot, nothing works.

That's not the behavior I'm seeing. This code works fine all by itself:

my $globref = \*GLOB;
*$globref = sub { print "Glob\n" };
GLOB();
[download]

It prints "Glob\n" just as I'd expect, even though the glob had nothing at all when the reference was taken. The problem comes from the use of local in the do block when creating the globref.

A globref created from a localized glob seems to lose some of its magic when the block exits. Then, when you try to assign something to one of its slots, the whole reference gets overwritten by what you assigned, not just the particular slot:

my $globref = \do { local *GLOB };
print $globref, "\n"; # prints GLOB(0x.......)
*$globref = 1;
print $globref, "\n"; # prints SCALAR(0x.......)
[download]

I don't know if this is a bug, but it's certainly surprising. I'd expect local to clobber the values from the globref when the block exits, but making the globref itself act differently is kind of strange.

You're explicitly overwriting the globref with a scalar. <P.You need to use the right syntax to assign to the SCALAR slot of the referenced glob.

[ 7:53:35.32] P:\test>perl -l
my $globref = \do { local *GLOB };
print $globref;

## Assign to the SCALAR slot in the glob referenced by $globref
${ *$globref } = 123456789;

print $globref; ## Still a GLOB
print ${ *$globref }; ## Contains our value

## This is where the trouble comes in.
*$globref = sub{ print 'test' };

print ${ *$globref }, $/, &{ *$globref };
^Z
GLOB(0x224fc8)
GLOB(0x224fc8)
123456789
Not a GLOB reference at - line 13.
[download]

However, I did just discover this.

[ 7:56:55.39] P:\test>perl -l
my $globref = do { local *GLOB; \*GLOB; };
print $globref;

## Assign to the SCALAR slot in the glob referenced by $globref
${ *$globref } = 123456789;

print $globref; ## Still a GLOB
print ${ *$globref }; ## Contains our value

## This is where the trouble comes in.
*$globref = sub{ print 'test' };

print ${ *$globref }, $/, &{ *$globref };
^Z
GLOB(0x1824284)
GLOB(0x1824284)
123456789
test
123456789
1
[download]

If I return the reference to the localised GLOB from with the do block, then everything works fine, without the need to pre-assign something to the actual GLOB before hand.

I'm pretty sure that I picked up on the idiom of

my $globref = \ do{ local *GLOB; };
[download]

from a usually reliable (and wizardly:) source, but I'll need to check that.

As I understand it, localising the GLOB effectively give you access to a new (anonymous) typeglob ensuring that if the code is called multiple times, you get a new once each time, without needing to go the Symbol route of creating sequence numbered globs in a special namespace.

However, my understanding may well be wrong. This could just be what I assumed the do local construct was doing. Hmmm. Off to try and relocate some sources and refresh my memory.