If it's pathalogical, what would be nonpathological?

$param->{'key'}          # { key => $key, value => $value }
[download]

is slightly clearer than

$param->[0]              # [ $key, $value ]
[download]

and much more clearer than

(keys(%$param))[0]       # { $key => $value }
[download]

Update: I missed this:

The non-pathological representation would have: $hash{$key}=[$value1, $value2, $value3,...]

But it's not true. That doesn't maintain order, so the question remains. What would be nonpathological?

"That doesn't maintain order"

The array has the order.

'C':
#define X_coord  0
#define Y_coord  1
#define MAX_ROWS 3

/* graph is a 2-d array of ints
   each row has an X and a Y coordinate
   Normally graph would be built dynamically as an
   array of pointer to array. The same [x][y]
   syntax can be used like in a predefined array.  

   The same [x][y] syntax works in Perl's array of
   references to arrays also. Although in most cases,
   I would consider this a "not good thing". 
*/   
 
for (int row =0; row <MAX_ROWS; row++)
{
   int this_pointX = graph[row][X_coord];
   int this_pointY = graph[row][Y_coord];
   ....
)   
##########
Perl: using Array of Array, about the same as 'C'
      this UGLY...

my $X_coord = 0;
my $Y_coord = 1;
foreach my $i (0..@graph-1) # forget 0..$#graph
                            # needless use of special variable 
{
   my $this_pointX = $graph[$i][$X_coord];
   my $this_pointY = $graph[$i][$Y_coord];
}
##########
Perl: Better than above using Array of Array:
foreach my $row (@graph)
{
   my ($this_pointX, $this_pointY) = @$row;
   ....
}
##########
Perl:
using Array of Hash:
foreach my $point (@graph) # graph is Array of Hash
                           # meaning an array of pointers
                           # to hash tables
{
   my $this_pointX = $point->{'X_coord'};
   my $this_pointY = $point->{'Y_coord'};
   ....
}
# there can be big advantages to avoiding this
# position dependent [$index] stuff as well as the
# need to pre-declare those indicies, The Perl AoH
# works very well to represent some types of C 2-D arrays.
# It is very easy to imagine how an implementer would
# go in that direction.
[download]

I'm wasn't able to locate in that example any occurrences of the keys 'key' and 'value'.