# A hashcode based on the hashcode of the keys and the values.
	#
	# ~~~
	# var a = new HashMap[String, Int]
	# var b = new ArrayMap[Object, Numeric]
	# a["one"] = 1
	# b["one"] = 1
	# assert a.hash == b.hash
	# ~~~
	redef fun hash
	do
		var res = length
		for k, v in self do
			if k != null then res += k.hash * 7
			if v != null then res += v.hash * 11
		end
		return res
	end

	# Use the address value
	redef fun hash `{ return (long)(intptr_t)self; `}

	redef fun hash do return simplified.path.hash

	redef fun hash do return val

	redef fun hash do return e.hash * 13 + f.hash * 27

	redef fun hash do return data.hash

	# Because of the law between `==` and `hash`, `hash` is redefined to be the sum of the hash of the elements
	redef fun hash
	do
		# The 17 and 2/3 magic numbers were determined empirically.
		# Note: the standard hash functions djb2, sbdm and fnv1 were also
		# tested but were comparable (or worse).
		var res = 17 + length
		for e in self do
			res = res * 3 / 2
			if e != null then res += e.hash
		end
		return res
	end

	#     var a = new Range[Int](10, 15)
	#     assert a.hash == 455
	#     var b = new Range[Int].without_last(10, 15)
	#     assert b.hash == 432
	redef fun hash do
		# 11 and 23 are magic numbers empirically determined to be not so bad.
		return first.hash * 11 + last.hash * 23
	end

	redef fun hash do return _motif.hash

	redef fun hash `{ return self; `}

	redef fun hash do return items.hash_items(width*height)

	redef fun hash do return hour * 1024 + minute * 64 + second

	redef fun hash do return year + month * 1024 + day * 2048

	redef fun hash do
		return derive_to_map.hash
	end

	redef fun hash do return typ.hash + data.hash*8

	redef fun hash do return id.hash

	redef fun hash do return to_i

	redef fun hash do return self.to_i

	redef fun hash do return self.to_i

	redef fun hash do return self.to_i

	redef fun hash do return self.to_i

	redef fun hash do return self.to_i

	redef fun hash
	do
		mutex.lock
		var r = real_collection.hash
		mutex.unlock
		return r
	end

	redef fun hash
	do
		return roots.hash + sub.hash
	end

	redef fun hash
	do
		var res = 0
		for e, ee in elements do
			if e == null then continue
			res += e.hash
			res += ee.direct_greaters.length
		end
		return res
	end

    redef fun hash do return self.to_i

	redef fun hash do return code_point

	redef fun hash do return self.to_i

	# Because of the law between `==` and `hash`, `hash` is redefined to be the sum of the hash of the elements
	redef fun hash
	do
		# 23 is a magic number empirically determined to be not so bad.
		var res = 23 + length
		# Note: the order of the elements must not change the hash value.
		# So, unlike usual hash functions, the accumulator is not combined with itself.
		for e in self do
			if e != null then res += e.hash
		end
		return res
	end

    redef fun hash do return self.to_i

	redef fun hash do return self

	redef fun hash
	do
		if hash_cache == null then
			# djb2 hash algorithm
			var h = 5381

			for i in [0..length[ do
				var char = chars[i]
				h = (h << 5) + h + char.code_point
			end

			hash_cache = h
		end
		return hash_cache.as(not null)
	end

	redef fun hash
	do
		if hash_cache == null then
			# djb2 hash algorithm
			var h = 5381
			var i = _first_byte

			var my_items = _items
			var max = last_byte

			while i <= max do
				h = (h << 5) + h + my_items[i].to_i
				i += 1
			end

			hash_cache = h
		end

		return hash_cache.as(not null)
	end