fix #10 set

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

lynglib/src/commonMain/kotlin/net/sergeych/lyng/Compiler.kt

@@ -159,9 +159,8 @@ class Compiler(
                                     cc.next()
                                     isCall = true
                                     val lambda =
-                                        parseExpression(cc) ?: throw ScriptError(t.pos, "expected valid lambda here")
+                                        parseLambdaExpression(cc)
                                     println(cc.current())
-                                    cc.skipTokenOfType(Token.Type.RBRACE)
                                     operand = Accessor { context ->
                                         context.pos = next.pos
                                         val v = left.getter(context).value
@@ -172,7 +171,7 @@ class Compiler(
                                                 v.invokeInstanceMethod(
                                                     context,
                                                     next.value,
-                                                    Arguments(listOf(lambda), true)
+                                                    Arguments(listOf(lambda.getter(context).value), true)
                                                 ), isMutable = false
                                             )
                                     }

lynglib/src/commonMain/kotlin/net/sergeych/lyng/Obj.kt

@@ -265,6 +265,7 @@ open class Obj {
                 is Boolean -> ObjBool(obj)
                 Unit -> ObjVoid
                 null -> ObjNull
+                is Iterator<*> -> ObjKotlinIterator(obj)
                 else -> throw IllegalArgumentException("cannot convert to Obj: $obj")
             }
         }

lynglib/src/commonMain/kotlin/net/sergeych/lyng/ObjArray.kt

@@ -0,0 +1,38 @@
+package net.sergeych.lyng
+
+val ObjArray by lazy {
+
+    /**
+     * Array abstract class is a [ObjCollection] with `getAt` method.
+     */
+    ObjClass("Array", ObjCollection).apply {
+        // we can create iterators using size/getat:
+
+        addFn("iterator") {
+            ObjArrayIterator(thisObj).also { it.init(this) }
+        }
+
+        addFn("contains", isOpen = true) {
+            val obj = args.firstAndOnly()
+            for (i in 0..<thisObj.invokeInstanceMethod(this, "size").toInt()) {
+                if (thisObj.getAt(this, ObjInt(i.toLong())).compareTo(this, obj) == 0) return@addFn ObjTrue
+            }
+            ObjFalse
+        }
+
+        addFn("last") {
+            thisObj.invokeInstanceMethod(
+                this,
+                "getAt",
+                (thisObj.invokeInstanceMethod(this, "size").toInt() - 1).toObj()
+            )
+        }
+
+        addFn("lastIndex") { (thisObj.invokeInstanceMethod(this, "size").toInt() - 1).toObj() }
+
+        addFn("indices") {
+            ObjRange(0.toObj(), thisObj.invokeInstanceMethod(this, "size"), false)
+        }
+
+    }
+}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/ObjArrayIterator.kt

@@ -0,0 +1,32 @@
+package net.sergeych.lyng
+
+class ObjArrayIterator(val array: Obj) : Obj() {
+
+    override val objClass: ObjClass by lazy { type }
+
+    private var nextIndex = 0
+    private var lastIndex = 0
+
+    suspend fun init(context: Context) {
+        nextIndex = 0
+        lastIndex = array.invokeInstanceMethod(context, "size").toInt()
+        ObjVoid
+    }
+
+    companion object {
+        val type by lazy {
+            ObjClass("ArrayIterator", ObjIterator).apply {
+                addFn("next") {
+                    val self = thisAs<ObjArrayIterator>()
+                    if (self.nextIndex < self.lastIndex) {
+                        self.array.invokeInstanceMethod(this, "getAt", (self.nextIndex++).toObj())
+                    } else raiseError(ObjIterationFinishedException(this))
+                }
+                addFn("hasNext") {
+                    val self = thisAs<ObjArrayIterator>()
+                    if (self.nextIndex < self.lastIndex) ObjTrue else ObjFalse
+                }
+            }
+        }
+    }
+}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/ObjClass.kt

@@ -69,118 +69,4 @@ open class ObjClass(
             ?: throw ScriptError(atPos, "symbol doesn't exist: $name")
 }
 
-/**
- * Abstract class that must provide `iterator` method that returns [ObjIterator] instance.
- */
-val ObjIterable by lazy {
-    ObjClass("Iterable").apply {
-
-        addFn("toList") {
-            val result = mutableListOf<Obj>()
-            val iterator = thisObj.invokeInstanceMethod(this, "iterator")
-
-            while (iterator.invokeInstanceMethod(this, "hasNext").toBool())
-                result += iterator.invokeInstanceMethod(this, "next")
-
-
-//        val next = iterator.getMemberOrNull("next")!!
-//        val hasNext = iterator.getMemberOrNull("hasNext")!!
-//        while( hasNext.invoke(this, iterator).toBool() )
-//            result += next.invoke(this, iterator)
-            ObjList(result)
-        }
-
-    }
-}
-
-/**
- * Collection is an iterator with `size`]
- */
-val ObjCollection by lazy {
-    val i: ObjClass = ObjIterable
-    ObjClass("Collection", i).apply {
-        // it is not effective, but it is open:
-        addFn("contains", isOpen = true) {
-            val obj = args.firstAndOnly()
-            val it = thisObj.invokeInstanceMethod(this, "iterator")
-            while (it.invokeInstanceMethod(this, "hasNext").toBool()) {
-                if( obj.compareTo(this, it.invokeInstanceMethod(this, "next")) == 0 )
-                    return@addFn ObjTrue
-            }
-            ObjFalse
-        }
-
-    }
-}
-
-val ObjIterator by lazy { ObjClass("Iterator") }
-
-class ObjArrayIterator(val array: Obj) : Obj() {
-
-    override val objClass: ObjClass by lazy { type }
-
-    private var nextIndex = 0
-    private var lastIndex = 0
-
-    suspend fun init(context: Context) {
-        nextIndex = 0
-        lastIndex = array.invokeInstanceMethod(context, "size").toInt()
-        ObjVoid
-    }
-
-    companion object {
-        val type by lazy {
-            ObjClass("ArrayIterator", ObjIterator).apply {
-                addFn("next") {
-                    val self = thisAs<ObjArrayIterator>()
-                    if (self.nextIndex < self.lastIndex) {
-                        self.array.invokeInstanceMethod(this, "getAt", (self.nextIndex++).toObj())
-                    } else raiseError(ObjIterationFinishedException(this))
-                }
-                addFn("hasNext") {
-                    val self = thisAs<ObjArrayIterator>()
-                    if (self.nextIndex < self.lastIndex) ObjTrue else ObjFalse
-                }
-            }
-        }
-    }
-}
-
-
-val ObjArray by lazy {
-
-    /**
-     * Array abstract class is a [ObjCollection] with `getAt` method.
-     */
-    ObjClass("Array", ObjCollection).apply {
-        // we can create iterators using size/getat:
-
-        addFn("iterator") {
-            ObjArrayIterator(thisObj).also { it.init(this) }
-        }
-
-        addFn("contains", isOpen = true) {
-            val obj = args.firstAndOnly()
-            for (i in 0..<thisObj.invokeInstanceMethod(this, "size").toInt()) {
-                if (thisObj.getAt(this, ObjInt(i.toLong())).compareTo(this, obj) == 0) return@addFn ObjTrue
-            }
-            ObjFalse
-        }
-
-        addFn("last") {
-            thisObj.invokeInstanceMethod(
-                this,
-                "getAt",
-                (thisObj.invokeInstanceMethod(this, "size").toInt() - 1).toObj()
-            )
-        }
-
-        addFn("lastIndex") { (thisObj.invokeInstanceMethod(this, "size").toInt() - 1).toObj() }
-
-        addFn("indices") {
-            ObjRange(0.toObj(), thisObj.invokeInstanceMethod(this, "size"), false)
-        }
-
-    }
-}
 

lynglib/src/commonMain/kotlin/net/sergeych/lyng/ObjCollection.kt

@@ -0,0 +1,8 @@
+package net.sergeych.lyng
+
+/**
+ * Collection is an iterator with `size`]
+ */
+val ObjCollection = ObjClass("Collection", ObjIterable).apply {
+
+    }

lynglib/src/commonMain/kotlin/net/sergeych/lyng/ObjIterable.kt

@@ -0,0 +1,80 @@
+package net.sergeych.lyng
+
+/**
+ * Abstract class that must provide `iterator` method that returns [ObjIterator] instance.
+ */
+val ObjIterable by lazy {
+    ObjClass("Iterable").apply {
+
+        addFn("toList") {
+            val result = mutableListOf<Obj>()
+            val iterator = thisObj.invokeInstanceMethod(this, "iterator")
+
+            while (iterator.invokeInstanceMethod(this, "hasNext").toBool())
+                result += iterator.invokeInstanceMethod(this, "next")
+            ObjList(result)
+        }
+
+        // it is not effective, but it is open:
+        addFn("contains", isOpen = true) {
+            val obj = args.firstAndOnly()
+            val it = thisObj.invokeInstanceMethod(this, "iterator")
+            while (it.invokeInstanceMethod(this, "hasNext").toBool()) {
+                if (obj.compareTo(this, it.invokeInstanceMethod(this, "next")) == 0)
+                    return@addFn ObjTrue
+            }
+            ObjFalse
+        }
+
+        addFn("indexOf", isOpen = true) {
+            val obj = args.firstAndOnly()
+            var index = 0
+            val it = thisObj.invokeInstanceMethod(this, "iterator")
+            while (it.invokeInstanceMethod(this, "hasNext").toBool()) {
+                if (obj.compareTo(this, it.invokeInstanceMethod(this, "next")) == 0)
+                    return@addFn ObjInt(index.toLong())
+                index++
+            }
+            ObjInt(-1L)
+        }
+
+        addFn("toSet") {
+            val result = mutableSetOf<Obj>()
+            val it = thisObj.invokeInstanceMethod(this, "iterator")
+            while (it.invokeInstanceMethod(this, "hasNext").toBool()) {
+                result += it.invokeInstanceMethod(this, "next")
+            }
+            ObjSet(result)
+        }
+
+        addFn("forEach", isOpen = true) {
+            val it = thisObj.invokeInstanceMethod(this, "iterator")
+            val fn = requiredArg<Statement>(0)
+            while (it.invokeInstanceMethod(this, "hasNext").toBool()) {
+                val x = it.invokeInstanceMethod(this, "next")
+                fn.execute(this.copy(Arguments(listOf(x))))
+            }
+            ObjVoid
+        }
+
+        addFn("map", isOpen = true) {
+            val it = thisObj.invokeInstanceMethod(this, "iterator")
+            val fn = requiredArg<Statement>(0)
+            val result = mutableListOf<Obj>()
+            while (it.invokeInstanceMethod(this, "hasNext").toBool()) {
+                val x = it.invokeInstanceMethod(this, "next")
+                result += fn.execute(this.copy(Arguments(listOf(x))))
+            }
+            ObjList(result)
+        }
+
+        addFn("isEmpty") {
+            ObjBool(
+                thisObj.invokeInstanceMethod(this, "iterator")
+                    .invokeInstanceMethod(this, "hasNext").toBool()
+                    .not()
+            )
+        }
+
+    }
+}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/ObjIterator.kt

@@ -0,0 +1,3 @@
+package net.sergeych.lyng
+
+val ObjIterator by lazy { ObjClass("Iterator") }

lynglib/src/commonMain/kotlin/net/sergeych/lyng/ObjKotlinIterator.kt

@@ -0,0 +1,14 @@
+package net.sergeych.lyng
+
+class ObjKotlinIterator(val iterator: Iterator<Any?>): Obj() {
+
+    override val objClass = type
+
+    companion object {
+        val type = ObjClass("KotlinIterator", ObjIterator).apply {
+            addFn("next") { thisAs<ObjKotlinIterator>().iterator.next().toObj() }
+            addFn("hasNext") { thisAs<ObjKotlinIterator>().iterator.hasNext().toObj() }
+        }
+
+    }
+}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/ObjList.kt

@@ -211,4 +211,6 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
             }
         }
     }
-}
+}
+
+

lynglib/src/commonMain/kotlin/net/sergeych/lyng/ObjSet.kt

@@ -0,0 +1,97 @@
+package net.sergeych.lyng
+
+class ObjSet(val set: MutableSet<Obj> = mutableSetOf()) : Obj() {
+
+    override val objClass = type
+
+    override suspend fun contains(context: Context, other: Obj): Boolean {
+        return set.contains(other)
+    }
+
+    override suspend fun plus(context: Context, other: Obj): Obj {
+        return ObjSet(
+            if (other is ObjSet)
+                (set + other.set).toMutableSet()
+            else
+                (set + other).toMutableSet()
+        )
+    }
+
+    override suspend fun plusAssign(context: Context, other: Obj): Obj {
+        when (other) {
+            is ObjSet -> {
+                set += other.set
+            }
+
+            is ObjList -> {
+                set += other.list
+            }
+
+            else -> {
+                if (other.isInstanceOf(ObjIterable)) {
+                    val i = other.invokeInstanceMethod(context, "iterable")
+                    while (i.invokeInstanceMethod(context, "hasNext").toBool()) {
+                        set += i.invokeInstanceMethod(context, "next")
+                    }
+                }
+                set += other
+            }
+        }
+        return this
+    }
+
+    override suspend fun mul(context: Context, other: Obj): Obj {
+        return if (other is ObjSet) {
+            ObjSet(set.intersect(other.set).toMutableSet())
+        } else
+            context.raiseArgumentError("set operator * requires another set")
+    }
+
+    override suspend fun minus(context: Context, other: Obj): Obj {
+        if (other !is ObjSet)
+            context.raiseArgumentError("set operator - requires another set")
+        return ObjSet(set.minus(other.set).toMutableSet())
+    }
+
+    override fun toString(): String {
+        return "Set(${set.joinToString(", ")})"
+    }
+
+    override suspend fun compareTo(context: Context, other: Obj): Int {
+        return if (other !is ObjSet) -1
+        else {
+            if (set == other.set) 0
+            else -1
+        }
+    }
+
+    companion object {
+        val type = object : ObjClass("Set", ObjCollection) {
+            override suspend fun callOn(context: Context): Obj {
+                return ObjSet(context.args.list.toMutableSet())
+            }
+        }.apply {
+            addFn("size") {
+                thisAs<ObjSet>().set.size.toObj()
+            }
+            addFn("intersect") {
+                thisAs<ObjSet>().mul(this, args.firstAndOnly())
+            }
+            addFn("iterator") {
+                thisAs<ObjSet>().set.iterator().toObj()
+            }
+            addFn("union") {
+                thisAs<ObjSet>().plus(this, args.firstAndOnly())
+            }
+            addFn("subtract") {
+                thisAs<ObjSet>().minus(this, args.firstAndOnly())
+            }
+            addFn("remove") {
+                val set = thisAs<ObjSet>().set
+                val n = set.size
+                for( x in args.list ) set -= x
+                if( n == set.size ) ObjFalse else ObjTrue
+            }
+        }
+    }
+}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt

@@ -152,11 +152,13 @@ class Script(
             addConst("Bool", ObjBool.type)
             addConst("Char", ObjChar.type)
             addConst("List", ObjList.type)
+            addConst("Set", ObjSet.type)
             addConst("Range", ObjRange.type)
             @Suppress("RemoveRedundantQualifierName")
             addConst("Callable", Statement.type)
             // interfaces
             addConst("Iterable", ObjIterable)
+            addConst("Collection", ObjCollection)
             addConst("Array", ObjArray)
             addConst("Class", ObjClassType)
             addConst("Object", Obj().objClass)