FAQ 7.22 What's the difference between calling a function as &foo and foo()?

[PerlFAQ Server]

This is an excerpt from the latest version perlfaq7.pod, which
comes with the standard Perl distribution. These postings aim to
reduce the number of repeated questions as well as allow the community
to review and update the answers. The latest version of the complete
perlfaq is at http://faq.perl.org .

--------------------------------------------------------------------

7.22: What's the difference between calling a function as &foo and foo()?

When you call a function as &foo, you allow that function access to your
current @_ values, and you bypass prototypes. The function doesn't get
an empty @_--it gets yours! While not strictly speaking a bug (it's
documented that way in perlsub), it would be hard to consider this a
feature in most cases.

When you call your function as "&foo()", then you *do* get a new @_, but
prototyping is still circumvented.

Normally, you want to call a function using "foo()". You may only omit
the parentheses if the function is already known to the compiler because
it already saw the definition ("use" but not "require"), or via a
forward reference or "use subs" declaration. Even in this case, you get
a clean @_ without any of the old values leaking through where they
don't belong.

--------------------------------------------------------------------

The perlfaq-workers, a group of volunteers, maintain the perlfaq. They
are not necessarily experts in every domain where Perl might show up,
so please include as much information as possible and relevant in any
corrections. The perlfaq-workers also don't have access to every
operating system or platform, so please include relevant details for
corrections to examples that do not work on particular platforms.
Working code is greatly appreciated.

If you'd like to help maintain the perlfaq, see the details in
perlfaq.pod.

[Michael Carman]

PerlFAQ Server wrote:
>
> When you call a function as &foo, you allow that function access to your
> current @_ values, and you bypass prototypes. The function doesn't get
> an empty @_--it gets yours! While not strictly speaking a bug (it's
> documented that way in perlsub), it would be hard to consider this a
> feature in most cases.

I realize the FAQ isn't a tutorial but it is a tool for learning. To
that end should it mention the primary case where this *is* a feature
(AUTOLOAD)? e.g.

One notable case where this B<is> a useful feature is autoloading.
See L<AUTOLOAD: Proxy Methods> in L<perltoot> for more details.

-mjc

[brian d foy]

In article <uZ74k.205237$yE1.69979@attbi_s21>, Michael Carman
<mjca...@mchsi.com> wrote:

> PerlFAQ Server wrote:

> > When you call a function as &foo, you allow that function access to your
> > current @_ values, and you bypass prototypes. The function doesn't get
> > an empty @_--it gets yours! While not strictly speaking a bug (it's
> > documented that way in perlsub), it would be hard to consider this a
> > feature in most cases.

> I realize the FAQ isn't a tutorial but it is a tool for learning. To
> that end should it mention the primary case where this *is* a feature
> (AUTOLOAD)? e.g.

I don't know if that's the primary case, at least for my use. Simply
mentioning AUTOLOAD doesn't really add anything the answer, but having
a longer example with AUTOLOAD might be fine.

I'll add this to my queue of things to think about.

Thanks, :)