I'm not sure if the braces around the zero have any effect.

Then find it out:

use Data::Dumper;
# your initialization code here
print Dumper \%hash;
[download]

About your other questions:

$hash{"LISTS"}=[() x $length]

This doesn't do what you want, since you want really references to empty arrays, not empty lists (which get flattened out).

# WRONG
$hash{"LISTS"}=[([]) x $length]
[download]

won't work either, because it returns many references to the same array.

A working solution is

$hash{LISTS} = [ map [], 1..$length ];
[download]

Though often this is not needed at all, thanks to autovivification. This works without error:

my %hash;

# automatically creates $hash{LISTS} as an array ref,
# and $hash{LISTS}[3] as an array ref:
push @{$hash{LISTS}[3]}, 'new item';

# also works for direct assignment:
$hash{LISTS}[4][0] = 'other new item';
[download]

$hash{"COUNTS"} = [ (1) x $length ];
[download]

The parentheses around 1 are needed here (they specify a list). Otherwise you'd get one string "1111111111", because in scalar context the x operator multiplies/concatenates a string.

For your second case:

$hash{"LISTS"}  = [ map [], 1..$length ];
[download]

( () x $length wouldn't work here)

Thanks! Let me compllicate that just a bit. suppose I would like to construct an array of length $arr_len of such hashes. What do I do?

You could apply the same technique:

my @array = map { LISTS => [ map [], 1..$length ] }, 1..$arr_len;
[download]


P.S.: when you play with this, you'll sooner or later encounter curious things like this:

my @array = map { 'foo' => $_ }, 1..3;    # ok

my @array = map { $_ => 'foo' }, 1..3;    # not ok: 'syntax error at .
+.., near "},"'
[download]

This is because Perl has to guess whether the {...} is an anonymous hash or a block (remember, map supports both map EXPR, LIST and map BLOCK LIST syntax).  In order to be sure what is meant, Perl would have to look ahead up until after the corresponding closing curly to see if there's a comma or not, which would disambiguate the interpretation. Perl doesn't do this, because the closing curly could potentially be many lines later... Rather, it expects you to help disambiguate early, like with a unary plus in this case:

my @array = map +{ $_ => 'foo' }, 1..3;   # ok
[download]

(see map for details)

Thanks! Let me complicate that just a bit. suppose I would like to construct an array of length $arr_len of such hashes. What do I do?

specifically, I noticed my @arr = {map { }, 1 .. $arr_len} seems to work, rather than my first guess, which was my @arr = [map { }, 1 .. $arr_len].

But shouldn't we return a array to assign into @arr? hence use square brackets?

What happens if you just start using the hash without initializing it? Most of the time, Perl does the right thing without complaint. If you add to a element that does not exists, Perl pretends it's zero and adds the number. If you push on a non-existent array, Perl creates it and pushes the value.

But if you insist on initializing the hash, use a simple loop:

#!/usr/bin/perl

use strict;
use warnings;

my %hash = ();
my $length = 10;

for my $index ( 0 .. $length-1 ){
  $hash{COUNTS}[$index] = 0;
  $hash{LISTS}[$index] = [];
}

print '%hash ', Dumper \%hash;
[download]

Seeing as OP's question has already been well answered, I just wanted to add a few good resources for further reading - perldsc, perlref and Data::Dumper (for inspecting datastructures). Hope this helps!

How can I visualize my complex data structure? may also be useful. ;-)

HTH,

planetscape

Thanks everybody, it's been a pleasure, as always, to get your wise words.