Re^6: A working strategy to handle AUTOLOAD, can(), and (multiple) inheritance without touching UNIVERSAL?

[lodin]

Don't rely on someone else's module. The area is too complicated.

Interesting. This is exactly why I think a module is needed. It is too complicated to be reimplemented and at least my first version was flawed or incomplete. I'd be more inclined to trust a module if the documentation and test suite give the impression of the module being robust.

This means you have to craft your own solution, but it is fairly simple.

That sounds a bit contradictory. :-)

Define a DESTROY method as bad stuff happens otherwise.

How about return if $method eq 'DESTROY'; in AUTOLOAD?

Define a semantically correct "can" function that either returns undef or a CODE ref.

Would that include looking at UNIVERSAL::can to find "real" methods?

Define the AUTOLOAD function in the fairly standard way based upon the "can" function.

Someone might decide to overload can and use caller arbitrarily, which may break (since there is no uplevel function in Perl). One might do this to remove some methods in can from the public (they can of course still be called). Good idea or not; I'm not to judge. I think caller was the reason I moved the logic out from can and into a common routine shared between can and AUTOLOAD. That way if anyone overloads can they do not have to think about my AUTOLOAD implementation since AUTOLOAD does not call can and in can I can use goto &$next to make it fully transparent.

I avoid multiple inheritence so I would make autoloading in a multiple inheritence scenario an absolute no.

It's not harder to use next::method/next::can and mro::get_linear_isa/Algorithm::C3::merge than it is to use SUPER::foo/can('SUPER::foo') and Class::ISA::super_path (mro/Algorithm::C3/Class::ISA is only needed (?) when overloading AUTOLOAD). mro.pm is core since Perl 5.9.5.

If you wanted to allow subroutine stubs in your classes (including any subclasses) you'd need to take some special care, I believe. This may be to break your first rule above, but still. The person who subclasses your class might not agree so if it can be solved I favor solving it. The problem is that UNIVERSAL::can returns a reference, but the subroutine it references is undefined, so AUTOLOAD will be invoked. So to avoid fatal recursion can may not return a reference to an undefined subroutine (i.e. stub). I think you may run into trouble with $self->SUPER::foo and/or $self->can('SUPER::foo') as well. ($self->SUPER::foo invokes AUTOLOAD only if it's a stub.)

The reciprocal perspective is that you want to overload a method and use SUPER in a subclass to a class (that perhaps someone else wrote) that uses stubs to lazily provide methods. If AUTOLOAD would query can then you'd end up with a fatal recursion.

Coincidentally, the design of Class::AUTOCAN implicitly handles stubs seamlessly. :-) If you want to lazily provide a method but still want to give it the precedence of a real method then you just do

{
    package Foo;

    sub foo;
    sub bar { __PACKAGE__ };

    # Handles &foo, and fallback for everything.
    AUTOLOAD { __PACKAGE__ }

    ## or, if it should can() everything:
    #use Class::AUTOCAN sub {
    #    return sub { __PACKAGE__ };
    #};
}
{
    package Foo::Bar;
    our @ISA = Foo::;

    sub bar; # Lazily overload bar.

    # Handle &bar and provide fallback for &foo and &BAR.
    # &foo should not be called here since &foo is declared
    # and should be handled by Foo::AUTOLOAD. If &foo should
    # be handled here then a stub should have been declared
    # here.
    use Class::AUTOCAN sub {
        my $self = shift;
        my ($method) = @_;

        return sub { __PACKAGE__ } if $method eq 'foo'; # Beware: stub
+.
        return sub { __PACKAGE__ } if $method eq 'bar';
        return sub { __PACKAGE__ } if $method eq 'BAR';
        return; # Let Foo worry about other methods.
    };
}

my $o = Foo::Bar::;
for my $method (qw/ foo bar BAR abc /) {
    my $code = $o->can($method);
    printf "%s => %-8s (can: %-8s)\n",
        $method,
        $o->$method,
        ($code ? $o->$code : ''),
    ;
}

__END__
foo => Foo      (can: Foo     )
bar => Foo::Bar (can: Foo::Bar)
BAR => Foo::Bar (can: Foo::Bar)
abc => Foo      (can:         )

Maybe I should upload Class::AUTOCAN somewhere so that you can try it out and see if you find any bugs in it. I would appreciate any fire your or anyone else could put it under. :-) If it's not bullet proof then it's not worth having on CPAN.

lodin

Update: improved the example.

[SilasTheMonk]

Interesting. This is exactly why I think a module is needed. It is too complicated to be reimplemented and at least my first version was flawed or incomplete. I'd be more inclined to trust a module if the documentation and test suite give the impression of the module being robust.

Yeah. If there was such a module I would use it. But if everyone followed my advice there would be no early adopters and so it would never reach the required maturity. I suspect all the perl brains (who could cut through this) are currently working on perl6.

>>> This means you have to craft your own solution, but it is fairly simple. That sounds a bit contradictory. :-)

Not at all contradictory. If you craft your own solution you are not trying to come up with an all encompassing solution but rather your are cutting your goals back to what matters in your circumstances.

How about return if $method eq 'DESTROY'; in AUTOLOAD?

Isn't this obscurantist? If you want to implement DESTROY why not just define one. Are you arguing that once you start using AUTOLOAD everything should pass through AUTOLOAD?

Would that include looking at UNIVERSAL::can to find "real" methods?

This is exactly what I do not trust. It seems that one class is trying to be very clever. It just feels wrong.

[lodin]

I do not want to implement DESTROY, that's the point. :-) What I want to avoid is to croak with "missing method" during object destruction. The reason I want to make an exception for DESTROY in AUTOLOAD is the following scenario:

{
    package Foo;

    sub new { ... }
    sub DESTROY { ... }
}
{
    package Bar;
    our @ISA = Foo::;

    sub AUTOLOAD { ... }
    sub DESTROY {} # Oops.
}

I want to think as little as possible, and by adding the exception in AUTOLOAD it always works and is future proof should you add any DESTROY later.

This is exactly what I do not trust. It seems that one class is trying to be very clever. It just feels wrong.

I'm not sure what you are referring to. Is it the call to UNIVERSAL::can? If UNIVERSAL::can($obj, 'foo') returns a value then that is what $obj->foo will call by the definition of UNIVERSAL::can. So naturally I would not want my can to return anything else if I want to be consistent.

In fact I was afraid I was not being clever enough and was missing something. The only thing my can does differently from any method that adds to a super method is that it checks UNIVERSAL::can:

• If $obj->$method will not call a regular method and if this class autoloads $method: go to it.
• If not: see what the next class says. (UNIVERSAL is considered the top class; explicitly added as the return value only because next::method ignores UNIVERSAL.)
AUTOLOAD's only exception is about DESTROY:
• If this class autoloads the method: go to it.
• If not: ask the next AUTOLOAD.
• If no next AUTOLOAD: croak, unless the method is DESTROY.

lodin