my @list=qw(a b c d e f g);

my %hash;
my $hptr=\%hash;
$hptr = $hptr->{$_}={} foreach @list;
[download]

This will work. the innermost key will point to an empty hashref.

Except it will clobber already existing keys/subhashes.

my @list=qw(a b c d e f g);

my %hash;
my $hptr=\%hash;
$hptr = $hptr->{$_}||={} foreach @list;
[download]

Change that assignment to ||= and it works fine. :-)


---
demerphq

_{<Elian> And I do take a kind of perverse pleasure in having an OO assembly language...}

Thanks pete, that seems to be just what I'm looking for. In an attempt to further my own knowledge while unfortunately looking like a complete newb at this perl stuff, is there any way I can con you into explaining how you arrived at that particular solution?

Thanks to everyone else's input... it's appreciated.

I know that each element in the list is going to be a pointer to the one before it. I just save off a reference to where the next insertion should take place. Each time through I create a anonymous hash, insert it into the current hash (the key is the array element, the value is the anonymous hash) and store out a reference to the new hash for the next time through the loop.

Hope that's clear. I'm much better at writing the code than explaining it in english.

-pete
"Worry is like a rocking chair. It gives you something to do, but it doesn't get you anywhere."

-- Randal L. Schwartz, Perl hacker
Be sure to read my standard disclaimer if this is a reply.

use List::Util qw(reduce);
use Data::Dumper;

my @c = (1, 2, 3, 4);
my %d;

reduce { $a->{$b} ||= {} } \%d, @c;
print Dumper \%d;
[download]

$VAR1 = {
          '1' => {
                   '2' => {
                            '3' => {
                                     '4' => {}
                                   }
                          }
                 }
        };
[download]

(reduce { $a->{$b} ||= {} } \%d, @c[0..$#c-1])->{$c[$#c]} = 42;
print Dumper \%d;
[download]

$VAR1 = {
          '1' => {
                   '2' => {
                            '3' => {
                                     '4' => 42
                                   }
                          }
                 }
        };
[download]

Perhaps this:

my %hash = map { $_->[0] => { $_->[1] => { $_->[2] => 1 } } } \@array1
+, \@array2, . . . \@arrayN;
[download]

Should work if each array only has three elements. I'm not sure how to do it for a varying number of elements, but I'll think about it. Thanks for posting an interesting question :)

----
I wanted to explore how Perl's closures can be manipulated, and ended up creating an object system by accident.
-- Schemer

Note: All code is untested, unless otherwise stated

use Data::Dumper;

my @array1 = ('foo', 'bar', 'baz');
my @array2 = ('foo2', 'bar2', 'baz3');

my $hashref = {};
foreach my $a(\@array1, \@array2){
    my $tmpref  = $hashref;
    foreach my $k(@$a){
        $tmpref->{$k} = {};
        $tmpref = $tmpref->{$k};
    }
}

print Dumper $hashref;

__OUTPUT__

$VAR1 = {
          'foo2' => {
                      'bar2' => {
                                  'baz3' => {}
                                }
                    },
          'foo' => {
                     'bar' => {
                                'baz' => {}
                              }
                   }
        };
[download]

I've tried using references to solve it, but that seems to be failing me.
This sounds familiar. The answer could be to add another level of indirection. I'm not referring to any code in particular here, but it still might be what you're after.

Brad