You can do that in a bunch of different ways (this is Perl we speak of so of course you can). Simplest would be something like:

use strict;
use warnings;

my @names = qw(tom harry diana nick sally henry);
my @actions = (\&play, \&eat, \&sleep);

for my $index (0 .. $#names) {
    $actions[$index % @actions]->($names[$index]);
}


sub play {
    print "$_[0] plays\n";
}


sub eat {
    print "$_[0] eats\n";
}


sub sleep {
    print "$_[0] sleeps\n";
}
[download]

Prints:

tom plays
harry eats
diana sleeps
nick plays
sally eats
henry sleeps
[download]

Tie::Cycle is a simple module that implements cyclic arrays through a tied reference (to the array):

use strict;
use warnings;
use Tie::Cycle;

my @names = qw/tom harry diana nick sally henry/;
tie my $cycle, 'Tie::Cycle', [
                              sub{print "$_[0] plays\n"},
                              sub{print "$_[0] eats\n"},
                              sub{print "$_[0] sleeps\n"}
                             ];

$cycle && $cycle->($_) for (@names);
[download]

Prints:

tom plays
harry eats
diana sleeps
nick plays
sally eats
henry sleeps
[download]

The last line ($cycle && $cycle->($_) for (@names);) seems a bit odd, but $cycle->($_) doesn't trigger the FETCH sub in the tied scalar (anybody knows why?) and a first call to $cycle is needed.

You could construct an iterator.

use strict;
use warnings;

my @arr1 = qw{ tom harry diana nick sally henry };
my $iterator = do
   {
       my $idx = -1;
       my @actions = (
          sub { print qq{$_[ 0 ] plays\n} },
          sub { print qq{$_[ 0 ] eats\n} },
          sub { print qq{$_[ 0 ] sleeps\n} },
          );
       sub {
               $idx ++;
               $idx = 0 if $idx > $#actions;
               &{ $actions[ $idx ] };
           };
   };
$iterator->( $_ ) for @arr1;
[download]

The output

tom plays
harry eats
diana sleeps
nick plays
sally eats
henry sleeps
[download]

I hope this is of interest.

Update: Changed array @methods to @actions to avoid confusion since this is nothing to do with OO.

The only 'problem' with these functions is that they return the empty list at the end of an iteration cycle to indicate that the cycle has finished, then start the cycle over again with the first array element(s). Because you seem to want to cycle continuously, you would need logic to detect and 'step over' the end condition.

If you want to roll your own custom iterator, here's an approach (actually, something like this is probably on CPAN already somewhere, I just haven't looked – also, the excellent and freely downloadable Higher-Order Perl discusses this technique in great detail):

Output:

Update: Added link to MJD's HOP.

use strict;
use warnings;

my @array_1 = ("tom","harry","diana","nick","sally","henry");
my @obj = map { new Person (name=>$_) }  @array_1;

$_->action() for @obj;

#------------------------------
BEGIN{
package Person;
    my $actionIndex=0;
    my @actions = qw (play eat sleep);
    my %actsub;

    sub new{
       my ($class, %args )= @_;
       return bless { ACTION => $actions[$actionIndex++ % scalar @acti
+ons],
                      %args,
           }, $class;
    }

    sub action{
      my $self = shift;
       $actsub{ $self->{ACTION} }->($self,@_);
    }

    # Initialize class ...
    for my $actname (@actions){
     $actsub{$actname} = 
      sub {
        my $self = shift;
        print $self->{name} . " likes to $actname\n";
      }
    }
    1;
}
[download]

tom likes to play
harry likes to eat
diana likes to sleep
nick likes to play
sally likes to eat
henry likes to sleep
[download]

the code i've written to map the elements is as follows :


foreach (@array_1)

{

    print "$array_2[0] maps to $_\n";    

    push(@array_2, shift @array_2);

}
[download]

While many of the other solutions are perhaps a closer fit to your problem, I thought that I would show you a solution that is closer to the code that you tried:

use strict; use warnings;

my @array_1 = ("tom","harry","diana","nick","sally","henry");
my @array_2 = ("play()","eat()","sleep()");

foreach (@array_1)

{
    my $action = shift(@array_2);

    print "$action maps to $_\n";    

    push(@array_2, $action);

}

which prints

play() maps to tom
eat() maps to harry
sleep() maps to diana
play() maps to nick
eat() maps to sally
sleep() maps to henry
[download]