[feature] an infix `isa` operator

[leonerd]

It is quite common in Perl code to want to know if a given object instance is derived from a given class. Such code as

if( $obj->isa( "Some::Class" ) ) ...

is however insufficient because it relies on invoking a method on what may not in fact be an object at all. Sufficiently-defensive code solves this by such constructs as:

use Scalar::Util 'blessed';

if( blessed $obj and $obj->isa( "Some::Class" ) ) ...

There are also CPAN-based solutions that try to make this nicer:

use Safe::Isa '$_isa';

if( $obj->$_isa( "Some::Class" ) ) ...

Such an omission in core Perl appears especially unfortunate in the wider context of thoughts around bringing in more of an OO system.

It would be nice if core Perl provided a basic infix operator to perform this test safely. Such an operator could additionally parse a bareword package name correctly in the common case, thus not requiring a "quoted" name:

use feature 'isa';

if( $obj isa Some::Class ) ...

In addition it may be useful to have a does operator that tests ->DOES instead, though I will admit to not fully understanding the subtle semantic difference is between the two.

[leonerd]

It is also for this feature that I suggest the use of extends rather than isa in any sort of proposed class syntax:

class DerivedClass extends BaseClass { ... }

[Grinnz]

This would also solve the misguided use of UNIVERSAL::isa to accomplish the same "safe" check, while respecting custom isa methods.

[karenetheridge]

So presumably DerivedClass isa BaseClass would be 1. parsable, and 2. return true?

Similarly for: my @classes = qw(DerivedClass BaseClass); $classes[0] isa $classes[1]

[leonerd]

@karenetheridge Yeah those both seem reasonable and DWIMy without being too magical.

[Grinnz]

Open question: should this have defined behavior for unblessed refs? The pro is this would obviate the other common use of UNIVERSAL::isa (working on both blessed and unblessed refs concisely). The con is that it would then have the same ambiguity as ref and it's a bit of feature creep.

[Grinnz]

One option is to define the behavior on unblessed refs as just "always false".

[haarg]

The issue isn't only unblessed refs, but also checking objects against a reftype. $object isa 'HASH'

[simcop2387]

I think it shouldn't ever be true with reftypes, simply because you can (though it's a terrible idea) actually have a class/package named 'HASH' and it'd mean a completely different thing than compared to checking for the reftype.

[Grinnz]

Always returning false for unblessed refs and not checking against reftypes, but not dying, would sufficiently replace the need for UNIVERSAL::isa or $_isa, IMO.

[leonerd]

@Grinnz @simcop2387 Indeed. I think $x isa Foo should always be false if $x is not a blessed object reference. That is, all non-refs and all unblessed refs are never isa anything - not even [] isa ARRAY. It must be blessed in order to be isa something.

[Grinnz]

Well, non-refs would be used as class names. undef should probably be specially false.

[xenu]

I don't understand why isa "deserves" to be an infix operator while ref does not.

[xenu]

On second thought, while ref($foo) eq 'something' is extremely common, it's not the only way how ref can be used, so unlike isa it doesn't translate into an infix operator that easily.