To make my subroutines and methods more reusable, extensible, and maintainable, I make them receive a hash reference as their only argument and return a hash reference. This has multiple benefits.

First, the parameters going into the subroutine are named when passed in, and these names are used to identify them inside the subroutine. This means that new parameters can be added with keys in the hash, a very minimal change. The same is true of the return hash. Using keys in a hash is far simpler to maintain than using positions in a list. I've spent enough time wrestling with indexed parameters in subroutines that I never use lists of parameters in code that I expect to use more that once (which is basically all of it).

Second, a hash reference is passed in instead of a hash because the reference can be tested using the ref function to ensure that is is actually a HASH ref. Assigning @_ to a hash is not as robust. The same is true of the returned hash reference.

Here is a brief example of a subroutine that receives and returns references to hashes of named parameters:

#!/usr/bin/env perl
use strict;
use warnings;

use feature qw(say); # perl 5.10+

# CPAN modules
use Data::Dumper;
$Data::Dumper::Purity = 1;

my $sendRef = { string => 'Wow! Perl is so awesome, right?' };
my $returnRef = no_punct( $sendRef );
unless ( defined $returnRef and ref $returnRef eq 'HASH' ) {
  say 'no_punct failed to return a HASH ref!';
  exit;
}
print 'with punctuation: '.Dumper( $sendRef );
print 'punctuation removed: '.Dumper( $returnRef );


=head1 Subroutines Begin

=cut

=head2 no_punct( \%params )

Processes each scalar value of a copy of %params and removes any punctuation in it.

Returns a hash reference.

=cut

sub no_punct {
  my $paramsRef = shift;
  my %params = ();
  %params = %$paramsRef if defined $paramsRef and ref $paramsRef eq 'HASH';

  my %return = %params;
  foreach my $k ( keys %return ) {
    if ( ref $return{ $k } eq 'HASH' ) {
      $return{ $k } = no_punct( $return{ $k } ); # recursive call
    } elsif ( ref $return{ $k } eq 'ARRAY' ) {
      foreach my $i ( 0 .. ( scalar @{ $return{ $k } - 1 ) ) {
        $return{ $k }[ $i ] =~ s/[^\w\s\d]//g;
      }
    } else {
      next unless ref $return{ $k } eq 'SCALAR';
      $return{ $k } =~ s/[^\w\s\d]//g;
    } 
  }

  return \%return;
} 

And that's the basics of it. What do you think? Comments are very welcome.