No. You'd have to do this in XS and outside of the published API. Even when you're in XS the published API just tells you to reset the iterator prior to using it. I suppose what you could do is track which key you were currently at, let the iterator get perturbed then reset it and advance it til you find the same key again.

Just to clarify (for all respondants) I'm investigating a bug in Data::Rmap where the following loops off forever:

perl -MData::Rmap=rmap_hash -le 'rmap_hash {print keys %{$_->{a}} } ({
+a=>{1,2}})'
[download]

I'm not certain, but I suspect that the keys call interacts with this line, from Data::Rmap:

push @return, $self->_rmap($_) for values %$_;
[download]

Since the module is for general use, XS or tie-ing aren't really options. Also, $_ is aliased during the callback so that things, including hashes can be changed (sometimes leading to different disasters). This further constrains the solution space.

Thanks for your tips,

Brad

Update: I think autovivification is to blame

# added exists check
perl -MData::Rmap=rmap_hash -le 'rmap_hash {print keys %{$_->{a}} if e
+xists $_->{a} } ({a=>{1,2}})'
1
[download]

Well... you'd probably better modify whatever you were given so it is read-only so the iterators *can* be reset and then you'd better do the reset/iterate-to-orig thing. Or... avoid ever using each() in Data::Rmap or take the "call arbitrary code" part out of Rmap or disallow using hashes.

⠤⠤ ⠙⠊⠕⠞⠁⠇⠑⠧⠊

push @return, $self->_rmap($_) for values %$_;
[download]

Hmm, if you do this another way, you must be able to avoid the problem:

push @return, map { $self->_rmap($_) } values %$_;
[download]

Here, values is finished before the map even starts.

However... you won't have a problem in the original unless the values is traversed lazily. You never know...

If you end up wanting to make your own iterator, here's one:

sub make_hash_iterator {
   my ($hash) = @_;
   my @keys = keys %hash;
   return sub {
      return () if !@keys;
      if (wantarray) {
         my $key = shift(@keys);
         return ($key, $hash->{$key});
      } else {
         $_[0] = shift(@keys);
         return 1;
      }
   };
}

my $i = make_hash_iterator(\%hash);
while ($i->(my $key)) {                # scalar context
   ...
}

my $i = make_hash_iterator(\%hash);
while (my ($key) = $i->()) {           # list context
   ...                                 # Will fail for '' and '0'
}                                      # without parens around $key.

my $i = make_hash_iterator(\%hash);
while (my ($key, $val) = $i->()) {
   ...
}
[download]

dragonchild,
Thanks for the plug. One of these days I am going to dust off that module, address some POD issues, and add a few new features. With regards to a lexical iterator, Localizable / customizable 'each' iterator for hashes by our very own davido may be of interest.

Cheers - L~R

Ah, that satisfies my curiosity.

Thanks

There is a single iterator for each hash, shared by all each, keys, and values function calls in the program; it can be reset by reading all the elements from the hash, or by evaluating keys HASH or values HASH . If you add or delete elements of a hash while you're iterating over it, you may get entries skipped or duplicated, so don't.

You may find the discussion in the node The Anomalous each() interesting (but probably not helpful).

(I can see why this could be too inefficient for production code, but maybe useful for debugging, I'm thinking...)

best, andye

my $href = \%hash;
my $aref = [];
@$aref = keys %hash;
for ( my $i = 0; $i <= $#$aref; $i++ ) {
    # do something with $href -> { $aref -> [$i ] }
    $href -> { $aref -> [$i] }{ XYZ }{ _callback } ( $href, $aref, $i 
+);
    # do more with $href -> { $aref -> [$i] }
}
[download]