I appreciate your having stuck with me through this. Please understand that this is a gut reaction after first reading of your post (and having previously looked at a CPAN Heap implementation), rather than a fully thought through one. I will pursue this further.

Using a weighted heap, moving an item to the top of the heap requires either:

1. Giving that item a weight higher than every other item in the heap.

   Which could be done by:

   1. Giving the item being promoted the highest possible weight. No good if you need to do it twice.
   2. Iterating the heap to find the highest weight and adding one. One recursive operation that will then trigger another. (In Perl not C)
   3. Remembering the highest value yet allocated and incrementing it. (Possible, but it still triggers a recursive operation at the perl level.)
2. Or: Adjusting the weights of every item between the item being promoted to the top, and the current top item.
3. Then there is the question of how you raise an items weight by 1 or 2 places?
4. And the complexity (and performance) of recursive reference chasing in Perl code.

Contrast this with the simplicity of the splice operation.

Then contrast it with the efficiency of doing the linear operation in C, to recursively dereferencing linked lists implemented using perl hashes or arrays.

O(N) -v- O(log N) doesn't tell the complete story when the the former is performed in C code and the latter in Perl code. Especially, heavily structured OO Perl code.

Then take a look at the complexity (and the weight) of something like Heap::Priority.

The order does matter, because it is my cheap mechanism for retaining and propagating the weightings of the elements. One operation takes care of adjusting all the weights of all the affected items in the stack, because their weights are their positions.

For now, my "string list" mechanism looks like it will be easy to implement:

<pre>
$order = "ABCDE";

    %valByKey    
{ A => \A_value }
{ B => \B_value }
{ C => \C_value }
{ D => \D_value }
{ E => \E_value }
</pre>
[download]

Accessing C via key calls for C to become top item getByKey( 'C' ); does:

sub getByKey {
    my $key = shift;

    ## to top.
    $order =~ s[(^.*)($key)][$2$1]; 

    ## Needs quotemetaing and adjusting for 3-char keys
    ## may also require C<no warnings 'undefined'> 
    ## to prevent that when the item being moved is at
    ## the beginning or the end of the string.

    ## to bottom ## $order =~ s[($key)(.*$)][$2$1];
    ## up one    ## $order =~ s[(.?)($key)][$2$1];
    ## down one  ## $order =~ s[($key)(.?)][$2$1];
    ## up two    ## $order =~ s[(..)?($key)][$2$1];
    ## down two  ## $order =~ s[($Key)(..)?][$1$2];
    
    return $valByKey{ $key };;
}
[download]

Afterwards:

$order = "CABDE";

    %valByKey    
{ A => \A_value }
{ B => \B_value }
{ C => \C_value }
{ D => \D_value }
{ E => \E_value }
[download]

This satisfies all my criteria, it's lightweight, pretty damn fast and easy to program.

It's only limitation (that I can see?) is the fixed length keys, but generalising that can be an exercise for another time.