How can I write a Perl subroutine that works both as a normal subroutine or a class method?

Question

I'm writing a function that is mostly static in nature. I want to plug it into Template Toolkit, which passes along the class name. In essential, it is doing

ClassName->function( $args.. )

but I want it to do something like

ClassName::function( $args.. )

inside

sub function {
}

what is the proper way to handle both cases?

Answer 1

In general, there isn't. a sub is either written to be called as a method or it isn't.

See how File::Spec::Functions handles this situation by prepending the package name to the argument list.

Now, in a very specific, limited case, you can do:

shift if $_[0] eq __PACKAGE__;

as the first line in your sub to discard the first argument when the sub is called as a class method.

Answer 2

Template Toolkit expects it's plugins to use OO, so there's no way around providing that interface. If you also want a functional interface you have a couple of options.

Perl doesn't really distinguish between a function and a method. The main difference is that the method invocation syntax implicitly includes the object reference (or class name, depending on how it was invoked) as the first argument. You can use function call syntax and provide the referent manually:

ClassName::function('ClassName', @args);

but that's messy. The cleaner solution would be to split it into two subs with one a wrapper for the other. e.g.

package ClassName;

sub function {
    # do something
}

sub method {
    my $class = shift;
    function(@_);
}

The function could be a wrapper around the method as well. As Sinan alluded to, File::Spec does this by creating two modules: one with the OO interface and one with a functional interface.

Answer 3

Here is a safer version that combines Sinan's and Alan's answers, and also:

• Handles the possibility that the method is called from a derived object
• Won't misinterpret ClassName::function("ClassName") as a method call

The code:

if (@_ == $nArgsExpectedForThisFunc + 1) {
    $_[0] eq __PACKAGE__ || UNIVERSAL::isa($_[0], __PACKAGE__) || die;
    shift;
}

This requires that you know the number of arguments to expect; if you don't, but your first argument can be differentiated from the possible allowable values that might be sent when it is called as a method (e.g. if your first argument must be an arrayref), the same general principle can still be applied.