Question

Has anybody found a good solution for lazily-evaluated lists in Perl? I’ve tried a number of ways to turn something like

for my $item ( map { ... } @list ) {  } 

into a lazy evaluation–by tie-ing @list, for example. I’m trying to avoid breaking down and writing a source filter to do it, because they mess with your ability to debug the code. Has anybody had any success. Or do you just have to break down and use a while loop?

Note: I guess that I should mention that I’m kind of hooked on sometimes long grep-map chains for functionally transforming lists. So it’s not so much the foreach loop or the while loop. It’s that map expressions tend to pack more functionality into the same vertical space.

Answer 1

As mentioned previously, for(each) is an eager loop, so it wants to evaluate the entire list before starting.

For simplicity, I would recommend using an iterator object or closure rather than trying to have a lazily evaluated array. While you can use a tie to have a lazily evaluated infinite list, you can run into troubles if you ever ask (directly or indirectly, as in the foreach above) for the entire list (or even the size of the entire list).

Without writing a full class or using any modules, you can make a simple iterator factory just by using closures:

sub make_iterator {     my ($value, $max, $step) = @_;      return sub {         return if $value > $max;    # Return undef when we overflow max.          my $current = $value;         $value += $step;            # Increment value for next call.         return $current;            # Return current iterator value.     }; } 

And then to use it:

# All the even numbers between 0 -  100. my $evens = make_iterator(0, 100, 2);  while (defined( my $x = $evens->() ) ) {     print '$x\n'; } 

There’s also the Tie::Array::Lazy module on the CPAN, which provides a much richer and fuller interface to lazy arrays. I’ve not used the module myself, so your mileage may vary.

All the best,

Paul