Don't forget the Data Structures Cookbook, just one part of our lovely perldoc.

There's so much in the perldoc, it can be overwhelming. You might want to check out perltoc, and the old, yet still relevant How to RTFM.

Data::Diver solves this problem nicely:

use strict;
use warnings;

use Data::Diver qw( DiveVal );
use Data::Dumper;

my @pathparts = split(/\//, "dir1/dir2/dir3/file1");
my $href = {};

DiveVal( $href, @pathparts ) = 'value';

print Dumper( $href );
[download]

Output:

$VAR1 = {
          'dir1' => {
                      'dir2' => {
                                  'dir3' => {
                                              'file1' => 'value'
                                            }
                                }
                    }
        };
[download]

Quick and dirty (not recommended):

# this breaks if @pathparts has a double quote in it!
my $element = '$hash' . join '', map { qq|{"$_"}| } @pathparts;
eval "$element = undef";
[download]

Slightly more respectable:

my $step = \%hash;
while ( my $part = shift $pathparts ) {
    $step->{$part} ||= {};
    $step = $step->{$part};
}
[download]

We might be able to help you better if you tell us what you're really trying to do (see XY Problem).

#!/user/bin/env perl

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

my @array = qw(a b c d e f g h i 123);
my $recurse_level = 0;

sub to_hash {
  my $hash_ref = shift;
  my @array = @_; 
  my $array_count = @array;
  die "Need at least 2 elements in original array" if (0 == $recurse_l
+evel && 2 > $array_count);
  my $index;
  if (2 < $array_count) {
    $index = shift @array;
    $recurse_level++;
    $hash_ref->{$index} = to_hash({},@array);
  }   
  else {
    $index = shift @array;
    $hash_ref->{$index} = shift @array;
  }
  return $hash_ref;
}

my $hash_ref = to_hash({},@array); 

print Dumper($hash_ref);
[download]

$VAR1 = {
          'a' => {
                   'b' => {
                            'c' => {
                                     'd' => {
                                              'e' => {
                                                       'f' => {
                                                                'g' =>
+ {
                                                                      
+   'h' => {
                                                                      
+            'i' => '123'
                                                                      
+          }
                                                                      
+ }
                                                              }
                                                     }
                                            }
                                   }
                          }
                 }
        };
[download]

Do I get a simple bonus if I turn your code into a one liner :)

my $h = pop @array; $h = {$_ => $h} for reverse @array;
[download]

It's the same sort of process that's used in building "Trie" trees over a list of words (to analyze "prefix patterns" by building this sort of hash from the letters that spell the words), and there are a few different CPAN solutions for that.