in reply to Re: referances of hashes, and subroutines
in thread referances of hashes, and subroutines

shift and pop are part of the language and are more like operators than subroutines. They can therefore do magic that is not available to mere mortals.

Others will very likely show ways of doing what you would like using deep Perl magic. But in most cases doing such stuff is likely to cause grief in the long run as your eye becomes accoustomed to Perl and gets confused by special magic.

The simple rule is that Perl passes by value. If you want a reference to something then you have to do that explicitely. Confounding that rule (by invoking special magic) will, in the long run, cause trouble because the reader of the code must check every subroutine to see if it might alter parameters in unexpected ways.

DWIM is Perl's answer to Gödel

Replies are listed 'Best First'.
Re^3: referances of hashes, and subroutines
by zer (Deacon) on Apr 22, 2006 at 20:25 UTC
    it isnt as much magical as it is prototyping. 
    use strict;
use warnings;
my %list=("bob" =>123,
          "tom" => "CAT");
sub change(\%){
    my $temp = shift;
    foreach (keys %$temp){
        print $_. " = $$temp{$_}\n";
        $$temp{$_} .= "hello";
    }
}
change (%list);
foreach (keys %list){
    print "$_ = $list{$_}\n";
}

    [download]
    declaring the subroutine as sub change(\%){ will send the values as a reference
[reply]
[d/l]
[select]

      It's magical to the extent that prototypeing is generally frowned on so is one of the lesser known corners of Perl.

      It is also magical in that the local context doesn't provide enough information to understand that there may be side effects when calling the sub. That is dangerous magic. Passing a reference to a sub explicitely is a strong hint that the referent will be altered.

      DWIM is Perl's answer to Gödel
[reply]
        And by the way, it's nice to do a favor for yourself within the subroutine that's receiving the reference to name the variable with a little suffix that implies that the scalar variable is not just a number or a string but that it is a REFERENCE flavor of scalar! e.g.

        use strict;
my %hash = qw( abc xyz );
print "Hash key(s) are:\n";
print "$_\n" foreach my_sub( \%hash );

sub my_sub {
    my ( $hash_hr ) = @_;
    return ( keys %$hash_hr );
}

        [download]
        In this case, since passing a hash reference, my suffix is 'hr'. If it was an array reference, I'd tack on '_ar'. The suffix does nothing to guarantee that what's in that scalar variable is really an array reference or a hash reference, but it sure makes reading over the code later easier when you are trying to remember what each variable is supposed to be doing and how it is built.

        By the way, even though only one argument is being passed, I like my subroutines to receive them from @_ via list context since it makes it easier to grow/evolve the subroutine later on. Same for passing return values....

[reply]
[d/l]
      thanks! This works.
[reply]

In Section Seekers of Perl Wisdom