The first thing that comes to mind, in general:

use List::Util 'first';
my $first_index = first { test( $arr[ $_ ] ) } 0..$#arr;
[download]

my $first_index = first { $arr[ $_ ] =~ /$pat/ } 0..$#arr;
[download]

BTW, you can achieve the same effect with grep, although less efficiently, because every element of the array will be tested:

my $first_index = ( grep test( $arr [$_ ] ), 0..$#arr )[ 0 ];
[download]

This isn't really an answer to your question specifically, but it's a possible workaround.

my @array = qw/some stuff in here/;



   #instead of:

my @matches = grep { /^s/ } @array;

   #which would give you ("some","stuff");



   #you could try something like this:

my @indices = grep { $array[ $_ ] =~ /^s/ } 0..$#array;

   #which would give you (0,1), which are the indices of the array you
+ want.
   #and then to get matches, you can still do something like:

my @matches = @array[ @indices ];
[download]

    -Bryan

Basically no!

But depending upon what your actually trying to do(?), you may be better off using a hash rather than an array.

The additional bonus of List::Util::first() is that it is compiled, so you will get performance akin to grep.

I wrote a myfirst using for that shortcircuits like List::Util:

          Rate   myfirst   first
myfirst  875/s       --     -83%
first   5236/s      498%     --
[download]

More interesting, possibly, is a comparison of grep and first solutions - does the slight overhead of calling first (a compiled, but still user, function) out-weight the benefit?

Read more... (706 Bytes)

my @list = qw(just remember in perl there's more than one way to do it
+, not that you should do it any way.);

my $i = 0;
my %hash = map { $_ => ++$i } @list;

my @search = ('to','just', 'should', 'one');
my @indices = grep { $hash{$_} } @search;

print 'matches ' . join (", ", map { $_ => ord()-97 } map { (a...z)[$h
+ash{$_}-1] } @indices);
[download]

I never liked searches, I remember doing an address book application in the mid 80's and routines for finding names in a big list were a pain. But I found if you are looking for efficiency sort your array first if possible. Now this really only applies if your data is in a format that this can work with. For my names db then, I would sort my list by surname on entry so the list was always in alphabetical order. Than when give a name you I would go the half way point and if the $string ascii values were less than the half way point go back half way. And so on homing in on the name. I found this achieved quick results. But it relies on the dataset being easily sortable.

This was in pascal and assembler and I have never really had to do anything since on the same scale because most datasets I work on now are coming from a Database Server which uses SQL to process the searches on that level. But I would think if the data is large enough and your searches happen often enough, you could build an index to use that you could than pull the values you need out of. Avoiding the overhead on the searches but adding the overhead on the data entry.

sub grepix (&@) {
  my $test = shift;
  grep {
    local $_ = $_[$_];
    &$test();
  } (0..$#_)
}

my @index = grepix { /foo/ } qw(foofoo bar fo);
[download]