in reply to Re: Class::Interface -- isa() Considered Harmful
in thread Class::Interface -- isa() Considered Harmful

It was an unclear example.

I hesitate to use this example, knowing that the likely response will be "Tying won't work that way in Perl 6." To forestall those replies, I know that this is the case. I'm also not interested in questions of "Why are you doing this anyway?" This is an example of the shortcomings of relying on inheritance. I can come up with clever hacks to get around all this, but I would rather that I not have to do so.

If you do have a better solution that achives both of my goals (it should be possible to check that things can handle the operations I'm about to perform on them, and this check should not dictate the implementation of these operations), I'm all ears.

Consider a constructor: 

sub new
{
    my ($class, $args) = @_;
    my $self = bless { dbname => $args->{dbhame} }, $class;
    $self->init( $args->{init} );
    return $self;
}

[download]

If $args doesn't exist, the two dereferences will fail. We can check for that: 

sub new
{
    my ($class, $args) = @_;
    return unless $args;
    # ...

[download]

If $args isn't a reference to a hash, the two dereferences will fail. Here's where it gets tricky: 

sub new
{
    my ($class, $args) = @_;
    return unless $args;
    return unless UNIVERSAL::isa( $args, 'HASH' );
    # ...

[download]

That looks fine, and I was happy to use it until I realized it would break if someone passed in a tied hash. Since neither Tie::Hash or Tie::StdHash inherit from HASH, this will fail if I use a tied hash. There are several possibilities:

I much prefer a system that lets me ask one question: am I dealing with something that acts according to this named set of behaviors?

Replies are listed 'Best First'.
Re: Re: Re: Class::Interface -- isa() Considered Harmful
by MarkM (Curate) on Jan 17, 2003 at 22:23 UTC

    As I pointed out in another node in this node tree, you seem to be looking for:

    use Scalar::Util qw(reftype);

sub new
{
    my($class, $args) = @_;
    return unless $args;
    return unless reftype($args) eq 'HASH';
    # ...

    [download]

    Also, it looks as if you are trying to blur the line between Perl object interfaces and Perl blessed reference method interfaces. Since the two are fully independent (any Perl blessed reference can be implemented using a reference to any Perl object), I suggest you are asking the wrong question... :-)

    To expand upon my "any Perl blessed reference can be implemented using a reference to any Perl object" - the initial version of my class could use a HASH to store member fields, while a later version uses an ARRAY to improve on efficiency, and reduce storage requirements. In pure OO philosophy, your code should not rely on how my class stores its member fields. If your code is expecting to get a hash reference as an argument, it is my responsibility as the caller to pass you a hash reference. If my hash reference happens to be blessed, it shouldn't matter. You should use reftype() and not care about the blessed'ness of the structure. It is unfortunate that Scalar::Util was not included in earlier versions of Perl.

[reply]
[d/l]

      No, I am very much not looking for Scalar::Util::reftype, thought it could indeed replace UNIVERSAL::isa. It still dictates implementation, which is what I'm trying to avoid.

      I'm not expecting to rummage around in the internals of an object passed as $args. I'm expecting to deal with something that behaves as a hash. If it's a hash, fine. If it's a tied hash, it ought to work fine too.

      Unfortunately, it doesn't: 

      #!/usr/bin/perl -w

use strict;
use Scalar::Util 'reftype';
use Tie::Hash;

foreach my $package (qw( Scalar Array Code ))
{
    my $h = tie my %new_hash, $package . 'Hash';
    print "Tied $h as a hash based on $package\n";
    print 'It is ' . (UNIVERSAL::isa( $h, 'HASH' ) ? '' : 'not ') . "a
+ HASH\n";
    print 'Its reftype is ' . reftype( $h ) . "\n";
}

package ScalarHash;

sub TIEHASH { bless \(my $foo), $_[0] }

package ArrayHash;

sub TIEHASH { bless [], $_[0] }

package CodeHash;

sub TIEHASH { bless sub {}, $_[0] }

      [download]
[reply]
[d/l]
[select]

        In your example, $h is not a tied hash. $h is a blessed reference to an object that is used to store data for the tied hash. The tied hash is %new_hash.

        For a better example than the one you are presenting:

        use Scalar::Util qw(reftype);

tie(%hash, "ScalarHash");
function_that_expects_a_hash_reference(\%hash);

sub function_that_expects_a_hash_reference
{
    my($hash_ref) = @_;
    reftype($hash_ref) eq 'HASH'
        or die "CALLED WITHOUT A HASH REFERENCE!\n";
    ... $hash_ref->{...} ...
}

package ScalarHash;

sub TIEHASH { bless \(my $foo), $_[0] }

        [download]

        As I pointed out in the node that you were responding to, you are confusing Perl object interfaces (the ability to use a scalar as if it were a hash reference), and Perl blessed reference methods (the ability to use a particular method with an object).

[reply]
[d/l]

In Section Meditations