Idiom #12 Check if list contains a value

Check if list contains a value x.
list is an iterable finite container.

`list.contains(&x);`
`list.iter().any(|v| v == &x)`
`(&list).into_iter().any(|v| v == &x)`
`with Ada.Containers.Vectors;`
`Result := List.Contains (X);`
`#include <stdbool.h>`
```bool contains(int x, int* list, size_t list_len) {
for (int i=0 ; i<list_len ; i++)
if (list[i] == x)
return true;
return false;
}```
`List.mem x list`
`(some (partial = x) list)`
`(some #{x} list)`
```#include <vector>
#include <algorithm>```
```bool Contains(const std::vector<int> &list, int x)
{
return std::find(list.begin(), list.end(), x) != list.end();
}```
`System.Collections.Generic`
`list.Contains(item);`
`import std.algorithm.searching;`
`bool here = canFind(items, x);`
`list.contains(x);`
`Enum.member?(list, x)`
`x in list`
```member(_, []) -> false;
member(Value, [H|_]) where Value =:= H -> true;
member(Value, [_|T]) -> member(Value, T).```
`lists:member(X, List).`
```member(_, []) -> false;
member(Value, [H|T]) ->
case H of
Value -> true;
_ -> member(T)
end.```
`if (any(x == list)) ...`
`if (findloc (list, x, 1) != 0) then`
```func Contains(list []T, x T) bool {
for _, item := range list {
if item == x {
return true
}
}
return false
}```
`list.contains(x)`
`x `elem` list`
```find _ [] = False
find n (x:xs)
| x == n = True
| otherwise = find x xs```
`return list.includes(x);`
`return list.indexOf(x) !== -1;`
`import java.util.List;`
`list.contains(x)`
```boolean contains(int[] list, int x){
for(int y:list)
if( y==x )
return true;
return false;
}```
```boolean <T> contains(T[] list, T x){
if( x==null){
for(T y:list)
if( y==null )
return true;
}else{
for(T y:list)
if( x.equals(y) )
return true;
}
return false;
}```
`x in list`
`list.contains(x)`
`(member x list)`
```function contains(list, x)
for _, v in pairs(list) do
if v == x then return true end
end
return false
end```
`[list containsObject:x];`
`in_array(\$x, \$list, true);`
```result := false;
for e in list do
if e=x then
begin
result := true;
break;
end
```
`uses classes;`
`result := list.IndexOf(x) <> -1;`
`List::Util 'first'`
`print "ok\n" if first {\$_ eq 'needle'} @haystack;`
```# To check an array for a value:
print "Found 'foo'\n" if grep { \$_ eq 'foo' } @a_list;

# To check a map for a value:
print "Found 'bar'\n" if exists \$map{bar};```
`member(X, [One]).`
`x in list`
`list.include? x`
```list.contains(x)
```
```(define (contains list x)
(cond [(null? list) #f]
[(equal? (car list) x) #t]
[else (contains (cdr list) x)]))```
`List.Contains(x)`

Idiom created by

programming-idioms.org