dump a perl data structure in a compact, human readable format

I wrote the following pair of functions for debugging Regexp::Assemble. It only deals with hashes, arrays and undef, but it sounds like that that's all you need.

The display is about as minimal and compact as I can get it.

sub _dump {
    my $path = shift;
    return _dump_node( $path ) if ref($path) eq 'HASH';
    my $dump = '[';
    my $d;
    my $nr = 0;
    for $d( @$path ) {
        $dump .= ' ' if $nr++;
        if( ref($d) eq 'HASH' ) {
            $dump .= _dump_node($d);
        }
        elsif( ref($d) eq 'ARRAY' ) {
            $dump .= _dump($d);
        }
        elsif( defined $d ) {
            $dump .= (
                ($d =~ /\s/ or not length $d)
                    ? qq{'$d'}
                    : $d
            );
        }
        else {
            $dump .= '*';
        }
    }
    $dump . ']';
}

sub _dump_node {
    my $node = shift;
    my $dump = '{';
    my $nr   = 0;
    my $n;
    for $n (sort keys %$node) {
        $dump .= ' ' if $nr++;
        if( $n eq '' and not defined $node->{$n}  ) {
            $dump .= '*';
        }
        else {
            $dump .= "$n=>" . (
                ref($node->{$n}) eq 'ARRAY'
                    ? _dump($node->{$n})
                    : $node->{$n}
            );
        }
    }
    $dump . '}';
}
[download]

I wasn't able to make complete sense of your data structure; I suspect you just invented it off the top of your head. Nevertheless:

my $ref = {
    a => [ 1, 2, 3 ],
    b => [
        { X => 1, Y=> 2 },
        {
            X => [ 1, 2, 3 ],
            Y => [ 4, 5, 6 ],
            Z => [ 7, 8, 9 ]
        },
    ],
};

print _dump($ref);
[download]

produces