Beefy Boxes and Bandwidth Generously Provided by pair Networks
Keep It Simple, Stupid
 
PerlMonks  

Re: Re: Class::Interface -- isa() Considered Harmful

by chromatic (Archbishop)
on Jan 17, 2003 at 17:28 UTC ( [id://227747]=note: print w/replies, xml ) Need Help??


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; }

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

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

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' ); # ...

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:

  • call can() to see if the object can FETCH() -- works on tied hashes, but also works on tied scalars. Doesn't work so well on regular hashes.
  • force all tied hashes that could ever possibly be written to inherit from HASH -- dictates implementation
  • check that $args isa() HASH or isa() Tie::Hash -- leaves out hashes that don't inherit from Tie::Hash
  • check for the existence of a tied-hash specific method, such as TIEHASH() -- better, but still requires another check that it is a regular hash

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'; # ...

    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.

      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] }

        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] }

        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).

Log In?
Username:
Password:

What's my password?
Create A New User
Domain Nodelet?
Node Status?
node history
Node Type: note [id://227747]
help
Chatterbox?
and the web crawler heard nothing...

How do I use this?Last hourOther CB clients
Other Users?
Others studying the Monastery: (5)
As of 2024-03-29 13:15 GMT
Sections?
Information?
Find Nodes?
Leftovers?
    Voting Booth?

    No recent polls found