Iterate over first at most n elements of an perl array - arrays

Question

What is the most pleasant idiomatic way of writing
for (take(100,#array)) {...}
given that there is no take (which takes the first n elements of a list, but fewer if there are not n elements)?
Things I considered:
for (#array[0..99]) {...}
but that fails ungraceful if #array has fewer than 100 elements
for (#array[0..min(99,$#array)]) {...}
but min is not a standard function in Perl
for (splice #array,0,100) {...}
bu that changes the array.

Answer 1

for (#array[0..min(99,$#array)]) {...}
but min is not a standard function in Perl
min is a standard function in the module List::Util, which is part of core as of 5.7.3.
use List::Util qw(min);
for (#array[0..min(99,$#array)]) { # generator in 5.8.8+
...
}
Note that perl 5.8.8 onward, and perhaps earlier, is smart enough to understand that expression as a generator rather than a slice. That is, elements 0 through $terminus are fetched one at a time from #array instead of an anonymous slice being taken and copied.

Answer 2

You want the CPAN module List::Slice
use List::Slice 'head';
foreach my $elem ( head 100, #things ) { ... }

Answer 3

You've indicated you've found the following the cleanest:
take(100, #array)
So to answer your question as to what's the cleanest, that is! I don't see why you're trying to find an alternative.

Answer 4

How about using map:
my #array = qw ( 1 2 3 4 );
print join "\n", map { $_ // () } #array[0..10];
This takes 10 elements from a list, but applies the 'defined' test to it - and if it's not defined, returns an empty list.
So you could:
for ( map { $_ // () } #array[0..100] ) {
#do something
}
Note - // is a defined-or operator, only available from perl 5.10+. You could use instead a defined ternary:
print join "\n", map { defined ? $_ : () } #array[0..10];

Answer 5

You could add an additional check inside of your loop to break once the end is reached.
my #arr = (1 .. 90);
for ( #arr[0..99]) {
last unless defined $_;
say;
}
But that would not work on arrays that have undef values in between, like these:
my #foo = (1, 2, undef, 4);
my #bar;
$bar[2] = 'foo'; # (undef, undef, 'foo')

Answer 6

The other responses have this covered but, just for thoroughness, there are a couple of "pumpkin perl" gather/take implementations on CPAN :-)
List::Gather
Syntax::Keyword::Gather
There is also Damian Conway's Perl6::Gather which is pretty much the same but requires Perl6::Export.
They let you work with lists in the way you want. e.g. to "take" half the alphabet:
perl -E 'use List::Gather; #lpha = ("a" .. "z");
#half = gather { for (#lpha){ take $_ if gathered < 13 } } ; say #half'
abcdefghijklm
or less if we aren't halfway there yet :
perl -E 'use List::Gather; #lpha = ("a" .. "c");
#half = gather { for (#lpha) { take $_ if gathered < 13 } } ; say #half'
abc
With List::Gather the gather block can take a loop (because of lexical scoping inside gather{} ??) and the topic $_ is required inside the block:
perl -E 'use List::Gather; #lpha = ("a" .. "g");
#half = gather for (#lpha) { take $_ if gathered < 13 }; say #half'
With Syntax::Keyword::Gather you do that inside the gather{} block (which is also possible with List::Gather):
perl -E 'use Syntax::Keyword::Gather; #lpha = ("a".."g");
#half = gather { for (#lpha){ take if gathered < 13 } }; say #half'
I find gather/take to be a nice alternative way to work with lists. Whether it is nice enough to ship with perl one day - say in List::Util - is an interesting implicit part of your question ;-) but they are on CPAN.
Postscript
To address some of the concerns about defined-ness raised by #simbabque, #zaid and #Joachim Breitner more checks can be added to the take() routine.
Here I use Ingy's boolean:
perl -E 'use boolean; use List::Gather;
#lpha = ("a" .. "g", "", undef, undef, "x", "0", "z");
#half = gather { for (#lpha){ take $_ if boolean($_) && gathered < 13 }};
use DDP; p #half;'
Output:
[
[0] "a",
[1] "b",
[2] "c",
[3] "d",
[4] "e",
[5] "f",
[6] "g",
[7] "x",
[8] "z"
]

Answer 7

I think you should use iterator pattern, i.e.
my $iterator = create_iterator(100);
while (my $element = $iterator->()) {
...;
}
There limit might be either embedded into iterator creation, i.e.
sub create_iterator {
my $limit = shift;
my #data = (0 x 1000);
my $i = 0;
return sub {
return $data[$i++] if ($i < #data);
}
}
PS. There is a limitation, that undef cannot be part of #data