sub foo { print( "Hello World\n" ); }

BEGIN { *bar = \&foo; }

foo();
bar();
[download]

The BEGIN is not necessary, but it can avoid problems.

Update: Or to demonstrate your requirements:

sub foo { print( "foo\n" ); }

BEGIN {
   *bar = \&foo;
}

BEGIN {
   *foo = sub { print( "bar\n" ); };
}

foo();  # bar
bar();  # foo
[download]

no strict 'refs';
my $old_puts = *{"puts"}{CODE};
no warnings 'redefine';
*{"puts"} = sub { ... };

puts();        # "New" puts.
&$old_puts();  # "Old" puts.
[download]

Is this what you want?

use strict;
package A;

sub new {
    my $class = shift;
    bless {}, $class;
}

sub test {
    "original test"
}
sub do_alias {
    my $self = shift;
    *test_alias = \&test;
}
sub redefine_alias {
    my $self = shift;
    *test_alias = sub {"new test"};
}

package main;

sub say { print @_,"\n" }

my $a = new A;
say $a->test();        # test
$a->do_alias(); 
say $a->test_alias();  # test
$a->redefine_alias();
say $a->test_alias();  # new_test
say $a->test();        # test
[download]

Best regards

I think Attribute::Alias might work better.

sub foo :Alias(bar) { ... }

# These both do the same thing.
foo();
bar();
[download]

---

My criteria for good software:

1. Does it work?
2. Can someone else come in, make a change, and be reasonably certain no bugs were introduced?

Does this really do what the poster wants? My impression was that Data::Alias is designed more to handle magic aliasing of scalars (possibly references), such as occurs in fors and subroutines, than to handle non-scalars such as subroutines. Of course, you can use

alias *old_func = \&new_func,
[download]

but I don't see what that gains over just

*old_func = \&new_func.
[download]

I searched the Data::Alias documentation for 'code' and 'function', but couldn't find anything indicating what I might be missing.

my $what = \&what;
local *what = sub {'new what'};

warn $what->();
warn what();

sub what { 'what' }
__END__
what at - line 4.
new what at - line 5.
[download]

Thats great, but there's better ways to solve this problem(ie subclass)