use Algorithm::Loops qw( NestedLoops );
my $iter= NestedLoops(
    [ [1], [ 2, 3, 4 ], [5], [ 6, 7, 8 ], [9] ],
);
my @perms;
while(  @perms = $iter->()  ) {
    print @perms, "\n";
}
[download]

Or, if we want to exactly match the original request, it is easy to transform to:

use Algorithm::Loops qw( NestedLoops );

sub expandSubLists
{
    my $av= shift(@_);
    return [
        NestedLoops(
            [ map ref($_) ? $_ : [$_], @$av ],
            sub { [@_] },
        ),
    ];
}
[download]

which, of course, chews up a lot of memory if given a lot of selections to generate.

- tye        

use strict; 
use warnings;
use Data::Dumper;

my $params = [ [ 2, 3, 4 ], 5, [ 6, 7, 8 ], 9 ];

sub get_numbers{
    my $array = shift;

    my ($car, @cdr) = @$array;
    ref $car or $car = [$car];
    @cdr or return $car;
    [ map {
    my $n = $_;
    map {[$n, (ref $_ ? @$_ : $_)] } @{get_numbers(\@cdr)};
    } @$car ];
}

print Dumper(get_numbers($params));
[download]

That does it... thanks !
--------------
It's sad that a family can be torn apart by such a such a simple thing as a pack of wild dogs

The code there won't traverse arrayrefs (sub-arrayrefs) and lists permutations (my fault for bad wording in the title) - I need them in order. But it's a good place to start, so thanks!
--------------
It's sad that a family can be torn apart by such a such a simple thing as a pack of wild dogs

use strict; 
use warnings;
use Data::Dumper;

my $params = [ 1, [ 2, 3, 4 ], 5 ];

use List::Util 'reduce';

sub multiplex {
    reduce {
        my $aref = ref($a) ? $a : [[$a]];
        my $bref = ref($b) ? $b : [$b];
        [
         map {
             my $b_item = $_;
             map [ @$_, $b_item], @$aref
         } @$bref
        ]       ;
    } @{shift()};
}

print Dumper(multiplex($params));
[download]

sub multiplex {
    my $ret = [[]];
    for (@{shift()}) {
        my $bref = ref($_) ? $_ : [$_];
        $ret =
          [ map {
              my $b_item = $_;
              map [ @$_, $b_item], @$ret;
            } @$bref
          ];
    }
    $ret;
}
[download]

Note that using reduce seems to be a little bit faster.
Nothing concerning, though.

             Rate no_reduce    reduce
no_reduce 42123/s        --       -2%
reduce    42955/s        2%        --
[download]



acid06
perl -e "print pack('h*', 16369646), scalar reverse $="

Unfortunately the perldoc installation is incomplete on the UNIX machine I am using. I found it though, and am looking into it now - thanks!
--------------
It's sad that a family can be torn apart by such a such a simple thing as a pack of wild dogs

A similar question was asked here earlier this week, and I suggested my module Set::CrossProduct. It's not the only module solution though.