sub f {
  my %hash;
  @hash{ qw/ h s d / } = @_;
  # ...
}
[download]

(That hash slice is equivlent to ($hash{h}, $hash{s}, $hash{d}).)

my ($host)=@_; $host="foo";
[download]

my $hash=shift; $hash->{host}="foo";
[download]

package Foo;
use strict;
use Carp;
use Data::Dumper;

my %defaults=( a => "sn",b=>"afu" );

sub test{shift; print "test:",shift,"\n"}
sub test2{&test};
sub new {
    my $class  = shift;
    my $attrs  = shift;
    my %params = @_;
    my $self=bless {%defaults},$class;
    for my $param (keys %params) {
       croak "Unknown param $param"
             unless exists($self->{$param});
       $self->{$param}=$params{$param};
    }
    for my $attr (keys %$attrs) {
       croak "Unknown attribute"
             unless $self->can($attr);
       $self->$attr($attrs->{$attr});
    }
    return $self;
}
my $t=Foo->new( {
                  test=>"Hello",
                  test2=>"There",
                },a=>1,b=>2);
my $tt=Foo->new();
print Dumper $t,$tt;
[download]

Yves
--
You are not ready to use symrefs unless you already know why they are bad. -- tadmc (CLPM)

I have tried a number of approaches to this error checking problem. None of them completely satisfied me. But for the moment here is the one that seems to work best.

What I do is having a function that does destructive manipulation of my arguments:

# Takes a hashref, a key name, and an optional default.
# Removes that key from the hash, and returns the value or
# the default.  Blows up if there is no value or default.
sub excise_arg {
  my $args = shift;
  my $arg_name = shift;
  if (exists $args->{$arg_name}) {
    return delete $args->{$arg_name};
  }
  elsif (@_) {
    return shift;
  }
  else {
    confess("Missing required argument '$arg_name'");
  }
}
[download]

Call it without a default argument and you have a required key. Put in the default and it is optional. And since it is destructive, it gets rid of the keys and I can use this for a typo check.

# Takes a hashref.  Verifies that it is empty
sub assert_args_done {
  my @left = keys %{ $_[0] };
  if (@left) {
    confess("Unexpected arguments '@left' left over");
  }
}
[download]

And now in a function I can do this:

sub some_func {
  my $args = { @_ };
  my $name = excise_arg($args, 'name');       # required
  my $age = excise_arg($args, 'age', undef);  # optional
  assert_args_done($args);
  # Rest of the code here.
}
[download]

And if I want to take an existing function and wrap it in one that can handle some things itself and wraps the rest, it is easy. I just excise a few arguments and then pass the rest through untested. As long as they are tested somewhere, typos get checked.

If anyone has alternate suggestions for how to handle this problem, I am open. This seems to work pretty well, but I have tried several things, and I don't claim that this is perfect.

UPDATE
Thanks Hofmator for catching my obvious typo. That is what I get for typing something up off of the top of my head. That is also why I use strict. :-)

Nice. I agree with you in that its difficult to do this stuff elegantly, and this is a decent solution. One minor thought though is that you might want to use the poorly documented

local $Carp::CarpLevel=1;
[download]

before your confess calls to make them appear from the correct perspective. Other than that looks good and might get borrowed (if you dont mind...)

Yves
--
You are not ready to use symrefs unless you already know why they are bad. -- tadmc (CLPM)

sub excise_arg {
  my $args = shift;
  my $arg_name = shift;
  if (exists $args{$arg_name}) {
    return delete $args{$arg_name};
  }
[...]
[download]

Shouldn't that be

if (exists $args->{$arg_name}) {
    return delete $args->{$arg_name};
  }
[download]

as you are passing a hashreference into your function?

Apart from that detail I really like this way :)

-- Hofmator

@list = qw (one two three);
%args = ( arg1 => 'string', arg2 => 5, arg3 => \@list );

sub1(%args);

sub sub1 {
   my %args = ( arg1 => 'default',
                arg2 => 0,
                arg3 => undef,
                @_
               );
   print "$_ => $args{$_}\n" for keys %args;
}
[download]

arg1 => string
arg2 => 5
arg3 => ARRAY(0x1a72f84)
[download]

This allows you to pass in the arguments as a hash, provide defaults in the subroutine, and override them with arguments passed in. This is right out of 'Effective Perl Programming' by Joeseph Hall and Randal Schwartz.

Ira,

"So... What do all these little arrows mean?"
~unknown

sub sub1 {
   my %args = ( arg1 => 'default',
                arg2 => 0,
                arg3 => undef,
                @_
               );
}
[download]

I personally prefer this approach because it 1) tells me what parameters I am expecting and 2) it allows me to set defaults. Yes, it takes up a lot of space visually, but who the heck cares since it makes the code that much more readable. :-)

Hah! I finally understood something! Probably something I shd have understood a while ago... namely that a hash in array context is an array. So When I do

@list = qw (one two three);
%args = ( arg1 => 'string', arg2 => 5, arg3 => \@list );

sub1(%args);

sub sub1 {
    print "$_\n" for @_;
}
[download]

I get

arg1
string
arg2
5
arg3
ARRAY(0x17656b4)
[download]

Obvious when you think about it. I mention it here more to fix it in my own mind than in the faint hope of enlightening others, who are probably way ahead of me. But it does make sense for me of a lot of stuff I've been doing on trust, not 100% knowing why it works... like this way of passing arguments to HTML::Template.

§ George Sherston

(well, technically its a list.... but thats for another day)

Another "a-ha!" moment is just one more step away. The '=>' operator is really just a glorified comma. It will quote simple barewords on the LHS, but thats the only difference. Consider the following:

my @a = (1 => 2 => 3 => 4);
print "$_\n" for @a;
[download]

So, the somewhat unfamiliar:

(arg1=>$blah, arg2=>$blah2)
[download]

is really just a very familiar four element list:

( 'arg1' , $blah , 'arg2' , $blah2 )
[download]

dressed up with some syntactic sugar. (note the need to quote 'barewords' when using commas)

With this in mind, take another look at your hash assignment and named argument passing.....

-Blake

    my %args = ( h => $_[0], s => $_[1], d => $_[2] );
[download]