glob can do that,

my $combs = [
    map {
        [split //]
    } glob '{a,b,c}{1,2,3}{-,+,\*}'
];
[download]

Wow! Just wow! However, this solution seems not to cope with strings of arbitrary length. So I did some cargo cult programming and "invented" the delimiter.

my $combs = [ map { [split /\./] }
          glob '{CZK,EUR}.{asia,emea,na,sa}.{acad,sopr,user}'
        ];
[download]

But it feels like I brought some kludginess to the code that way. Punymonk

That's exactly how I would have handled longer elements. You can pick any seperator that suits the data.

That's not cargo cult, it's adaptation. Glad you like it :-)

After Compline,
Zaxo

Too bad the other usage of glob (out of file name expansion) aren't documented in the standard documentation...

It's documented indirectly. perldoc -f glob says that glob expansion works as in csh. Try this in csh or bash:

$ echo {a,b,c}{1,2,3}
a1 a2 a3 b1 b2 b3 c1 c2 c3
$
[download]

After Compline,
Zaxo

use Algorithm::Loops qw( NestedLoops );

sub comb {
   my @rv;
   NestedLoops(\@_, sub { push(@rv, [ @_ ]); });
   return \@rv;
}
[download]

Test harness:

Update: What follows is a solution that doesn't require an external module. Neither it nor NestedLoops are recursive. Since they're not recursive, they're probably faster, more memory efficient, and you can use a callback instead of building the result in memory. You could even convert the code below into an iterator.

sub comb {
   my @idx = map { 0    } @_;
   my @max = map { $#$_ } @_;

   my @rv;

   for (;;) {
      push(@rv, [ map { $_[$_][$idx[$_]] } 0..$#idx ]);

      my $i = 0;
      for (;;) {
         $idx[$i]++;
         last if $idx[$i] <= $max[$i];

         $idx[$i] = 0;

         $i++;
         return \@rv if $i == @idx;
      }
   }
}
[download]

The recursive solution.

sub comb{
    return @{ $_[0] } if @_ == 1;
    map{ my $x = $_; map{ "$x$_" } comb( @_ ) } @{ shift() }
}
my @combs = comb [qw(a b c)],[qw(1 2 3)],[qw(- + *)];
[download]

We aware that with this approach taking the product using one of the partial products will be slightly different than with 2 of the original lists. I.E.

A partial list will look like:
[a,1],[a,2],[a,3],[b,1],[b,2],[b,3]

Whereas an original list will be like:
(-, +, *)

So when using a partial product be careful not to end up with something like:
[[a,1],-]

Hope this helps

sub comb {
    my $s = shift;
    if (@_ == 1) { print "$s$_\n" for @{$_[0]}; return; }
    comb("$s$_",@_) for @{shift()};
}
comb '',[qw(a b c)],[qw(1 2 3)],[qw(- + *)];
[download]

    if (@_ == 1) { dowhatever("$s$_") for @{$_[0]}; return; }
[download]

glob is perhaps the prettiest solution, but it isn't recommended for large sets, since all combinations will be generated before any are returned.

So does the comb you wrote.

TedPride,
...but it isn't recommended for large sets, since all combinations will be generated before any are returned.

What makes you think that? In scalar context, glob becomes an iterator. That isn't how it was used, but it could have been. How is a recursive solution any better - it builds the entire solution in memory before returning it.

Cheers - L~R