No, @_ is an alias to the sub's arguments. That's how things like chomp work:

sub my_chomp {
   $_[0] =~ s/\r?\n\z//sm;
}

my $var = "foo\n";
my_chomp $var;
print "[[$foo]]\n";
[download]

perlsub says:

The array @_ is a local array, but its elements are aliases for the actual scalar parameters.

2 effects are overlaying.

• the @arr inside the sub is the same like outside, because you didn't use my again. (Change the name and strict will throw an error, otherwise the function is a closure)
• the elements of @_ are aliases of the elements passed, i.e. the values of @arr (like demonstrated by Tobyink)

Since you reassign these elements with the map, you are effectively changing @_, it's like writing @_ = map { 2 * $_ } @_;

Change this to my @arr = map { 2 * $_ } @_; and your problem disappears

Style tips how to avoid this

G'day pritesh_ugrankar,

Whenever I see code like

&function(...)
[download]

it raises a red flag.

Unless you can expand that to

# In the following code, I am aware of the leading ampersand.
# I have read, and fully understood, all the implications of
# writing the code, as is; having read and completed digested
# all information in http://perldoc.perl.org/perlsub.html.
# I totally intended that code to be written as is because
# ...
# ...
# ...
&function(...)
[download]

To understand my code better, refer to "perlsub - Perl subroutines".

Unless you can confidently fill in all of the blanks in the above comments, you've almost certainly done something wrong.

Not sure what you mean here. Are you complaining about the use of the ampersand with the function call? I usually advise against that too, but in this case the behavior is the same with or without it.

You raise a valid point and I'm definitely not "complaining" about anything. Like you, I "usually advise against" that usage.

My intention was to point out, quite unequivocally, that there was a difference between

&sub(@args)
[download]

and

sub(@args)
[download]

Reviewing what I originally wrote, it's perhaps not immediately obvious that, without a valid reason for writing

&sub(@args)
[download]

it would generally be preferable to write

sub(@args)
[download]

Thankyou for raising this point and providing an opportunity for clarification.

— Ken

Wasn't ampersand bypassing prototype checks?

Edit: yep see Re: What is the point of the & sigil for function refs?

Cheers Rolf
_{(addicted to the Perl Programming Language and ☆☆☆☆ :)
Je suis Charlie!}

Perl arguments are passed by reference. Change them in the sub, and they'll change in the caller and vice-versa.

According to perlsub inside a subroutine the elements of @_ are aliased to the items in the list that are passed to the subroutine. Passing by reference means you pass one or more references in the arguments to the subroutine. Then elements of @_ are aliased to the references and you can make local copies inside the subroutine.

"Pass By Reference" (vs. "Pass By Value") is a general computer science term which is implemented as "aliasing" in Perl.

Perl's "references" are totally different.

update

Context matters: Canadians are North Americans proud not to be Americans. ;)

update

OK, I consider this perlsub#Pass-by-Reference a documentation bug.

Cheers Rolf
_{(addicted to the Perl Programming Language and ☆☆☆☆ :)
Je suis Charlie!}

Before calling the sub test_this @arr: 1 2 3 4 5 6 7 8 9 10
Inside the sub, before the map @arr: 1 2 3 4 5 6 7 8 9 10
Inside the sub, before the map @_ = 1 2 3 4 5 6 7 8 9 10
Inside the sub, after the map @arr: 2 4 6 8 10 12 14 16 18 20
Use of uninitialized value $_[0] in join or string at foo line 11.
Use of uninitialized value $_[3] in join or string at foo line 11.
Use of uninitialized value $_[6] in join or string at foo line 11.
Use of uninitialized value $_[9] in join or string at foo line 11.
Inside the sub, after the map @_ =  _ Use of uninitialized value $_[0]
+ in join or string at foo line 11.
  _ Use of uninitialized value $_[3] in join or string at foo line 11.
  _ Use of uninitialized value $_[6] in join or string at foo line 11.
 
After calling the sub test_this @arr: 2 4 6 8 10 12 14 16 18 20
[download]

panic: attempt to copy freed scalar 7fe03e8040b0 to 7fe03e82c858 at /o
+pt/local/lib/perl5/5.26/darwin-thread-multi-2level/Data/Dumper.pm lin
+e 602.
[download]

Interesting, a bisect with a test program something like this:

my @a=(3);
sub x {
  @a = map {$_*2} @_;
  "@_" eq "6" or die
}
&x(@a);
[download]

says that the first bad commit is a5f4850559, which makes v5.24.0, or more specifically v5.23.2, the first version with this behavior. Since that commit is heavy on the internals and I'm not an expert on that, I can't say more at the moment, although it does seem like a regression to me.

It's not particularly a regression. Perl suffers from a particular over-arching bug, which is hard to fix (which is why it hasn't been fixed yet): elements on perl's execution stack are not reference counted. This means that if you empty something like an array whose elements are on the stack (and will have been aliased to elements of @_ if this is a function call), and if nothing else holds a reference count to those elements, then they will be prematurely freed (and possibly re-allocated) while still accessible.

That commit merely causes that bug to show up where previously it happened to be masked. For example in 5.22.0 with this code:

my @a=(3,4);

sub x {
  @a = ();
  print "[$_]" for @_;
  print "\n";
}

x(@a);
[download]

you get:

$ perl5220 -w ~/tmp/p
Use of uninitialized value $_ in concatenation (.) or string at /home/
+davem/tmp/p line 9.
Use of uninitialized value $_ in concatenation (.) or string at /home/
+davem/tmp/p line 9.
[][]
[download]

Dave.

I guess they did some optimization to speed up code execution and never expected/tested such a weird case where the same values are at LHS as closed overs and at RHS as aliases.

The gaps indicate side effects from changing the execution/evaluation order.

Edit: like not caching a list of the map but iterating and setting each element directly.

Cheers Rolf
_{(addicted to the Perl Programming Language and ☆☆☆☆ :)
Je suis Charlie!}

Respected Monks,

Thank you for taking time to reply.

I used & at the beginning of a function because, as per Learning Perl book, I am to use an & before calling the function, else, I might accidentally end up calling a perl built-in. In fact there is a link given in the book https://www.learning-perl.com/2013/05/why-we-teach-the-subroutine-ampersand/ which if I understood right, is stating it's better to use & when one is not sure.

But from the posts here, I reckon it's not encouraged. So I'm not sure if I should or shouldn't use the &. I will later try to test on other version(s) of Perl and see how it goes.

In that article, brian d foy is saying that using & sometimes avoids trouble for people who are very new to Perl. What the rest of us are saying is that using & causes more trouble for intermediate-level Perl programmers. Decide for yourself which category you are in, but remember that & is old-perl.

Mr foy suggests that it is ok to type "&foo;", but never do that, because it actually passes @_ to foo. Always put the parens. "foo();" or "&foo();", but not "&foo;" unless you really mean it.