sub cartesian {
    my @sets = @_;
    # base case
    if (@sets == 0) {
        return ([]);
    }
    my @first = @{@sets[0]};
    # recursive call
    shift @sets;
    my @rest = cartesian(@sets);
    my @result = ();
    foreach my $element (@first) { 
        foreach my $product (@rest) { 
            my @newSet = @{$product};
            unshift (@newSet, $element);
            push (@result, \@newSet);
        }
    }
    return @result;
}
[download]

Update: Sorry, deleted rerroneous post

Rule One: "Do not act incautiously when confronting a little bald wrinkly smiling man."

I had the same thought also (to use a recursive algorithm), but your code didn't seem complete or it didn't work the way I expected. There are certainly more Perlish ways to code this with map etc., but it works. Cartesian product of multiple lists using recursion.

use Data::Dumper;

my $letters = [qw(a b c)];
my $numbers = [1..3];
my $words   = [qw(you me)];

my $result = cartesian($letters, $numbers, $words);

print Dumper( $result );

sub cartesian {
  my ($set, @sets) = @_;

  my @expanded;

  # base case
  if ( !@sets ) {
    foreach ( @{$set} ){
      push @expanded, [$_];
    }
  }

  # recursive call
  else {
    my @product = @{ cartesian(@sets) };
    foreach my $element ( @{$set} ) {
      foreach my $product ( @product ) {
        push @expanded, [ $element, @{$product} ];
      }
    }
  }

  return \@expanded;
}
[download]

  my @C = map { [ $_ ] } @{ shift @_ };
[download]

  my @C = [];
[download]

sub cartesian {
    my @C = [];

    foreach (reverse @_) {
        my @A = @$_;

        @C = map { my $n = $_; map { [ $n, @$_ ] } @C } @A;
    }

    return @C;
}
[download]