fix #10 set

+collection functions (map, forEach, toList, toSet, isEmpty, etc,)

docs/Collection.md

@@ -0,0 +1,13 @@
+# Collection
+
+Is a [Iterable] with known `size`, a finite [Iterable]:
+
+    class Collection : Iterable {
+        val size
+    }
+
+See [List], [Set] and [Iterable]
+
+[Iterable]: Iterable.md
+[List]: List.md
+[Set]: Set.md

docs/Iterable.md

@@ -1,13 +1,17 @@
 # Iterable interface
 
-The inteface which requires iterator to be implemented:
+Iterable is a class that provides function that creates _the iterator_:
 
-    fun iterator(): Iterator
+    class Iterable {
+        abstract fun iterator()
+    }
+
+Note that each call of `iterator()` must provide an independent iterator.
 
 Iterator itself is a simple interface that should provide only to method:
 
-    interface Iterable {
-        fun hasNext(): Bool
+    class Iterator {
+        abstract fun hasNext(): Bool
         fun next(): Obj
     }
 
@@ -15,19 +19,26 @@ Just remember at this stage typed declarations are not yet supported.
 
 Having `Iterable` in base classes allows to use it in for loop. Also, each `Iterable` has some utility functions available:
 
+## Instance methods
+
+    fun Iterable.toList(): List
+    fun Iterable.toSet(): Set
+    fun Iterable.indexOf(element): Int
+    fun Iterable.contains(element): Bool
+    fun Iterable.isEmpty(element): Bool
+    fun Iterable.forEach(block: (Any?)->Void ): Void
+    fun Iterable.map(block: (Any?)->Void ): List
+    
+
 ## Abstract methods
 
     fun iterator(): Iterator
 
-## Instance methods
-
-### toList()
-
 Creates a list by iterating to the end. So, the Iterator should be finite to be used with it.
 
 ## Included in interfaces:
 
-- Collection, Array, [List]
+- [Collection], Array, [List]
 
 ## Implemented in classes:
 

docs/List.md

@@ -116,6 +116,8 @@ Open end ranges remove head and tail elements:
 : `+=` append either a single element, or all elements if the List or other Iterable
 instance is appended. If you want to append an Iterable object itself, use `add` instead.
 
+It inherits from [Iterable] too.
+
 ## Member inherited from Array
 
 | name             | meaning                        | type  |
@@ -130,8 +132,6 @@ instance is appended. If you want to append an Iterable object itself, use `add`
 : end-inclisiveness allows to use negative indexes to, for exampe, remove several last elements, like
 `list.removeRangeInclusive(-2, -1)` will remove two last elements.
 
-# Notes
 
-Could be rewritten using array as a class but List as the interface
-
-[Range]: Range.md
+[Range]: Range.md
+[Iterable]: Iterable.md

docs/Set.md

@@ -0,0 +1,94 @@
+# List built-in class
+
+Mutable set of any objects: a group of different objects, no repetitions.
+Sets are not ordered, order of appearance does not matter.
+
+    val set = Set(1,2,3, "foo")
+    assert( 1 in set )
+    assert( "foo" in set)
+    assert( "bar" !in set)
+    >>> void
+
+## Set is collection and therefore [Iterable]:
+
+    assert( Set(1,2) is Set)
+    assert( Set(1,2) is Iterable)
+    assert( Set(1,2) is Collection)
+    >>> void
+
+So it supports all methods from [Iterable]; set is not, though, an [Array] and has
+no indexing. Use [set.toList] as needed.
+
+## Set operations
+
+    // Union
+    assertEquals( Set(1,2,3,4), Set(3, 1) + Set(2, 4))
+
+    // intersection
+    assertEquals( Set(1,4), Set(3, 1, 4).intersect(Set(2, 4, 1)) )
+    // or simple
+    assertEquals( Set(1,4), Set(3, 1, 4) * Set(2, 4, 1) )
+
+    // To find collection elements not present in another collection, use the 
+    // subtract() or `-`:
+    assertEquals( Set( 1, 2), Set(1, 2, 4, 3) - Set(3, 4))
+
+    >>> void
+
+## Adding elements
+
+    var s = Set()
+    s += 1
+    assertEquals( Set(1), s)
+    
+    s += [3, 3, 4]
+    assertEquals( Set(3, 4, 1), s)
+    >>> void
+
+## Removing elements
+
+List is mutable, so it is possible to remove its contents. To remove a single element
+by index use:
+
+    var s = Set(1,2,3)
+    s.remove(2)
+    assertEquals( s, Set(1,3) )
+
+    s = Set(1,2,3)
+    s.remove(2,1)
+    assertEquals( s, Set(3) )
+    >>> void
+
+Note that `remove` returns true if at least one element was actually removed and false
+if the set has not been changed.
+
+## Comparisons and inclusion
+
+Sets are only equal when contains exactly same elements, order, as was said, is not significant:
+
+    assert( Set(1, 2) == Set(2, 1) )
+    assert( Set(1, 2, 2) == Set(2, 1) )
+    assert( Set(1, 3) != Set(2, 1) )
+    assert( 1 in Set(5,1))
+    assert( 10 !in Set(5,1))
+    >>> void
+
+## Members
+
+| name                | meaning                              | type  |
+|---------------------|--------------------------------------|-------|
+| `size`              | current size                         | Int   |
+| `+=`                | add one or more elements             | Any   |
+| `+`, `union`         | union sets                           | Any   |
+| `-`, `subtract`     | subtract sets                        | Any   |
+| `*`, `intersect`    | subtract sets                        | Any   |
+| `remove(items...)`  | remove one or more items             | Range |
+| `contains(element)` | check the element is in the list (1) |       |
+
+(1)
+: optimized implementation that override `Iterable` one
+
+Also, it inherits methods from [Iterable].
+
+
+[Range]: Range.md