Be concise.

Be useful.

All contributions dictatorially edited by webmasters to match personal tastes.

Please do not paste any copyright violating resource.

Please try to avoid dependencies to third-party libraries and frameworks.

Implementation edit is for fixing errors and enhancing with metadata.

Instead of changing the code of the snippet, consider creating another Pascal implementation.

Other implementations
func Contains(list []T, x T) bool {
	for _, item := range list {
		if item == x {
			return true
	return false
#include <vector>
#include <algorithm>
bool Contains(const std::vector<int> &list, int x)
	return std::find(list.begin(), list.end(), x) != list.end();
(define (contains list x)
        (if (null? list) #f)
        (if (equal? (car list) x) #t)
        (else (contains (cdr list) x))))
x in list
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;
    for(T y:list)
      if( x.equals(y) )
        return true;
  return false;
import java.util.List;
# 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};
return list.indexOf(x) !== -1;
in_array($x, $list, true);
import std.algorithm.searching;
bool here = canFind(items, x);
uses classes;
result := list.IndexOf(x) <> -1;
x `elem` list
(some (partial = x) list)
Enum.member?(list, x)
lists:member(X, List).
#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;
function contains(list, x)
	for _, v in pairs(list) do
		if v == x then return true end
	return false
with Ada.Containers.Vectors;
Result := List.Contains (X);
return list.includes(x);
list.iter().any(|v| v == &x)
(&list).into_iter().any(|v| v == &x)
member(_, []) -> false;
member(Value, [H|T]) -> 
  case H of
    Value -> true;
    _ -> member(T)
member(_, []) -> false;
member(Value, [H|_]) where Value =:= H -> true;
member(Value, [_|T]) -> member(Value, T).
[list containsObject:x];
list.include? x
List::Util 'first'
print "ok\n" if first {$_ eq 'needle'} @haystack;
(member x list)
(some #{x} list)
List.mem x list
x in list
if (findloc (list, x, 1) != 0) then
member(X, [One]).
if (any(x == list)) ...
find _ [] = False
find x (x:xs) = True
find x (_:xs) = find x xs
x in list