That's not how I understand the output. It seems FETCHSIZE is only called once, but each element is fetched right before the iteration:

#! /usr/bin/perl
use warnings;
use strict;
use feature qw{ say };

{   package My;
    use Tie::Array;
    use parent -norequire => 'Tie::StdArray';
    sub TIEARRAY {
        warn "TIE: @_\n";
        my $class = shift;
        bless [@_], $class
    }
    sub FETCHSIZE {
        warn "SIZE: @_\n";
        return scalar @{ $_[0] }
    }
    sub FETCH {
        warn "FETCH: @_\n";
        my ($ar, $idx) = @_;
        my $e = $ar->[$idx];
        return ++$e
    }
}

for my $e (do { tie my @ar, 'My', qw( a b c ); @ar } ) {
    say "MAIN: $e";
}
[download]

TIE: My a b c
SIZE: My=ARRAY(0x21eff40)
FETCH: My=ARRAY(0x21eff40) 0
MAIN: b
FETCH: My=ARRAY(0x21eff40) 1
MAIN: c
FETCH: My=ARRAY(0x21eff40) 2
MAIN: d
[download]

for my $e (@ar), on the other hand, calls FETCHSIZE before each FETCH.

It seems FETCHSIZE is only called once, but each element is fetched right before the iteration:

That's correct. for (@a) iterates over the indexes as if you had done for (0..$#a). This differs from for ((), @a), which retrieves the contents of @a up front.

Yup, I was referring to for(), where an additional FETCHSIZE is invoked for each iteration, which is useful in the case where we want to size to be dynamic/growing.

This:

for (tie @ary, "My::Class", "some", "contents";) {
   ...
}
[download]

is exactly what you should NOT be doing

Read: Tying-Arrays: If someone outside the class tries to dereference the object returned (doubtless thinking it an ARRAY ref), they'll blow up. This just goes to show you that you should respect an object's privacy.

FETCH and FETCHSIZE are exactly for that you can: 'respect an object's privacy':

Something like this:

my $aryt = tie @ary, "My::Class", "some", "contents";
@ary = ... ;
for (0..($aryt->FETCHSIZE-1)) {
    do-something($aryt->FETCH($_));
}
[download]

But isn't the whole point of tie that one can use the tied array as if it were a normal array and all the magic happens without ever calling the classes' methods explicitly?

Yes, my point is that you simply can't assume an object can be de-referenced to an array. The tie mechanism useful for creating algorithms that can handle objects without implying knowledge about their implementation. Otherwise this would defeat the whole purpose using tie. So it is still a good question, any other solutions appreciated.

Perl != Python

the closest to a drop in replacement is maybe a customfunction sub xfor (&&) :

xfor {@arr} sub { ...};
[download]

Didn't hdb just do that? :-)

and from which Perl version on? :-)

Cheers Rolf
_{(addicted to the Perl Programming Language :)
Wikisyntax for the Monastery FootballPerl is like chess, only without the dice}