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:

• 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?