for my $i (0 .. 29) {
    print $stuff->[ $i % @$stuff ];
}
[download]

Using closures and modulo is one way. Define a function that returns a function reference which has a copy of the array reference and knows the last position. Every time you call this unnamed function you will get the next element of the cycle. Using array references will mean that any change of the array will be reflected in your cycling. If this is undesired use arrays instead.

use strict;
use warnings;

my $stuff = [ 'a', 'b', 'c', 'd' ];

sub cyclist {
  my $array = shift;
  my $pos = -1;
  return sub { return $$array[++$pos % @$array]; }
}

my $cyclestuff = cyclist $stuff;

print $cyclestuff->() for 1..30;
print "\n";
$$stuff[0] = 'A';
print $cyclestuff->() for 1..30;
print "\n";
[download]

Here is another way to do it, inspired by hdb's answer, but with a function that takes the array you want to cycle through as a parameter (instead of having a sub that remembers both the array and the associated position for each array). The positions are stored in a hash which uses the stringified arrayref as a key.

I've added some extra food for thoughts: using *cycle to be able to call the sub without the -> notation. blessing one arrayref into the current package to call the function as a method. Or, using the + prototype on a function that calls $sub->() to be able to call cycle2 on either an array ref or a literal array.

use strict;
use warnings;

sub makeClosure
{
        my %pos; # hash that will store the positions of all the array
+s
        return sub
                { 
                        my $array = shift;
                        $pos{$array} //= -1; # To avoid "Use of uninit
+ialized value"
                        $pos{$array} = (($pos{$array})+1) % @$array;
                        return $array->[$pos{$array}];
                }
}
 
my $sub = makeClosure;
my $array1 =[1..4];
my $array2 = ['a'..'c'];

$\ = $/;
print $sub->($array1) for 1..3;
print $sub->($array2) for 1..2;
print $sub->($array1) for 1..3;
print $sub->($array2) for 1..2;
print "__________";  

print "Unblessed reference : ", $array2;
*cycle = $sub;    # &main::cycle is now our closure
use subs 'cycle'; # Tell Perl that there is a function called cycle, b
+ecause there was no 'sub cycle'.
                  # This is only useful if you want to call cycle with
+out parenthesis
bless $array2;    # $array2 is now an object of class 'main'
print "Blessed reference : ",  $array2;
print cycle $array2; # this works because of use subs
print $array2->cycle() for 1..3; # calls main::cycle on object $array2

sub cycle2(+)
{
        my $array = shift;
        $sub->($array);
}
 
print "__________";

print cycle2 $array1;
my @array = qw/Tic Tac/;
print cycle2 @array for 1..4;
[download]

1
2
3
a
b
4
1
2
c
a
__________
Unblessed reference : ARRAY(0x10eb6a0)
Blessed reference : main=ARRAY(0x10eb6a0)
a
b
c
a
__________
3
Tic
Tac
Tic
Tac
[download]

G'day rje,

Here's a solution using state, which therefore requires 5.10.0 or later:

$ perl -Mstrict -Mwarnings -E '
    sub cycle {
        state %i;
        no warnings "uninitialized";
        $_[0]->[($i{$_[0]} % @{$_[0]}, ++$i{$_[0]})[0]];
    }                                                       
    my $a2d = ["a" .. "d"];
    my $e2h = ["e" .. "h"];
    for (1..3) {
        print cycle($a2d) for 1..3;
        print cycle($e2h) for 1..3;
    }                              
'
abcefgdabhefcdaghe
[download]

For earlier Perls, this uses a closure and retains the same level of privacy for %i:

$ perl -Mstrict -Mwarnings -E '
    {          
        my %i;
        sub cycle {
            no warnings "uninitialized";
            $_[0]->[($i{$_[0]} % @{$_[0]}, ++$i{$_[0]})[0]];
        }                  
    }                      
    my $a2d = ["a" .. "d"];
    my $e2h = ["e" .. "h"];
    for (1..3) {
        print cycle($a2d) for 1..3;
        print cycle($e2h) for 1..3;
    }
'
abcefgdabhefcdaghe
[download]

If you only ever want to cycle through a single array (I wasn't sure if that's what your OP was suggesting), then this would be faster (but has distinct limitations):

$ perl -Mstrict -Mwarnings -E '
    sub cycle {
        state $i = -1;
        $_[0]->[++$i, $i %= @{$_[0]}];
    }                                                   
    my $stuff = ["a" .. "d"];                               
    print cycle($stuff) for 1..30;
'
abcdabcdabcdabcdabcdabcdabcdab
[download]

Obviously, that can also be modified for earlier Perls in the same manner as the previous example.

Not that this is any more correct than any other suggestion, but in the past I've used something like:

my @stuff = ( "a", "b", "c", "d" );

{
  my @current_list;
  sub cycle
  {
    @current_list = @stuff unless @current_list;
    return pop ( @current_list ); 
  }
}
[download]