Here's an interesting experiment (well, I think it's interesting, as I wasn't quite sure how it would turn out):

#!/usr/bin/perl -w
 
use strict;
use warnings;
use Data::Dumper;
 
my %hash = (
    'a' => 'b',
    'c' => 'd',
    'e' => [ 'F', 'G', 'H' ],
    'i' => {
        'J' => 'K',
        'L' => 'M',
    },
);
 
as_hash(%hash);
as_array(%hash);
 
 
sub as_hash {
    my (%hash) = @_;
    printf "Dump of hash as a hash => %s\n", Dumper(\%hash);
    my $hash_i_J = $hash{'i'}{'J'};
    printf "hash{i}{J} = '%s'\n", $hash_i_J;
}
 
 
sub as_array {
    my (@array) = @_;
    print "\nEach element of \@array:\n";
    map { print "- $_\n" } @array;
    printf "\nDump of hash as an array => %s\n", Dumper(\@array);
    as_hash(@array);
}
[download]

Which outputs:

Dump of hash as a hash => $VAR1 = {
          'e' => [
                   'F',
                   'G',
                   'H'
                 ],
          'c' => 'd',
          'a' => 'b',
          'i' => {
                   'J' => 'K',
                   'L' => 'M'
                 }
        };
 
hash{i}{J} = 'K'
 
Each element of @array:
- e
- ARRAY(0x804c8d4)
- c
- d
- a
- b
- i
- HASH(0x806024c)
 
Dump of hash as an array => $VAR1 = [
          'e',
          [
            'F',
            'G',
            'H'
          ],
          'c',
          'd',
          'a',
          'b',
          'i',
          {
            'J' => 'K',
            'L' => 'M'
          }
        ];
 
Dump of hash as a hash => $VAR1 = {
          'e' => [
                   'F',
                   'G',
                   'H'
                 ],
          'c' => 'd',
          'a' => 'b',
          'i' => {
                   'J' => 'K',
                   'L' => 'M'
                 }
        };
 
hash{i}{J} = 'K'
[download]

I wanted to see what happened when the hash got interpreted as an array, and then back into a hash again.  No problem, you can treat it as an array, then treat that array as a hash, and it's all still there in the same original format (as witnessed both by dumping the structure with Data::Dumper, and by accessing $hash{i}{J}).

So when you say that doesn't work if the hash has to be more than one level deep, what part do you think isn't working?

Hi, I was not surprised:) perl passed a flat list of "aliases" so it does not matter if the list comes from hash or array. Still "my assignment" just creates a shallow copy, so one should be aware of it. In a context of options (which are treated read-only) this should not be problematic

hth --stephan

In what way does it not work for multi-layers?

Module::foo(
  blah => 'zap',
  baz => [ 4, 12, 15, 'Fibonacci' ],
  froop => {
    thwap => 'funny'
  },
);
[download]

  my $self = undef;
  if (ref $_[0] and UNIVERSAL::isa($_[0], __PACKAGE__))
  {
    $self = shift;
  }
  my %args = @_;
[download]

Now, granted, a hashref can be faster than this, but that wasn't your question.

You've just broken polymorphism with your use of ref() and UNIVERSAL::isa(). The correct incantation follows.

defined( blessed( $_[0] ) ) and $_[0]->isa( __PACKAGE__ )

⠤⠤ ⠙⠊⠕⠞⠁⠇⠑⠧⠊

Update: I forgot to mention that CGI's functions can be called both as a methods and as functions. From the thread title, that sounds like what you want to do. Check it out!

Thanks Ikegami - it makes me more comfortable about going the href route to know that as popular a module as CGI went there already.

-M

Free your mind

But the problem I am actually having with providing support for a coerced hash (or even an ordered list of parameters for that matter) is this:

my $oref = OtherModule -> new();
Package::method( $oref, 'gotcha' );
[download]

Devel::Caller::called_as_method()

I'm looking for a job.

ref($_[0]) works if you use named parameters, since the first arg is either an object or a parameter name.

sub method {
        my $self = $_[0]; # leave it alone for obj/hashref
        unless( ref( $self ) || !$#_ ) { # else is immed. hash or
                                 # list of pairs
                my %opt = @_;
                $self = \%opt;
        }

        # now $self can be processed as a hashref whichever
        # of the four calling styles was used
}
[download]