sub foo {print "world,\n"}

my $func_name = "foo";
my $func_ref = \&foo;

# Replace foo
*foo = sub {print "Hello "};

&$func_name();
$func_ref->();
[download]

This behavior confuses me. EG:

my $string = "Hello.";
my $string_ref = \$string;

$string = "Bacon!";
print $$string_ref;
[download]

The above prints "Bacon!", as my intuition expects. Why does the coderef point to the old block?

Because the symbol foo and the coderef are different things. *foo = ... assigns a new coderef to the symbol foo. It doesn't redefine the coderef for the original sub foo, which is kind of like a constant.

\&foo takes the address of a constant, not a variable. So it is analogous to \"Hello World" rather than \$some_var_holding_a_string. You can't reassign it any more than you can reassign the address of the string literal "Hello World".

Well, almost so. Sub "literals" are more complex than a string. Redefine a string and you get a different string. Redefine a sub and you get a different association between sub name and body. So if you *really*, *really* were set on redefining sub foo itself, you could, but (a) you have to nudge Perl into compiling code at runtime and (b) you will get a warning about redefining things that are not supposed to be redefined:

use strict;
use warnings;

sub sayHello { print "Hello, world!\n"; }
sayHello();
eval q{sub sayHello { print "Bonjour, le monde!\n"; }};
sayHello();
[download]

which outputs

Hello, world!
Subroutine sayHello redefined at (eval 1) line 1.
Bonjour, le monde!
[download]

Best, beth

Update: added some explanation about difference between sub and string literals.

Why does the coderef point to the old block?

That's not a code reference, it's a scalar reference.
$string_ref is a reference to the scalar, $string. Doing a print $$string_ref; will print out whatever's *presently* in $string.

Update: Oops ... looking at Freezy's post in the context of the entire thread, I think I might've missed the point somewhat in my reply.

Cheers,
Rob

\&thefunc is a good option.. It reduces memory consumption in symbol table Using symbolicreferences confuses the programmer.. normally ppl will think $$variable = dereferenicing a scalar variable..if it is unavoidable then use ${"$variable"}

but I will use 'funcname', when have a function template configured to be executed, where it can be easily changed, by adding a new function to the module and just adding a name to the configuration.
In which case in the main program, i read the configuration and just check whether that function exists using 'can', and execute it (if 'use strict' is in action, i will use 'no strict "refs"' inside that particular block so it won't throw error).

moreover the using 'funcname', does an additional lookup in the symbol table I reckon.

can returns a code ref so you don't need to turn off strictures, just:

use strict;
use warnings;

my $funcName = 'doit';

if (my $cando = main->can ($funcName)) {
    $cando-> ();
}


sub doit {
    print "I done it\n";
}
[download]

Prints:

I done it
[download]

---

True laziness is hard work

Telling someone to turn off strict refs is NOT a good idea, unless right after the functions action they turn it back on.
Besides why would you want to turn something off when you can get around the error.
Spiel auf Hündinnen.

If you turn off strict refs inside of a block, it is automatically on right after the block. I personally find it clearer to do this than to use a complex syntax the maintenance programmer may not know to fool strict.pm into not complaining.