How do I access the original method of a monkeypatched method in Perl?

Question

I'm trying to monkey patch a Perl class: I want to change the behavior of an existing method.

This node on perlmonks shows how to add a function to an existing class. I found that this pattern can also be used to provide a new implementation for an existing function.

However, I'd like to know how to call the original function.

I'm looking for something like this:

use ExistingClass;

# TODO: Somehow rename existingFunction() to oldExistingFunction().

sub ExistingClass::existingFunction {
    my $self = shift;

    # New behavior goes here.
    $self->oldExistingFunction(@_); # Call old behavior.
    # More new behavior here.
}

Answer 1

Typeglob assignment

*ExistingClass::oldExistingFunction = *ExistingClass::existingFunction;

Quick and dirty. This aliases all existingFunction symbols to oldExistingFunction. This includes the sub you're interested in, but also any scalars, arrays, hashes, handles that might happen to have the same name.

• Advantages: no thinking, it just works. "quick"
• Disadvantages: "dirty"

Coderef assignment

*ExistingClass::oldExistingFunction = \&ExistingClass::existingFunction;
# or something using *ExistingClass::symbol{CODE}

That one only aliases the sub. It's still done in the package stash, so the oldExistingFunction symbol is globally visible, which might or might not be what you want. Probably not.

• Advantages: that aliasing doesn't 'leak' to other variable types.
• Disadvantages: more thinking, more typing. A lot more thinking if going for the *...{CODE} syntax (I personnally don't use it every day)

Lexical coderef

my $oldFunction = \&ExistingClass::existingFunction;

Using my keeps a reference to the old function that is only visible to the currrent block/file. There is no way for external code to get hold of it without your help anymore. Mind the calling convention:

$self->$oldFunction(@args);
$oldFunction->($self, @args);

• Advantages: no visibility issues anymore
• Disadvantages: harder to get right

Moose

See jrockway's answer. It's got to be The Right Way, since there's no mucking around with globs and/or references anymore, but I don't know it enough to explain it.

Answer 2

Memoize is a good example of this.

Answer 3

As an alterative, what's wrong with:

package NewClass;
use base qw/ExistingClass/;

sub existingFunction {
# ....
}

sub oldExistingFunction {
    my $self = shift;
    return $self->SUPER::existingFunction(@_);
}

Answer 4

Just copy it to a lexical variable and call it.

my $existing_function_ref = \&ExistingClass::existingFunction;
*ExistingClass::existingFunction = sub { 
    my $self = shift;
    $self->go_and_do_some_stuff();
    my @returns = $existing_function_ref->( $self, @_ );
    $self->do_some_stuff_with_returns( @returns );
    return wantarray ? @returns : shift @returns;
};

If you would feel better about it with OO-syntax, you could create a UNIVERSAL::apply method (or at any base class you chose).

sub UNIVERSAL::apply { 
    my ( $self, $block ) = splice( @_, 0, 2 );
    unshift @_, $self;
    goto &$block;
}

That way you can call it like this:

my @returns = $self->apply( $existing_function_ref, @_ );

Answer 5

You should use Moose or Class::Method::Modifiers.

In that case, you can just say:

around 'some_method' => sub {
    my ($orig, $self, @args) = @_;
    # ... before original ...
    $self->$orig(@_);
    # ... after original ...
};

Answer 6

Besides the other answers, look at modules such as:

• Sub::Override
• Hook::LexWrap

I also talk about this in the "Dynamic Languages" chapter in Mastering Perl.