You could try List::Comprehensions

use List::Comprehensions;

local $"=",";
print comp1 { "@_\n" } [1,2], [qw(a b)], [qw(# * &)];
[download]

Output:

1,a,#
1,a,*
1,a,&
1,b,#
1,b,*
1,b,&
2,a,#
2,a,*
2,a,&
2,b,#
2,b,*
2,b,&
[download]

Not that you'll be able to turn in the perl list comprehensions one in for your homework either, but . . .

$ echo 'main=do{putStrLn $ unlines $ map show [ (x,y,z) | x <- [1,2], 
+y <- "ab", z <- "#*&"]}' | runhaskell
(1,'a','#')
(1,'a','*')
(1,'a','&')
(1,'b','#')
(1,'b','*')
(1,'b','&')
(2,'a','#')
(2,'a','*')
(2,'a','&')
(2,'b','#')
(2,'b','*')
(2,'b','&')
[download]

Thanks fletch. But could you please write your code a bit more clearly. I can't quite read it. Thanks

say"@$_"for(*_=sub{!@_?():@_==1?map{[$_]}@{$_[0]}:map{my$x=$_;map{[$x,
+@$_]}_(@_[1..$#_])}@{$_[0]}})->([1,2],["a","b"],["#","*","&"]);
__END__
1 a #
1 a *
1 a &
1 b #
1 b *
1 b &
2 a #
2 a *
2 a &
2 b #
2 b *
2 b &
[download]

The code above contains a bug - it returns an empty list when no arguments are given, but it should return a reference to an empty list. Fixing the bug also means the code can be shortened:

say"@$_"for(*_=sub{@_?map{my$x=$_;map{[$x,@$_]}_(@_[1..$#_])}@{$_[0]}:
+[]})->([1,2],["a","b"],["#","*","&"]);
[download]

I keep thinking there must be a way to simplify this with matrix addition. Of course you need the matrices to be of the same order, but you could pad the matrices with empty strings. You'd also have to make the matrix addition code use the . operator instead of +.

A good approach with this type of problem is to think of any information you know up front. As soon as we have the lists we can easily determine the total number of results (by multiplying the lengths together). From there we can work backwards.

use strict;
use warnings;

my @lists = (
    [1, 2],
    ['a', 'b'],
    ['#', '*', '&'],
   );

# we know the total number of results will be:

my $num_results = 1;
$num_results *= $_ for map {scalar @{$_}} @lists;

my $max_i = $num_results - 1;
  
# build the result list entries left to right

my @res = map { '' } 0 .. $max_i;

my $pivot = $num_results;

for my $list (@lists) {

    my $j = -1;
    my $len = scalar @{$list};
    $pivot = $pivot / $len;

    for my $i (0 .. $max_i) {
        $j++ if $i % $pivot == 0;
        $j = 0 if $j == $len;
        $res[$i] .= $list->[$j];
    }
}

print join( "\n", @res), "\n";
[download]

Put the lists into separate tables. Generate the cross join of the whole set of tables. *poof*

Using SQL, you can't be sure that the resulting list will preserve the order of the original lists.

Unsorted original lists and the use of primary keys or clustered tables, the query optimizer, size of lists and blocking factor among others are things I can recall that might change the way the output is returned... :-(

Howdy!

Actually, you can ensure the order of the output, but it requires that the base tables include a column with a sort key. Then you have something you can use in an order by clause.

Fundamentally, generating the cartesian product of the input lists will generate the elements of the output list. Controlling the sequence is a minor additional task.

yours,
Michael

You could also use the glob built-in function although you may need to take care if your lists contain metacharacters significant to glob.

$ perl -le 'print for glob( q{{a,b}{c,d}} );'
ac
ad
bc
bd
$
[download]

$ perl -le '
> @lists = (
>    [ qw{ 1 2 3 } ],
>    [ qw{ a b } ],
>    [ qw{ X Y Z } ],
>    );
> $globStr = 
>    join q{},
>    map { qq{{@{ [ join q{,}, @$_ ] }}} }
>    @lists;
> print for glob $globStr;'
1aX
1aY
1aZ
1bX
1bY
1bZ
2aX
2aY
2aZ
2bX
2bY
2bZ
3aX
3aY
3aZ
3bX
3bY
3bZ
$
[download]

I hope this is helpful.