Re^3: Accessing Arguments inside Subroutines via @

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,

Athanasius <°(((>< contra mundum Iustus alius egestas vitae, eros Piratica,

Comment on Re^3: Accessing Arguments inside Subroutines via @_ Select or Download Code

Replies are listed 'Best First'.

Re^4: Accessing Arguments inside Subroutines via @_
by LanX (Saint) on Mar 20, 2015 at 21:11 UTC

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!

[reply]
[d/l]

Re^5: Accessing Arguments inside Subroutines via @_

by Athanasius (Archbishop) on Mar 21, 2015 at 03:24 UTC

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:

accesses the right-hand variables
accesses the left-hand variables
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,

[reply]
[d/l]
[select]

Re^6: Accessing Arguments inside Subroutines via @_

by LanX (Saint) on Mar 21, 2015 at 12:09 UTC

Athanasius

No idea about the camel book, I have to admit I never read it.

my understanding is that the values from RHS are temporarily pushed on a stack like structure and from there assigned to the LHS.

B::Concise shows

~$ perl -MO=Concise -e '($a,$b)=($b,$a)'
a  <@> leave[1 ref] vKP/REFC ->(end)
1     <0> enter ->2
2     <;> nextstate(main 1 -e:1) v:{ ->3
9     <2> aassign[t5] vKS/COMMON ->a
-        <1> ex-list lKP ->6
3           <0> pushmark s ->4
-           <1> ex-rv2sv sK/1 ->5
4              <#> gvsv[*b] s ->5
-           <1> ex-rv2sv sK/1 ->-
5              <#> gvsv[*a] s ->6
-        <1> ex-list lKPRM* ->9
6           <0> pushmark sRM* ->7
-           <1> ex-rv2sv sKRM*/1 ->8
7              <#> gvsv[*a] s ->8
-           <1> ex-rv2sv sKRM*/1 ->-
8              <#> gvsv[*b] s ->9
-e syntax OK
[download]

so you might wanna look into ex-list (where both sides are stored) and aassign ("array-assign" which is a misnomer).

Unfortunately I couldn't find a good compilation explaining all these ops.

From the Llama (Learning Perl, 3rd Edition)


P is for Practical
	PerlMonks

Re^3: Accessing Arguments inside Subroutines via @_