Sub::Auto - declare individual handlers for AUTLOADed subs, respecting can and inheritance


 use Sub::Auto;

 autosub /^get_(\w+)$/ {
    my ($what, @pars) = @_;
    print "Getting $what...\n";

 autosub /^set_(\w+)_(\w+)$/ {
    my ($adjective, $noun, @pars) = @_;
    print "Setting the $adjective $noun\n";

 autosub handle_foo_events /foo$/ {
    my ($subname, @pars) = @_;
    print "Called $subname to do something to a foo\n";

 if (__PACKAGE__->can('set_blue_cat')) { ... }


AUTOLOAD, like other languages' method-missing features is a useful feature for those situations when you want to handle sub or method calls dynamically, and can't pre-generate the subroutines with accessor generators.

To be sure, this is almost never the case, but occasionally, AUTOLOAD is convenient.

Well, "convenient" is a strong word, writing sub AUTOLOAD handlers is mildly unpleasant, and doesn't handle inheritance and can by default.

Using Sub::Auto you can:

  • Declare multiple handlers, each responding to calls matching a given regular expression.

  • Optionally name your handler, for clarity, or because you want to call it directly.

  • Ensure that unhandled methods get dealt with by the next class in the inheritance chain.



 autosub [name] /regex/ { ... }

If the regex contains capturing parentheses, then each of those items will be prepended to the sub's argument list. For example:

 autosub /(\w+)_(\w+)/ {
    my ($verb, $noun, @params) = @_;
    print "$verb'ing $noun - " . join ','=>@params;

 jump_up('one', 'two'); # prints "jump'ing up - one,two"

If the matching regex didn't have any capturing parens, the entire method name is passed as the first argument.

The name of the sub is optional. It registers a normal subroutine or method with that name in the current package. Nothing will be automatically prepended to a call to this method!

 autosub foo /(\w+)_(\w+)/ {
    my ($verb, $noun, $one,$two) = @_;
    print $one + $two;

 foo (undef,undef, 1, 2);


Class::AutoloadCAN by Ben Tilly, does all the heavy lifting.

Devel::Declare by Matt Trout provides the tasty syntactic sugar.

Class::Accessor or various other method generators that are a saner solution in general than using AUTOLOAD at all.


 (c) 2008

This module is released under the same terms as Perl itself.