Groovy list contains

list.contains[x]

with Ada.Containers.Vectors;

Result := List.Contains [X];

#include

bool contains[int x, int* list, size_t list_len] { for [int i=0 ; i false; member[Value, [H|_]] where Value =:= H -> true; member[Value, [_|T]] -> member[Value, T].

member[_, []] -> false; member[Value, [H|T]] -> case H of Value -> true; _ -> member[T] end.

lists:member[X, List].

if [findloc [list, x, 1] != 0] then

if [any[x == list]] ...

func Contains[list []T, x T] bool { for _, item := range list { if item == x { return true } } return false }

x `elem` list

find _ [] = False find n [x:xs] | x == n = True | otherwise = find n xs

return list.indexOf[x] !== -1;

return list.includes[x];

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 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; }

list.contains[x]

x in list

[member x list]

function contains[list, x] for _, v in pairs[list] do if v == x then return true end end return false end

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];

uses classes;

result := list.IndexOf[x] -1;

result := false; for e in list do if e=x then begin result := true; break; end

p := list; while [p nil] cand [p^.key = x] do p := p^.next; found := p.key = x

use List::Util 'first';

print "ok\n" if first {$_ eq $x} @list;

print "Found 'foo'\n" if grep {$_ eq $x} @list;

member[X, [One]].

x in list

list.include? x

list.contains[&x];

list.iter[].any[|v| v == &x]

[&list].into_iter[].any[|v| v == &x]

list.contains[x]

[define [contains list x] [cond [[null? list] #f] [[equal? [car list] x] #t] [else [contains [cdr list] x]]]]

[member x list]

list includes: x.

List.Contains[x]