What you have there is fine. Although, if you don't need it for anything else, you can eliminate @hierarchy and shorten the code a bit. Don't forget warnings too.

#!/usr/bin/env perl 
use strict;
use warnings;

my $order = 0;
my %hierarchy;

$hierarchy{$_} = $order++ for @ARGV;

while( my( $key, $value ) = each %hierarchy ){
    print "$key: $value\n";
}
[download]

much more elegant...thank you!

Unless you can have gaps in your orders (eg: POPE at 0 and CARDINAL at 3 but nothing in between) you can consider your array as a hash that uses a number as key (you just access elements with $hierarchy[$pos] instead of $hierarchy{$pos}). BTW, if you are using the position to select your data rather than the name, it should be the key, not the value.

When I say that an array can be used as a hash (with keys 0..N), you can even use each on it:

while (my ($key, $value) = each @ARGV)
{
  print "$value: $key\n"; # The key is the position
}
[download]

use Data::Dumper;
print Dumper { %ARGV[0,1,3] };
[download]

Edit: so you can also get your hash with %hierarchy = reverse %ARGV[0..$#ARGV] if you want to keep the names as key.

Hello dirtdog,

You do not need to push into an array the @ARGV it is a already an array. Sample of code bellow:

#!/usr/bin/perl
use strict;
use warnings;
use Data::Dumper;

my $count = 0;
my %hasHierarchy;

$hasHierarchy{$_} = $count++ foreach @ARGV;

while( my( $key, $value ) = each %hasHierarchy ){
    print "$key: $value\n";
}

# print Dumper \%hasHierarchy;

__END__

$ perl test.pl POPE PATRIARCH ARCHBISHOP CARDINAL
POPE: 0
CARDINAL: 3
ARCHBISHOP: 2
PATRIARCH: 1
[download]

You can also use Data::Dumper to view complex structures. On the sample of code I have enter the command remove the # and give it a try.

Update: Just a minor note to add, you can use also while loop to process the @ARGV, usually while loops are faster than foreach loops. Have a look on the Benchmark bellow, but also keep in mind that the while loop because we are using shift we will destroy the array. In case you want to reuse the array you need to copy it. In this case foreach loop is faster so a better option. :)

Update 2: I tried to apply minor modifications but still foreach is winning, but at least now they are closer on the comparison. :)

Hope this helps, BR.