X-Git-Url: http://nitlanguage.org

diff --git a/lib/standard/list.nit b/lib/standard/list.nit
index 6a0fd19..13a8e29 100644
--- a/lib/standard/list.nit
+++ b/lib/standard/list.nit
@@ -19,29 +19,29 @@ import abstract_collection
 class List[E]
 special IndexedCollection[E]
 # Access
-	redef meth [](index) do return get_node(index).item
+	redef fun [](index) do return get_node(index).item
 
-	redef meth []=(index, item) do get_node(index).item = item
+	redef fun []=(index, item) do get_node(index).item = item
 
 	# O(1)
-	redef meth first do return _head.item
+	redef fun first do return _head.item
 
 	# O(1)
-	redef meth first=(e) do _head.item = e
+	redef fun first=(e) do _head.item = e
 
 	# O(1)
-	redef meth last do return _tail.item
+	redef fun last do return _tail.item
 
 	# O(1)
-	redef meth last=(e) do _tail.item = e
+	redef fun last=(e) do _tail.item = e
 
 # Queries
 
 	# O(1)
-	redef meth is_empty do return _head == null
+	redef fun is_empty do return _head == null
 
 	# O(n)
-	redef meth length
+	redef fun length
 	do
 		var l = 0
 		var t = _head
@@ -53,9 +53,9 @@ special IndexedCollection[E]
 	end
 
 	# O(n)
-	redef meth has(e) do return search_node_after(e, _head) != null
+	redef fun has(e) do return search_node_after(e, _head) != null
 
-	redef meth has_only(e)
+	redef fun has_only(e)
 	do
 		var node = _head
 		while node != null do
@@ -65,7 +65,7 @@ special IndexedCollection[E]
 		return true
 	end
 
-	redef meth count(e)
+	redef fun count(e)
 	do
 		var nb = 0
 		var node = _head
@@ -76,12 +76,12 @@ special IndexedCollection[E]
 		return nb
 	end
 
-	redef meth has_key(index) do return get_node(index) != null
+	redef fun has_key(index) do return get_node(index) != null
 
 # Add elements
 
 	# O(1)
-	redef meth push(e)
+	redef fun push(e)
 	do
 		var node = new ListNode[E](e)
 		if _tail == null then
@@ -94,7 +94,7 @@ special IndexedCollection[E]
 	end
 
 	# O(1)
-	redef meth unshift(e)
+	redef fun unshift(e)
 	do
 		var node = new ListNode[E](e)
 		if _head == null then
@@ -109,7 +109,7 @@ special IndexedCollection[E]
 	# Append `l' to `self' but clear `l'.
 	##
 	# O(1)
-	meth link(l: List[E])
+	fun link(l: List[E])
 	do
 		if _tail == null then
 			_head = l._head
@@ -124,7 +124,7 @@ special IndexedCollection[E]
 # Remove elements
 
 	# O(1)
-	redef meth pop
+	redef fun pop
 	do
 		var node = _tail
 		_tail = node.prev
@@ -138,7 +138,7 @@ special IndexedCollection[E]
 	end
 
 	# O(1)
-	redef meth shift
+	redef fun shift
 	do
 		var node = _head
 		_head = node.next
@@ -151,26 +151,26 @@ special IndexedCollection[E]
 		return node.item
 	end
 
-	redef meth remove(e)
+	redef fun remove(e)
 	do
 		var node = search_node_after(e, _head)
 		if node != null then remove_node(node)
 	end
 
-	redef meth remove_at(i)
+	redef fun remove_at(i)
 	do
 		var node = get_node(i)
 		if node != null then remove_node(node)
 	end
 
-	redef meth clear
+	redef fun clear
 	do
 		_head = null
 		_tail = null
 	end
 
 
-	redef meth iterator: ListIterator[E] do return new ListIterator[E](_head)
+	redef fun iterator: ListIterator[E] do return new ListIterator[E](_head)
 
 	# Build an empty list.
 	init do end
@@ -179,13 +179,13 @@ special IndexedCollection[E]
 	init from(coll: Collection[E]) do append(coll)
 
 	# The first node of the list
-	attr _head: nullable ListNode[E]
+	var _head: nullable ListNode[E]
 
 	# The last node of the list
-	attr _tail: nullable ListNode[E]
+	var _tail: nullable ListNode[E]
 
 	# Get the `i'th node. get `null' otherwise.
-	private meth get_node(i: Int): nullable ListNode[E]
+	private fun get_node(i: Int): nullable ListNode[E]
 	do
 		var n = _head
 		if i < 0 then
@@ -199,7 +199,7 @@ special IndexedCollection[E]
 	end
 
 	# get the first node that contains e after 'after', null otherwise
-	private meth search_node_after(e: E, after: nullable ListNode[E]): nullable ListNode[E]
+	private fun search_node_after(e: E, after: nullable ListNode[E]): nullable ListNode[E]
 	do
 		var n = after
 		while n != null and n.item != e do n = n.next
@@ -207,7 +207,7 @@ special IndexedCollection[E]
 	end
 
 	# Remove the node (ie. atach prev and next)
-	private meth remove_node(node: ListNode[E])
+	private fun remove_node(node: ListNode[E])
 	do
 		if node.prev == null then
 			_head = node.next
@@ -225,7 +225,7 @@ special IndexedCollection[E]
 		end
 	end
 
-	private meth insert_before(element: E, node: ListNode[E])
+	private fun insert_before(element: E, node: ListNode[E])
 	do
 		var nnode = new ListNode[E](element)
 		var prev = node.prev
@@ -243,13 +243,13 @@ end
 # This is the iterator class of List
 class ListIterator[E]
 special IndexedIterator[E]
-	redef meth item do return _node.item
+	redef fun item do return _node.item
 
-	# redef meth item=(e) do _node.item = e
+	# redef fun item=(e) do _node.item = e
 
-	redef meth is_ok do return not _node == null
+	redef fun is_ok do return not _node == null
 
-	redef meth next
+	redef fun next
 	do
 		_node = _node.next
 		_index += 1
@@ -263,10 +263,10 @@ special IndexedIterator[E]
 	end
 
 	# The current node of the list
-	attr _node: nullable ListNode[E]
+	var _node: nullable ListNode[E]
 
 	# The index of the current node
-	redef readable attr _index: Int
+	redef readable var _index: Int
 end
 
 # Linked nodes that constitute a linked list.
@@ -278,8 +278,8 @@ special Container[E]
 	end
 
 	# The next node.
-	readable writable attr _next: nullable ListNode[E]
+	readable writable var _next: nullable ListNode[E]
 
 	# The previous node.
-	readable writable attr _prev: nullable ListNode[E]
+	readable writable var _prev: nullable ListNode[E]
 end