Hello citi2015,

I meant Perl’s design decision to remove the aliasing when @_ is assigned-to within a subroutine.

You can, of course, do the swap by explicitly accessing the subroutine arguments as individual elements of @_:

sub swap
{
    my $temp = $_[0];
       $_[0] = $_[1];
       $_[1] = $temp;
}
[download]

— but note the necessity of “remembering” the initial value of $_[0] by storing it in a temporary variable. And I think that answers my question: if the aliasing were not removed, @_ = reverse @_ would produce wrong results, because some elements would be changed (assigned-to) before they were assigned-from.

Hope that helps,

Sorry, your theory is wrong.

A list assignment doesn't need a $temp var and there is no race condition.

 
  DB<100> sub rev { ($_[0],$_[1]) = ($_[1],$_[0]) }

  DB<101> @a=("A","B")
 => ("A", "B")

  DB<102> rev @a

  DB<103> @a
 => ("B", "A")
[download]

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

PS: Je suis Charlie!

Hello LanX,

Thanks for that, it’s good to know. Perl continues to surprise! I looked in the Camel Book, but the section on “List Assignment”¹ doesn’t cover this behaviour. Do you know where it’s documented?

I’m intrigued to know how Perl accomplishes this. I wrote the following, but it left me none the wiser:

Read more... (916 Bytes)

It looks as though the virtual machine:

1. accesses the right-hand variables
2. accesses the left-hand variables
3. performs the assignments

So it must create temporary copies of the right-hand variables “under the hood”?

¹Chapter 2, pages 82–83 in the 4^th Edition.

Athanasius <°(((>< contra mundum

Iustus alius egestas vitae, eros Piratica,

Since perl can do multiple assignments in one swell foop, this would work too, avoiding the temporary variable:

sub swappy {
   ($_[0], $_[1]) = ($_[1], $_[0])
}
[download]

...roboticus

When your only tool is a hammer, all problems look like your thumb.