The & prefix also disables prototype checking, but you shouldn't be using prototypes in the first place, so I consider that a very minor point, but if I didn't mention it, someone else would surely raise that flag. {grin}

In our Learning Perl book, we suggest that you always use the ampersand when you're first learning Perl, because otherwise you'll be a bit befuddled when the following code doesn't work:

sub log {
  print STDERR "logging: ", @_, "\n";
}

...
log("starting");
...
log("finishing");
...
[download]

> The & prefix also disables prototype checking, but you shouldn't be using prototypes in the first place,
> so I consider that a very minor point, but if I didn't mention it, someone else would surely raise that flag. {grin}

I was going to ask for clarification here as I thought prototypes were good ju-perl. How mistaken I was, a supersearch lead me to this node Gratuitous use of Perl Prototypes. Another step on the path to enlightenment.

Thanks,
R.

Pereant, qui ante nos nostra dixerunt!

foo("\@_ has elements!");    # prints "Surprise! @_ has elements!"
bar("\@_ has no elements!"); # prints "Surprise!"

sub foo {
    # absent parens say pass my @_
    &baz;
}

sub bar {
    # parens say only pass these arguments (nothing)
    &baz();
}

sub baz {
    print "Surprise! ",join("\t",@_),"\n";
}
[download]

the local @_ is implicitly passed

It's even the same @_. This means that &foo(@_) and &foo; won't behave the same; see perlfaq7, "What's the difference between calling a function as &foo and foo()?". Demonstration:

use strict;

sub foo { pop }

sub bar {
    print "bar before: @_";
    print '&foo      : ' . &foo . "     <--- I am a theif";
    print "bar after : @_   <--- no c";
}

sub baz {
    print "baz before: @_";
    print '&foo(@_)  : ' . &foo(@_);
    print "baz after : @_";
}

bar(qw/ a b c /); print '';
baz(qw/ a b c /);

__END__
bar before: a b c
&foo      : c     <--- I am a theif
bar after : a b   <--- no c

baz before: a b c
&foo(@_)  : c
baz after : a b c
[download]

ihb

See perltoc if you don't know which perldoc to read!

Is there ever a scenario when it's preferrable to use the &

There is one dramatic difference that occurs when you call the function without a parameter list:

#! /usr/local/bin/perl -w

use strict;

sub inner {
    print "  inner: $_\n" for @_;
}

sub outer {
    print "outer: $_\n" for @_;
        inner;
        print "\n";
}

sub outer_amp {
    print "outer_amp: $_\n" for @_;
        &inner;
        print "\n";
}

outer( qw/ vroon gukguk faba / );

outer_amp( qw/ foomp tweedle zachitty / );

__RESULTS__

outer: vroon
outer: gukguk
outer: faba

outer_amp: foomp
outer_amp: tweedle
outer_amp: zachitty
  inner: foomp
  inner: tweedle
  inner: zachitty
[download]

When using the &inner variant, whatever remains of @_ in the calling routine is passed to the called routine. The only time it's really useful is when doing out-of-the-ordinary stuff like autoloading. In general you should avoid it. It leads to bad surprises

PS: metasyntactic function call arguments courtesy of BooK's Acme::MetaSyntactic module, the donmartin theme.

(tye)Re: A question of style

Where can I learn more about this?

A somewhat related inquiry follows at: Subroutine Bewilderment with some helpful comments.