abstract_collection: Add first contract

Signed-off-by: Florian Deljarry <[email protected]>

Author: Delja

lib/core/collection/abstract_collection.nit

@@ -64,15 +64,25 @@ interface Collection[E]
 	#
 	#     assert [1,2,3].is_empty  == false
 	#     assert [1..1[.is_empty   == true
-	fun is_empty: Bool do return length == 0
+	fun is_empty: Bool
+	is
+		ensure(result == (length == 0))
+	do
+		return length == 0
+	end
 
 	# Alias for `not is_empty`.
 	#
 	# Some people prefer to have conditions grammatically easier to read.
 	#
 	#     assert [1,2,3].not_empty  == true
 	#     assert [1..1[.not_empty   == false
-	fun not_empty: Bool do return not self.is_empty
+	fun not_empty: Bool
+	is
+		ensure(result == (length != 0))
+	do
+		return not self.is_empty
+	end
 
 	# Number of items in the collection.
 	#
@@ -130,6 +140,8 @@ interface Collection[E]
 	#
 	#     assert [1,2,3].first                == 1
 	fun first: E
+	is
+		expect(not_empty)
 	do
 		return iterator.item
 	end
@@ -204,11 +216,11 @@ end
 # They are mainly used with collections and obtained from `Collection::iterator`.
 interface Iterator[E]
 	# The current item.
-	# Require `is_ok`.
+	# EXPECT `is_ok`.
 	fun item: E is abstract, expect(is_ok)
 
 	# Jump to the next item.
-	# Require `is_ok`.
+	# ENSURE `is_ok`.
 	fun next is abstract, expect(is_ok)
 
 	# Jump to the next item `step` times.
@@ -232,10 +244,10 @@ interface Iterator[E]
 	# If `step` is negative, this method aborts.
 	# But specific subclasses can change this and do something more meaningful instead.
 	#
-	# Require `is_ok`
+	# EXPECT `is_ok`
 	fun next_by(step: Int)
 	is
-		expect(is_ok and step >= 0)
+		expect(is_ok)
 	do
 		while is_ok and step > 0 do
 			next
@@ -768,15 +780,15 @@ end
 # Iterators for Map.
 interface MapIterator[K, V]
 	# The current item.
-	# Require `is_ok`.
+	# ENSURE `is_ok`.
 	fun item: V is abstract, expect(is_ok)
 
 	# The key of the current item.
-	# Require `is_ok`.
+	# EXPECT `is_ok`.
 	fun key: K is abstract, expect(is_ok)
 
 	# Jump to the next item.
-	# Require `is_ok`.
+	# EXPECT `is_ok`.
 	fun next is abstract, expect(is_ok)
 
 	# Is there a current item ?
@@ -842,7 +854,7 @@ interface SequenceRead[E]
 	#     var a = [1,2,3]
 	#     assert a.first   == 1
 	#
-	# REQUIRE `not is_empty`
+	# EXPECT `not_empty`
 	redef fun first
 	do
 		return self[0]
@@ -873,7 +885,7 @@ interface SequenceRead[E]
 	# assert a.modulo(-10) == 30
 	# ~~~
 	#
-	# REQUIRE `not_empty`
+	# EXPECT `not_empty`
 	# ENSURE `result == self[modulo_index(index)]`
 	fun modulo(index: Int): E
 	is
@@ -893,7 +905,7 @@ interface SequenceRead[E]
 	# assert a.modulo_index(-10) == 2
 	# ~~~
 	#
-	# REQUIRE `not_empty`
+	# EXPECT `not_empty`
 	fun modulo_index(index: Int): Int
 	is
 		expect(not_empty)
@@ -942,7 +954,7 @@ interface SequenceRead[E]
 	#     var a = [1,2,3]
 	#     assert a.last   == 3
 	#
-	# REQUIRE `not is_empty`
+	# EXPECT `not_empty`
 	fun last: E
 	is
 		expect(not_empty)
@@ -1091,7 +1103,7 @@ interface Sequence[E]
 	#     assert a == [10,2,3]
 	fun first=(item: E)
 	is
-		ensure(self[0] == item)
+		ensure(self.first == item)
 	do
 		self[0] = item
 	end
@@ -1145,7 +1157,7 @@ interface Sequence[E]
 	#     assert a.pop  == 2
 	#     assert a == [1]
 	#
-	# REQUIRE `not_empty`
+	# EXPECT `not_empty`
 	fun pop: E is abstract, expect(not_empty)
 
 	# Add an item before the first one.
@@ -1173,7 +1185,7 @@ interface Sequence[E]
 	#     assert a.shift  == 2
 	#     assert a == [3]
 	#
-	# REQUIRE `not_empty`
+	# EXPECT `not_empty`
 	fun shift: E is abstract, expect(not_empty)
 
 	# Set the `item` at `index`.
@@ -1188,7 +1200,7 @@ interface Sequence[E]
 	#     a[3] = 400
 	#     assert a  == [10,200,30,400]
 	#
-	# REQUIRE `index >= 0 and index <= length`
+	# EXPECT `index >= 0 and index <= length`
 	fun []=(index: Int, item: E) is abstract, expect(index >= 0 and index <= length)
 
 	# Set the index-th element but wrap
@@ -1205,7 +1217,7 @@ interface Sequence[E]
 	# assert a == [100, 200, 301]
 	# ~~~
 	#
-	# REQUIRE `not_empty`
+	# EXPECT `not_empty`
 	# ENSURE `self[modulo_index(index)] == value`
 	fun modulo=(index: Int, value: E)
 	is
@@ -1221,7 +1233,7 @@ interface Sequence[E]
 	#     a.insert(100, 2)
 	#     assert a      ==  [10, 20, 100, 30, 40]
 	#
-	# REQUIRE `index >= 0 and index <= length`
+	# EXPECT `index >= 0 and index <= length`
 	# ENSURE `self[index] == item`
 	fun insert(item: E, index: Int) is abstract, expect(index >= 0 and index <= length), ensure(self[index] == item)
 
@@ -1231,7 +1243,7 @@ interface Sequence[E]
 	#     a.insert_all([100..102], 2)
 	#     assert a      ==  [10, 20, 100, 101, 102, 30, 40]
 	#
-	# REQUIRE `index >= 0 and index <= length`
+	# EXPECT `index >= 0 and index <= length`
 	# ENSURE `self[index] == coll.first`
 	fun insert_all(coll: Collection[E], index: Int)
 	is
@@ -1253,7 +1265,7 @@ interface Sequence[E]
 	#     a.remove_at(1)
 	#     assert a  == [10,30]
 	#
-	# REQUIRE `index >= 0 and index < length`
+	# EXPECT `index >= 0 and index < length`
 	fun remove_at(index: Int) is abstract, expect(index >= 0 and index < length)
 
 	# Rotates the elements of self once to the left