What argument checking?

sub f {
   my ($arg1,$arg2,$arg3) = @_;
   .... uses arg1, arg2 arg3 ....
}

f();        # Works. ($arg1, $arg2 and $arg3 are undef.)
f(1,2,3,4); # Works. ('4' is ignored.)
[download]

Maybe you're thinking of prototypes? & causes the prototype to be ignored. Use of & is discouraged for this reason. Then again, most prototypes are discouraged as well (for other reasons).

Aside from ignoring prototypes, (&f) means something different than f():

sub f {
   my ($arg1) = @_;
   print(defined($arg1) ? $arg1 : '[undef]', "\n");
}

sub t1 { print("t1: "); f(); }
sub t2 { print("t2: "); &f;  }

t1('moo');  # t1: [undef]
t2('moo');  # t2: moo
[download]

When function f is called using &f (with no arguments), a new @_ isn't created; it shares the @_ of its caller.

Looking at it from the other direction,
f(...);
is equivalent to
do { local @_ = (...); &f };
(when no prototypes are involved).

Update: Added talk of prototypes.

Thanks. But why we want to share @_ with the caller? Please enlighten me. I am a true newbie in perl. Thanks

Sometimes, you want to pass the arguments you received on to the called function. It's more efficient than creating a new @_. Even more efficient is goto(&f) which returns directly to the caller. Both of these tricks are useful when dealing with advanced features and techniques such as AUTOLOAD and currying. This is not something one commonly does, so & is rarely required.

Your coworker's reference or 'argument checking' is probably referring to the fact that when you call a function as &f then any prototype it has is ignored. This isn't relevant if you have not established a prototype for the function in question, so your coworkers criticism does not apply. It is probably a bad idea to call a prototyped functions as &f as confusion is indeed likely to occur.

Hi I have got another explanation that Using & means that it's a user defined subroutine. For example:
&print is a user define print and will not use Perls print function.
Also, if you don't specify the "&", subroutines must be defined before you make a call to it.
But from PErl Best Practise:

sub lock{
   my ($file)=@_;
   print " user defined lock\n";
  
}
sub link{
  my ($text, $url) =@_;
  print " user defined link $text $url\n";
}
print "calling lock: ".lock;  #calls locl, built-in lock hidden;
print "calling &lock: ".&lock; # calls user defined lock
print "calling &link: ".&link("123","123"); # user defined link
print "calling &link: ".&link; #user defined won't print 123
print "calling link: ".link("123","123");  # built-in link
[download]

So my question: is this a strong case for using &?

TheDamian has a lot to say about subroutines in Perl in "Perl Best Practices", among others about prototypes, argument checking and sigil calling.

This is chapter 9 of said Book.

Incidentally, this excact chapter can be downloaded as pdf for free as a sneak preview from its publisher's web site.

sub write_log {
 ...
}

sub write_error {
 ...
}
[download]

write_log('string');
write_error('string');
[download]

write_all('string');
[download]

&write_log;
&write_error;
[download]