That one is interesting to watch behind the scenes. You start out with a simple array. Each time you rotate it either

1) There is some spare room in the space allocated for the array and an item is moved into that space and Perl notes that the real array is really further down in that block of space than it used to be

or

2) There isn't any space left in which case a larger space is allocated for the array and the array is placed at the front of that new bigger space.

So the "offset" to finding the first entry will progress something like (from a real run using Devel::Peek):
0, 1, 0, 1, 2, ..., 8, 0, 1, 2, ..., 25, 0, ...

while the space for the array slowly grows without bound (it appears).

Update: Sounds like I stopped experimenting just a bit too soon. Good thing I covered my butt with that "it appears" on the end. (:

On both 5.005 and 5.6 (Linux) I do not see behaviour like that. Here is my code:

use Devel::Peek;

my @a = 1..2;
for (my $i = 0; 1; $i++) {
  print "Stats for $i\n";
  Dump(\@a);
  <STDIN>;
  push @a, shift @a;
}
[download]

The line to look for is "ARRAY =..." When there is an offset it will say "(offset=2)". I find it goes 0, 1, 2, then back to 0, then up to 10, back to zero, up to 10, and so on. Now if I try it with an array of 3 elements it goes up to 1, 0-9, 0-25, 0-25, 0-25... With 4 the same thing only it goes up to 24. Etc.

If anyone wants to play with this, here is an easy script to hack around with. Play with the array size and run it as many times as you want...

use strict;
use IPC::Open3;

my $array_size = shift || 2;

my $code = <<'CODE';
  use Devel::Peek;
  
  my @a = 1..COUNT;
  for (my $i = 0; 1; $i++) {
    print STDERR "Iteration=$i\n";
    Dump(\@a);
    print STDERR "\nITERATE\n";
    push @a, shift @a;
  }
CODE

$code =~ s/COUNT/$array_size/;

open3(\*PIPE, ">&STDOUT", \*OUTPUT, "perl") or die "Cannot run perl: $
+!";

$/ = "ITERATE";
print PIPE $code;
close PIPE;
while (<OUTPUT>) {
  my $i;
  if (/Iteration=(\d+)/) {
    $i = $1;
  }
  else {
    die "Cannot find the iteration in\n$_";
  }
  
  my $off = /offset=(\d+)/ ? $1 : 0;
  printf "Iteration%8d:   Offset%6d\n", $i, $off;
}
[download]

I appreciate tilly's posting so much, that I just had to make figures from it. I modified it a bit to find the maximum offset for various array_lengths. Here are the graphs:

Simple:
max_offset
 1600 ++----------+----------+-----------+-----------+----------+-----
+-----++
      +           +          +           +           +'/tmp/out.txt'**
+***** +
 1400 ++                                                          *   
+     ++
      |                                                           *   
+      |
      |                                                           *   
+      |
 1200 ++                                                          *   
+     ++
      |                                                           *   
+      |
 1000 ++                                                          *   
+     ++
      |                                                           *   
+      |
  800 ++                                                          *   
+     ++
      |                             ******                        *   
+      |
      |                             *     **********              *   
+      |
  600 ++                            *              ***********    *   
+     ++
      |                             *                        ******   
+      |
  400 ++             *              *                                 
+     ++
      |              ***********    *                                 
+      |
      |              *         ******                                 
+      |
  200 ++     *********                                                
+     ++
      + * ****    +  *       +           +           +          +     
+      +
    0 *****-------+----------+-----------+-----------+----------+-----
+-----++
      0          100        200         300         400        500    
+     600
                                   array_length
Better axes:
max_offset / array_length
 9 ++------+-------+-------+-------+--------+-------+-------+-------+-
+-----++
   +       +       +       +       +        +       +'/tmp/out2.txt'+*
+***** +
 8 ++   *                                                             
+     ++
   |   * *                                                            
+      |
   |   * *                                                            
+      |
 7 ++ *   *                                                           
+     ++
   | *    *                                                           
+      |
 6 +*      *                                                          
+     ++
   |*       *                                                         
+      |
 5 *+        *                                                        
+     ++
   |          *                                                       
+      |
   |           *                                                      
+      |
 4 ++          *                                                      
+     ++
   |            **                                                    
+      |
 3 ++             *        *       *       **       *       *       * 
+     ++
   |               **      **      **      ***      **      **      **
+      |
   |                 *     * *     * **    * **     ****    ****    * 
+      |
 2 ++                 *   *   **   *  ***  *   **  *   **   *  ***  * 
+     ++
   +       +       +   ** *+    ** *    ****+   ****+    ** *    **** 
+      +
 1 ++------+-------+-----**+------**------**+-----**+------**------**-
+-----++
   1       2       3       4       5        6       7       8       9 
+     10
                              log2( array_length)
[download]

That's clear: a jump at every 2**(1..$n) length of the array. The jump is to 3 times the array_length at the jump. So now we can deduct the perl source code from this {grin}.

There are small deviations due to the poor representation of lines on the ASCII field. For smaller array lengths, this relation does not hold.

Jeroen
"We are not alone"(FZ)