I agree though that the idea runs against the essence of Perl's general lots-of-rope attitude. And indeed as dragonchild pointed out you can shorten the whole thing to UNIVERSAL::isa($self, __PACKAGE__). But even that is problematic, as some other class may well offer the same methods and signatures as yours and therefor be safe, even though it doesn't inherit from yours. See Class::Interface -- isa() Considered Harmful for a thorough discussion of the subject.

Of course, depending on your goals, it may be ok, but the caveats should be noted.

Something you may want to look into is UNIVERSAL::can() which checks if a method given by name can be called on an object reference.

Makeshifts last the longest.

Dang, that Class::Interface discussion is tasty... :)

Once again, happy I am!

My issue with the way it works now, is that I can explicitly call a method by using it's full name (Class::Method), thereby bypassing the implicit passing of the first argument. I'd feel safe if there was an easy way to tell my method to do a solid type-check on the first argument, to ensure it's an object or class-name it can work with.

It should be emphasised that:

Class::method($self); # called as a subroutine
$self->method;        # called as a method
[download]

are not equivalent. As soon as you start calling methods as subroutines you can't use SUPER:: or override in subclasses.

Perhaps you want something like:

use Devel::Caller qw(called_as_method);

sub foo {
   my $self = shift;
   croak "I am an instance method" unless called_as_method(0);
   # actual body of code
}
[download]

Now foo croaks unless it is called as a method, which means $self->isa(__PACKAGE__) must be true.

Personally, I wouldn't bother with checks like this. For me somebody calling an OO module in an non-OO style has deliberatly broken encapsulation - so deserves whatever chaos ensues :-)

Update: the called_as_method should also be a fair bit faster since you don't have to do the potentially expensive walk of the inheritance tree.