Perl: if ( element in list )

I'm looking for presence of an element in a list.

In Python there is an in keyword and I would do something like:

if element in list:
    doTask

Is there something equivalent in Perl without having to manually iterate through the entire list?

Solution 1:

UPDATE:

The smartmatch family of features are now experimental

Smart match, added in v5.10.0 and significantly revised in v5.10.1, has been a regular point of complaint. Although there are a number of ways in which it is useful, it has also proven problematic and confusing for both users and implementors of Perl. There have been a number of proposals on how to best address the problem. It is clear that smartmatch is almost certainly either going to change or go away in the future. Relying on its current behavior is not recommended.

Warnings will now be issued when the parser sees ~~, given, or when.

If you can get away with requiring Perl v5.10, then you can use any of the following examples.

The smart match ~~ operator.

if( $element ~~ @list ){ ... }
if( $element ~~ [ 1, 2, 3 ] ){ ... }

You could also use the given/when construct. Which uses the smart match functionality internally.
```
given( $element ){
   when( @list ){ ... }
}
```
You can also use a for loop as a "topicalizer" ( meaning it sets $_ ).
```
for( @elements ){
   when( @list ){ ... }
}
```

One thing that will come out in Perl 5.12 is the ability to use the post-fix version of when. Which makes it even more like if and unless.

given( $element ){
  ... when @list;
}

If you have to be able to run on older versions of Perl, there still are several options.

You might think you can get away with using List::Util::first, but there are some edge conditions that make it problematic.

In this example it is fairly obvious that we want to successfully match against 0. Unfortunately this code will print failure every time.
```
use List::Util qw'first';
my $element = 0;
if( first { $element eq $_ } 0..9 ){
  print "success\n";
} else {
  print "failure\n";
}
```
You could check the return value of first for defined-ness, but that will fail if we actually want a match against undef to succeed.
You can safely use grep however.
```
if( grep { $element eq $_ } 0..9 ){ ... }
```
This is safe because grep gets called in a scalar context. Arrays return the number of elements when called in scalar context. So this will continue to work even if we try to match against undef.
You could use an enclosing for loop. Just make sure you call last, to exit out of the loop on a successful match. Otherwise you might end up running your code more than once.
```
for( @array ){
  if( $element eq $_ ){
    ...
    last;
  }
}
```

You could put the for loop inside the condition of the if statement ...

if(
  do{
    my $match = 0;
    for( @list ){
      if( $element eq $_ ){
        $match = 1;
        last;
      }
    }
    $match; # the return value of the do block
  }
){
  ...
}

... but it might be more clear to put the for loop before the if statement.

my $match = 0;
for( @list ){
  if( $_ eq $element ){
    $match = 1;
    last;
  }
}

if( $match ){ ... }

If you're only matching against strings, you could also use a hash. This can speed up your program if @list is large and, you are going to match against %hash several times. Especially if @array doesn't change, because then you only have to load up %hash once.
```
my %hash = map { $_, 1 } @array;
if( $hash{ $element } ){ ... }
```

You could also make your own subroutine. This is one of the cases where it is useful to use prototypes.

sub in(&@){
  local $_;
  my $code = shift;
  for( @_ ){ # sets $_
    if( $code->() ){
      return 1;
    }
  }
  return 0;
}

if( in { $element eq $_ } @list ){ ... }

Solution 2:

if( $element ~~ @list ){
   do_task
}

~~ is the "smart match operator", and does more than just list membership detection.