Is self lesser than other?

Property definitions

core $ Comparable :: <
	# Is `self` lesser than `other`?
	fun <(other: OTHER): Bool is abstract
lib/core/kernel.nit:319,2--320,38

core $ ISODate :: <
	# TODO handle timezones
	redef fun <(o) do return to_s < o.to_s
lib/core/time.nit:277,2--278,39

trees $ TreeNode :: <
	# Nodes ordering is based on the `key`
	redef fun <(o) do return self.key < o.key
lib/trees/abstract_tree.nit:97,2--98,42

ai $ Tile :: <
	redef fun <(o) do return goal_idx < o.goal_idx
lib/ai/examples/puzzle.nit:225,2--47

date $ Time :: <
	redef fun <(d) do return self.diff_time(d) < 0
lib/date/date.nit:72,2--47

date $ Date :: <
	redef fun <(d) do return self.diff_days(d) < 0
lib/date/date.nit:136,2--47

nitc $ Message :: <
	# Comparisons are made on message locations.
	redef fun <(other: OTHER): Bool do
		if location == null then return true
		if other.location == null then return false

		return location.as(not null) < other.location.as(not null)
	end
src/toolcontext.nit:68,2--74,4

nitc $ MVisibility :: <
	# Is self give less visibility than other
	# none < private < protected < public < intrude
	redef fun <(other)
	do
		return self.level < other.level
	end
src/model/model_base.nit:141,2--146,4

github $ ContributorStats :: <
	# ContributorStats can be compared on the total amount of commits.
	redef fun <(o) do return total < o.total
lib/github/api.nit:1030,2--1031,41

nitc $ Location :: <
	redef fun <(other: OTHER): Bool do
		if self == other then return false
		if self.located_in(other) then return true
		if other.located_in(self) then return false

		if line_start != other.line_start then return line_start < other.line_start
		if column_start != other.column_start then return column_start < other.column_start
		if line_end != other.line_end then return line_end < other.line_end

		return column_end < other.column_end
	end
src/location.nit:253,2--263,4

core $ UInt32 :: <
	redef fun <(i) is intern
lib/core/fixed_ints.nit:603,2--25

core $ Int8 :: <
	redef fun <(i) is intern
lib/core/fixed_ints.nit:119,2--25

core $ Int16 :: <
	redef fun <(i) is intern
lib/core/fixed_ints.nit:240,2--25

core $ UInt16 :: <
	redef fun <(i) is intern
lib/core/fixed_ints.nit:361,2--25

core $ Int32 :: <
	redef fun <(i) is intern
lib/core/fixed_ints.nit:482,2--25

gmp $ Ratio :: <
    redef fun <(r) do return (self <=> r) < 0
lib/gmp/gmp.nit:316,5--45

core $ Char :: <
	redef fun <(i) is intern
lib/core/kernel.nit:915,2--25

core $ Byte :: <
	redef fun <(i) is intern
lib/core/kernel.nit:619,2--25

core $ Float :: <
	redef fun <(i) is intern
lib/core/kernel.nit:530,2--25

gmp $ BigInt :: <
    redef fun <(i) do return (self <=> i) < 0
lib/gmp/gmp.nit:148,5--45

core $ Int :: <
	redef fun <(i) is intern
lib/core/kernel.nit:720,2--25

core $ Text :: <
	# Lexicographical comparaison
	#
	# ~~~
	# assert "abc" < "xy"
	# assert "ABC" < "abc"
	# ~~~
	redef fun <(other)
	do
		var self_chars = self.chars.iterator
		var other_chars = other.chars.iterator

		while self_chars.is_ok and other_chars.is_ok do
			if self_chars.item < other_chars.item then return true
			if self_chars.item > other_chars.item then return false
			self_chars.next
			other_chars.next
		end

		if self_chars.is_ok then
			return false
		else
			return true
		end
	end
lib/core/text/abstract_text.nit:1054,2--1077,4

core $ ArrayCmp :: <
	redef fun <(o) do return (self <=> o) < 0
lib/core/collection/array.nit:921,2--42

core $ FlatString :: <
	redef fun <(other)
	do
		if not other isa FlatText then return super

		if self.object_id == other.object_id then return false

		var myits = _items
		var itsits = other._items

		var mbt = _byte_length
		var obt = other.byte_length

		var minln = if mbt < obt then mbt else obt
		var mst = _first_byte
		var ost = other.first_byte

		for i in [0 .. minln[ do
			var my_curr_char = myits[mst]
			var its_curr_char = itsits[ost]

			if my_curr_char > its_curr_char then return false
			if my_curr_char < its_curr_char then return true

			mst += 1
			ost += 1
		end

		return mbt < obt
	end
lib/core/text/flat.nit:570,2--598,4