#     assert [1..10].has(5)
	#     assert [1..10].has(10)
	#     assert not [1..10[.has(10)
	redef fun has(item) do return item isa Comparable and item >= first and item <= last

	redef fun has(e)
	do
		mutex.lock
		var r = real_collection.has(e)
		mutex.unlock
		return r
	end

	redef fun has(an_item) do return item == an_item

	redef fun has(item)
	do
		var i = 0
		var l = length
		while i < l do
			if self[i] == item then return true
			i += 1
		end
		return false
	end

	redef fun has(k) do return self.map.index(k) >= 0

	# O(n)
	redef fun has(item)
	do
		for i in self.map._items do if i.second == item then return true
		return false
	end

	redef fun has(k) do return self.map.node_at(k) != null

	redef fun has(item)
	do
		var c = self.map._first_item
		while c != null do
			if c._value == item then return true
			c = c._next_item
		end
		return false
	end

	redef fun has(e) do return parents.has_key(e)

	redef fun has(e) do return self.elements.keys.has(e)

	# Is the element in the structure
	#
	#     var s = new DisjointSet[Int]
	#     assert not s.has(1)
	#     s.add(1)
	#     assert s.has(1)
	#     assert not s.has(2)
	redef fun has(e) do
		return nodes.has_key(e)
	end

	redef fun has(e) do return _array.has(e)

	# O(n)
	redef fun has(e) do return search_node_after(e, _head) != null

	redef fun has(e) do return entities.has(e)

	redef fun has(value)
	do
		if not value isa Int then return false
		assert value < _capacity
		var pos = _keys[value]
		if pos < _length then
			return _values[pos] == value
		end
		return false
	end

	redef fun has(item)
	do
		return node_at(item) != null
	end

	redef fun has(c)
	do
		if not c isa Int then return false
		return super(c&255)
	end

	redef fun has(e)
	do
		mutex.lock
		var result = real_collection.has(e)
		mutex.unlock
		return result
	end