%AppCode is not a nested hash here. It's a separate hash altogether.

This:

Could have been written as:

my $this_appcode = $AppCode{$ID};
$TotCst{ $this_appcode }
[download]

It's just taking a value from one hash, and using that value as the key to another hash.

Your original:

Could have been written as:

my $this_appcode = $AppCode{$ID};
my $this_csttype = $CstType{$ID};
$TotCst{$this_appcode}->{$this_csttype} += $InvAmnt{$ID};
[download]

So what does the arrow operator actually do? Well, confusingly it performs two different duties in Perl. The first is for object oriented programming: it's the method call operator:

$object->method(@arguments);
Class->method(@arguments);
[download]

But that's not how it's being used here. Here it's the dereferencing operator.

# Here's an array...
my @array = ('foo', 'bar', 'baz');

# Set up a reference (pointer) to the array above.
my $array_ref = \@array;

# We can access an item in the array like this.
warn $array[2];

# But we want to access it via the reference (pointer)
# then we need the arrow:
warn $array_ref->[2];
[download]

What's happening here? The arrow operator takes the thing on the left, which is a reference (pointer) to some other piece of the data, follows the reference to find the data, and then applies whatever's on the right hand side.

So in the example above, it's following the $array_ref pointer to find @array then it's applying the index [2] to it.

As it happens, the arrow is actually optional in your case. This should work just as well:

$TotCst{$this_appcode}{$this_csttype} += $InvAmnt{$ID};
[download]

This is because inside hashes and arrays, any nested hashes/arrays will always be references, so it is unambiguous that they will always need to be dereferenced. In my $array_ref->[2] example, the arrow operator is not optional.

This has been a great help, thanks very much for taking the time to explain. I can now see it's a 2 dimensional hash where the 2 levels of keys are values from 2 other hashes - all falling into place now :-)

$CstType{$ID} is the hash key into an unnamed hash that $TotCst{$AppCode{$ID}} points to.

To get a good picture of it you could use Data::Dumper to show you how $CstType looks like. Data::Dumper shows you hashes and other datastructures exactly as if you had to initialize them with the data in a perl script

my $AppCodeID = $AppCode{$ID};
my $CstTypeID = $CstType{$ID};
my $hash_reference = $TotCst{$AppCodeID};
$hash_reference->{$CstTypeID} += $InvAmnt{$ID};
[download]

A hash of hashes

$foo{bar}{bar} +=3;
$foo{bar}->{bar} +=3;
[download]

Tutorials► Data Types and Variables► Data Type: Hash► references quick reference