use Tie::Hash::Array;

tie my %hash, 'Tie::Hash::Array';

foreach(a..z){
    tie my %tmp, 'Tie::Hash::Array';
    my $t = $_;
    foreach my $i(0..5){
        $t++;
        $tmp{$t} = $i;
    }
    $hash{$_} = \%tmp;
}

use Data::Dumper;
print Dumper \%hash;

untie %hash;

__OUTPUT__

$VAR1 = {
          'a' => {
                   'b' => 0,
                   'c' => 1,
                   'd' => 2,
                   'e' => 3,
                   'f' => 4,
                   'g' => 5
                 },
          'b' => {
                   'c' => 0,
                   'd' => 1,
                   'e' => 2,
                   'f' => 3,
                   'g' => 4,
                   'h' => 5
                 },
          'c' => {
                   'd' => 0,
                   'e' => 1,
                   'f' => 2,
                   'g' => 3,
                   'h' => 4,
                   'i' => 5
                 },
          'd' => {
                   'e' => 0,
                   'f' => 1,
                   'g' => 2,
                   'h' => 3,
                   'i' => 4,
                   'j' => 5
                 },
          'e' => {
                   'f' => 0,
                   'g' => 1,
                   'h' => 2,
                   'i' => 3,
                   'j' => 4,
                   'k' => 5
                 },
          'f' => {
                   'g' => 0,
                   'h' => 1,
                   'i' => 2,
                   'j' => 3,
                   'k' => 4,
                   'l' => 5
                 },
          'g' => {
                   'h' => 0,
                   'i' => 1,
                   'j' => 2,
                   'k' => 3,
                   'l' => 4,
                   'm' => 5
                 },
          'h' => {
                   'i' => 0,
                   'j' => 1,
                   'k' => 2,
                   'l' => 3,
                   'm' => 4,
                   'n' => 5
                 },
          'i' => {
                   'j' => 0,
                   'k' => 1,
                   'l' => 2,
                   'm' => 3,
                   'n' => 4,
                   'o' => 5
                 },
          'j' => {
                   'k' => 0,
                   'l' => 1,
                   'm' => 2,
                   'n' => 3,
                   'o' => 4,
                   'p' => 5
                 },
         ....
[download]

- Tom

What I (think I) want is to tie *all* the hashes in the hash of hashes so that they are always retrieved sorted, so that the output from Data::Dumper is always consistent.

This is overkill of a level that boggles my mind. You can either upgrade Data::Dumper so you can use the Sorted Sortkeys method available in later releases, or do some minor surgery to Data::Dumper itself (dont forget to rename it so you dont accidentally overwrite it or something) and leave it at that. Doing this via a Tie is going to be Very Hard, hacking dumper to produce sorted output is so close to trivial Ill just leave it at that.

I don't know if you can overload keys, but that might be the way to go.

<plug>
If your needs change, and you are looking for something more robust in maintaining sorted order, you can look for Tie::Hash::Sorted when it is released in the next few days. In the interim, you can read about it here and here.
</plug>

Cheers - L~R

Thanks to all who have provided replies, they're all helpful. The approaches described are about what I thought I might have to do to get this working. It is, however, exceedingly helpful to know that loops will be required to build such data structures (or else mods to the dumping code) and that more magical ways have not been invented for this kind of problem.