Some recent nodes about inside-out objects got me thinking about how to find out about the implementation of a regular object.

If you have to ask, you're probably doing something scary and probably dangerous. The purpose of inside-out objects is to prevent you from doing such dangerous things accidentally.

For curiosity's sake, reftype() is the most accurate approach, though heed ysth's example carefully. The documentation is the best place to learn what you can and cannot and should and should not do with an object.

well, exactly, it's dangerous. My impression of the purpose of inside-out objects is to prevent users from messing up the contents of hashref in the implementation, which I assume means directly change the content via the object reference, and to do that one needs to know its type (reference of hash, array, scalar , etc.), hence my original question.

package Hello;
use strict;

sub new {
    my $class = shift;
    my $this = {};
    return bless $this, $class;
}

1;
[download]

And here we use this script:

use strict;
use Hello;

my $a =  Hello->new();
print $a;
[download]

When the above is run, it gives:

Hello=HASH(0x225388)

..which is self-documenting. ;) Hope this helps!

eval { keys %$ref } ;
print "its a hash" unless $@;
[download]

use overload '%{}'=>sub{{}};
sub new { bless [] }
$ref = new();
eval { keys %$ref } ;
print "is it a hash?" unless $@;
[download]

That'd be the correct answer most of the time - if an object promises says it "can do" a hash interface, its up to everyone but the most sneaky to go by that.

I'd probably use:

BEGIN {
    *isa= \&UNIVERSAL::isa;
}
... isa( $ref, 'HASH' ) ...
[download]

which isn't perfect, but neither are any of the techniques I've seen that aren't unreasonably complicated, unfortunately.

neither are any of the techniques I've seen that aren't unreasonably complicated, unfortunately.

Is:

use Scalar::Util qw( reftype );
...
print "$ref is a ", reftype( $ref ), "\n";
[download]

unreasonably complicated?

I guess you are assuming that it is perfect. But it isn't. It prevents you from properly handling overloaded objects that know how to act like a hash ref even though they aren't.

Of course, it is also overly complicated in many cases. For example, on the version of Perl I have most handy, it simply dies with Can't locate Scalar/Util.pm and overcoming that is rather hugely complicated, as it happens.

- tye        

It has the misfortune of working correctly, as opposed to ref or UNIVERSAL::isa().

It would be helpful to look at perlobj. The function that you are looking for is ref. Here is an example from perlobj, that shows what you are looking for:

$a = {};
$b = $a;
bless $a, BLAH;
print "\$b is a ", ref($b), "\n";
[download]

Actually, ref doesn't give the underlying implementation. In the example code you gave, it should give 'BLAH', which doesn't tell you if 'BLAH' is an arrayref, or a hashref:

for my $i ( [], {} ) {
    bless $i, 'BLAH';
    printf( "%s\t%s\n", ref($i), $i )
}
[download]

I typically use tye's answer, and go with UNIVERSAL::isa. (eg, if I'm dealing with structures passed in from a SOAP call, and I want to make sure the structure is right, even if the class name is wrong, before I start to manipulate it)