You can save a bit of memory by first grepping for defined elements inside each array, and then combining them:

my @flat = map { grep defined, @$_ } @{$aoa};
[download]

That way the "big" list with all the elements, including the undefs, isn't fully created in the first place.

my @flat = map { (defined @$_) ? @$_ : () )@{$aoa};
[download]

That does something else then what the OP does. You're filtering out the undefined elements of @$aoa (that is, top level elements), while the OP wants to remove (according to his code), the undefined elements of the elements of @$aoa.

That is, if $aoa is

[
  [2, undef, 4],
  [undef, undef, 5],
];
[download]

he wants to end with

(2, 4, 5)
[download]

not with

(2, undef, 4, undef, undef, 5)
[download]

which is what your code ends up with.

Note that you probably intended to write defined $_ instead of defined @$_.

Yes, thank you.

Update:


#!/usr/bin/perl -w
use strict;
use Data::Dumper;
$|++;

my @AoA = ( undef,
            [1, 2],
            undef,
            [3, 4]);
          
my @flat = map{defined (@$_) ? @$_ : ()}@AoA;

print join (",",@flat),"\n"; # prints: 1,2,3,4

my $AoAref = \@AoA;

@flat = map{ defined (@$_) ? @$_ : () }@$AoAref;
print join (",",@flat),"\n"; # prints: 1,2,3,4

=so far prints:...
1,2,3,4
1,2,3,4
=cut

@AoA = ( undef,
         [1, undef],
         undef,
         [3, 4]);
$AoAref = \@AoA;         

# "undef" is a legal Perl value.
# to handle this idea of an undef value within
# an defined array (undef is a legal Perl value)! Yes, use grep.
#
# my map filters out "undefined references to arrays"
# within an AoA, I would use grep to filter 
# that undesired "undef" value out if what is meant
# a value within in an array.
# as shown before: grep{} map{}.
[download]

My code is just a special case.
The more general case is to flatten the whole thing out and grep out the undefined values provided that if what is meant by "sparse" is that not only entire rows are missing but also columns within defined rows. "undef" is a legal Perl value and requires some kind of "grep" to "get rid of it"

@flat = map { @$_ } grep { defined } @{$aoa};
[download]

is there a more efficient way to eliminate all the undefs right there inside the map()

my @flat = map defined ? @$_ : (), @$aoa;

[download]

Or perhaps:

my @flat = map ref eq 'ARRAY' ? @$_ : (), @$aoa;

[download]

@flat = grep {defined} map {@$_} grep {$_} @AoA;
[download]

I'm not the biggest fan of using EXPR ? LIST : () inside a map just to avoid writing grep.