Using a reference to an anonymous array as an element of an array

It appears that you are expecting @AoA and @AwR to be identical, they are not. You can see this with a simple test script:

#!/usr/bin/perl

use strict;
use warnings;
use Test::More;

my $RoR = [[2, 3], [4, 5, 7]];
my @AoA = ([2, 3], [[2, 3], [4, 5, 7]]);
my @AwR = ([2, 3], @{$RoR});

is_deeply(\@AwR, \@AoA, 'arrays match');

This is because of the way in which you are inserting $RoR into @AwR. To create an array identical to @AoA create @AwR without dereferencing $RoR:

my @newAwR = ([2, 3], $RoR);

and test to confirm this is correct:

is_deeply(\@newAwR, \@AoA, 'arrays match');

Ok, now that I got it somewhat clear, I thought I would post what I have as an answer: -

use strict;
use warnings;
use Test::More;

my $RoR = [[2, 3], [4, 5, 7]];
my @AoA = ([2, 3], [[2, 3], [4, 5, 7]], [0]);
my @AwR = ([2, 3], $RoR, [0]);

print "1: ", $AoA[1][1][1], "\n";       # 1
print "2: ", $AoA[1]->[1][1], "\n";     # 2

#print "3(a): ", $RoR[0][1], "\n";      # 3(a) 
print "3(b): ", $$RoR[0][1], "\n";      # 3(b)          
print "4: ", $RoR->[0][1], "\n";        # 4

print "5: ", $AwR[1][0][1], "\n";       # 5
print "6: ", $AwR[1]->[0][1], "\n";     # 6

print "7: ", $AwR[1][1]->[1], "\n";     # 7
print "8: ", @{$RoR}[1]->[1], "\n";     # 8
print "9: ", @{$AwR[1]}[1]->[1], "\n";  # 9

Explanation: -

• First two print statements are straight forward. They both will print the value 5
• 3(a) will not compile, as we cannot access index of anonymous array on reference without an arrow.

• 3(b) works, because now, we have de-referenced our reference - $RoR by using $$RoR

• 4th print statement, is similar to the 3(b), and is a clear way to do what 3(b) is doing. Since RoR is a reference to an anonymous array, so we can't access the elements like the normal array. We have to use an arrow (->). After arrow we can add indices to any level to access nested anonymous array.

$$RoR[0][1] works because, $RoR binds more tightly to the de-referencer $ on the left side, than to the subscript operator on the right side. So, first $RoR is de-referenced to get the array, and then subscript is applied.

Here's a quote from the Perl Documentation: -

Perl's precedence rules on its five prefix dereferencers(which look like someone swearing: $ @ * % &) make them bind more tightly than the postfix subscripting brackets or braces.
The seemingly equivalent construct in Perl, $$aref[$i] first does the deref of $aref, making it take $aref as a reference to an array, and then dereference that, and finally tell you the i'th value of the array pointed to by $AoA

• 5th and 6th print statement are similar to 3(b). Since $AwR[1] contains the reference $RoR only. So, $AwR[1] gets converted to: $$RoR. Hence, $AwR[1][0][1] is similar to $$RoR[0][1] in 5th statement. And the 6th statement: - $AwR[1]->[0][1] gets converted to: - $$RoR->[0][1]. Now here's my doubt. How is 6th statement working. Why can we use an arrow on a de-referenced reference.

• In 7th print statement, $AwR[1][1]->[1] is similar to ${$RoR}[1]->[1]. So, it is clear that de-referencing is done prior to the subscript operator. Hence, we can access the 2nd element on array obtained after de-referencing the reference $RoR.

• 8th and 9th print statement are pretty same. There also, we are de-referencing the reference $RoR. But now, we are de-referencing to an array rather than a scalar.

I have tried to explain in the best way I could. If there is something wrong or something missing in the above explanation, then please point that out. That will help me learn more.

Also, can someone please explain the 5th and 6th print statement. I'll add this to the question above.