remove closures from code

[nit.git] / lib / standard / collection / hash_collection.nit

diff --git a/lib/standard/collection/hash_collection.nit b/lib/standard/collection/hash_collection.nit
index 07bc985..9a53f99 100644 (file)
--- a/lib/standard/collection/hash_collection.nit
+++ b/lib/standard/collection/hash_collection.nit
@@ -11,14 +11,14 @@
 # another product.
 
 # Introduce Hashmap and Hashset.
-package hash_collection
+module hash_collection
 
 import array
-import hash
 
 # A HashCollection is an array of HashNode[K] indexed by the K hash value
-private class HashCollection[K: Object, N: HashNode[K]]
+private abstract class HashCollection[K: Object, N: HashNode[Object]]
        super ArrayCapable[nullable N]
+
        var _array: nullable NativeArray[nullable N] = null # Used to store items
        var _capacity: Int = 0 # Size of _array
        var _length: Int = 0 # Number of items in the map
@@ -43,7 +43,7 @@ private class HashCollection[K: Object, N: HashNode[K]]
        # Return the node assosiated with the key
        fun node_at(k: K): nullable N
        do
-               # cache: `is' is used instead of `==' because it is a faster filter (even if not exact)
+               # cache: `is` is used instead of `==` because it is a faster filter (even if not exact)
                if k is _last_accessed_key then return _last_accessed_node
 
                var res = node_at_idx(index_at(k), k)
@@ -58,7 +58,7 @@ private class HashCollection[K: Object, N: HashNode[K]]
                var c = _array[i]
                while c != null do
                        var ck = c._key
-                       if ck is k or ck == k then # prefilter with `is' because the compiler is not smart enought yet
+                       if ck is k or ck == k then # prefilter with `is` because the compiler is not smart enought yet
                                break
                        end
                        c = c._next_in_bucklet
@@ -134,6 +134,7 @@ private class HashCollection[K: Object, N: HashNode[K]]
                _last_accessed_key = null
        end
 
+       # Clear the whole structure
        fun raz
        do
                var i = _capacity - 1
@@ -147,6 +148,7 @@ private class HashCollection[K: Object, N: HashNode[K]]
                _last_accessed_key = null
        end
 
+       # Force a capacity
        fun enlarge(cap: Int)
        do
                var old_cap = _capacity
@@ -183,7 +185,7 @@ private class HashCollection[K: Object, N: HashNode[K]]
        end
 end
 
-private class HashNode[K: Object]
+private abstract class HashNode[K: Object]
        var _key: K
        type N: HashNode[K]
        readable writable var _next_item: nullable N = null
@@ -196,6 +198,8 @@ private class HashNode[K: Object]
        end
 end
 
+# A map implemented with a hash table.
+# Keys of such a map cannot be null and require a working `hash` method
 class HashMap[K: Object, V]
        super Map[K, V]
        super HashCollection[K, HashMapNode[K, V]]
@@ -212,16 +216,6 @@ class HashMap[K: Object, V]
 
        redef fun iterator: HashMapIterator[K, V] do return new HashMapIterator[K,V](self)
 
-       redef fun iterate
-               !each(k: K, v: V)
-       do
-               var c = _first_item
-               while c != null do
-                       each(c._key, c._value)
-                       c = c._next_item
-               end
-       end
-
        redef fun length do return _length
 
        redef fun is_empty do return _length == 0
@@ -251,6 +245,7 @@ class HashMap[K: Object, V]
        redef var values: HashMapValues[K, V] = new HashMapValues[K, V](self)
 end
 
+# View of the keys of a HashMap
 class HashMapKeys[K: Object, V]
        super RemovableCollection[K]
        # The original map
@@ -271,6 +266,7 @@ class HashMapKeys[K: Object, V]
        redef fun remove_all(key) do self.map.remove_node(key)
 end
 
+# View of the values of a Map
 class HashMapValues[K: Object, V]
        super RemovableCollection[V]
        # The original map
@@ -341,7 +337,7 @@ class HashMapValues[K: Object, V]
        end
 end
 
-class HashMapNode[K: Object, V]
+private class HashMapNode[K: Object, V]
        super HashNode[K]
        redef type N: HashMapNode[K, V]
        var _value: V
@@ -394,6 +390,8 @@ class HashMapIterator[K: Object, V]
        end
 end
 
+# A `Set` implemented with a hash table.
+# Keys of such a map cannot be null and require a working `hash` method
 class HashSet[E: Object]
        super Set[E]
        super HashCollection[E, HashSetNode[E]]
@@ -436,9 +434,15 @@ class HashSet[E: Object]
                _length = 0
                enlarge(0)
        end
+
+       # Build a list filled with the items of `coll`.
+       init from(coll: Collection[E]) do
+               init
+               add_all(coll)
+       end
 end
 
-class HashSetNode[E: Object]
+private class HashSetNode[E: Object]
        super HashNode[E]
        redef type N: HashSetNode[E]