gilmore606 · gilmore606 · Jul 13, 2025 · Jul 11, 2025 · Jul 12, 2025 · Jul 12, 2025
diff --git a/src/main/kotlin/compiler/parser/Parser.kt b/src/main/kotlin/compiler/parser/Parser.kt
@@ -655,14 +655,15 @@ class Parser(inputTokens: List<Token>) {
     // Parse lambda: { var, var -> ... } or { ... }
     private fun pLambdaFun(): N_EXPR? {
         consume(T_BRACE_OPEN)?.also {
-            var done = false
             val args = mutableListOf<N_IDENTIFIER>()
-            while (!done) {
-                done = true
+            while (nextAre(T_IDENTIFIER, T_COMMA)) {
+                consume(T_IDENTIFIER)?.also { args.add(N_IDENTIFIER(it.string)) }
+                consume(T_COMMA)
+            }
+            while (nextAre(T_IDENTIFIER, T_ARROW)) {
                 consume(T_IDENTIFIER)?.also { args.add(N_IDENTIFIER(it.string)) }
-                consume(T_COMMA)?.also { done = false }
             }
-            if (args.isNotEmpty()) consume(T_ARROW) ?: fail("missing arrow after function literal var declaration")
+            if (args.isNotEmpty()) consume(T_ARROW) ?: fail("missing arrow after function var declaration")
             val code = mutableListOf<N_STATEMENT>()
             while (!nextIs(T_BRACE_CLOSE)) {
                 pStatement()?.also { code.add(it) } ?: fail("non-statement in braces")

diff --git a/src/main/kotlin/server/mcp/MCP.kt b/src/main/kotlin/server/mcp/MCP.kt
@@ -75,10 +75,17 @@ object MCP {
                 timeMap.remove(task.timeID)
                 taskMap.remove(task.id)
                 val result = task.execute()
-                if (result is Task.Result.Suspend) {
-                    task.setTime(result.seconds)
-                    timeMap[task.timeID] = task
-                    taskMap[task.id] = task
+                when (result) {
+                    is Task.Result.Suspend -> {
+                        task.setTime(result.seconds)
+                        timeMap[task.timeID] = task
+                        taskMap[task.id] = task
+                    }
+                    is Task.Result.Failed -> {
+                        task.connection?.sendText(result.e.toString())
+                        task.connection?.sendText(task.stackDump())
+                    }
+                    is Task.Result.Finished -> { }
                 }
                 task = getNextTask()
             }

diff --git a/src/main/kotlin/server/mcp/Task.kt b/src/main/kotlin/server/mcp/Task.kt
@@ -6,6 +6,7 @@ import com.dlfsystems.yegg.util.NanoID
 import com.dlfsystems.yegg.util.systemEpoch
 import com.dlfsystems.yegg.value.VObj
 import com.dlfsystems.yegg.value.VTask
+import com.dlfsystems.yegg.value.VVoid
 import com.dlfsystems.yegg.value.Value
 import com.dlfsystems.yegg.vm.*
 import com.dlfsystems.yegg.vm.VMException.Type.*
@@ -47,21 +48,21 @@ class Task(
 
 
     sealed interface Result {
-        data object Finished: Result
-        @JvmInline value class Suspend(val seconds: Int): Result
+        data class Finished(val v: Value): Result
+        data class Suspend(val seconds: Int): Result
+        data class Failed(val e: Exception): Result
     }
 
     // Execute the top stack frame.
     // On a Suspend, return Suspend upward to MCP.
     // On a Call, push a new stack frame.
     // On a Return, pop a stack frame, and save the return value to pass to the next iteration (the previous frame).
     // Continue until the stack is empty.
-
-    fun execute(): Result {
+    fun execute(toDepth: Int = 0): Result {
         var vReturn: Value? = resumeResult
         resumeResult = null
         try {
-            while (stack.isNotEmpty()) {
+            while (stack.size > toDepth) {
                 stack.first().execute(vReturn).also { result ->
                     vReturn = null
                     when (result) {
@@ -80,15 +81,28 @@ class Task(
                     }
                 }
             }
+            val result = Result.Finished(vReturn ?: VVoid)
+            return result
         } catch (e: Exception) {
-            connection?.sendText(e.toString())
-            connection?.sendText(stackDump())
+            return Result.Failed(e)
+        }
+    }
+
+    // Execute an exe immediately for a return value.  The task cannot suspend.
+    // Used by system functions to call verb code in an existing Task.
+    override fun executeForResult(exe: Executable, args: List<Value>): Value {
+        push(vThis, exe, args)
+        execute(toDepth = stack.size - 1).also { result ->
+            when (result) {
+                is Result.Suspend -> fail(E_LIMIT, "cannot suspend in verb called by system")
+                is Result.Failed -> throw result.e
+                is Result.Finished -> return result.v
+            }
         }
-        return Result.Finished
+        return VVoid
     }
 
-    // Add a VM to the stack to run an exe.
-    fun push(
+    private fun push(
         vThis: VObj,
         exe: Executable,
         args: List<Value>,
@@ -99,12 +113,13 @@ class Task(
         )
     }
 
-    fun pop(): VM {
+    private fun pop(): VM {
         return stack.removeFirst()
     }
 
     fun stackDump() = stack.joinToString(prefix = "...", separator = "\n...", postfix = "\n")
 
+
     companion object {
         fun make(
             exe: Executable,

diff --git a/src/main/kotlin/value/VList.kt b/src/main/kotlin/value/VList.kt
@@ -44,8 +44,8 @@ data class VList(var v: MutableList<Value> = mutableListOf()): Value() {
     private fun propSorted(): VList {
         if (v.isEmpty()) return make(v)
         return make(when (v[0]) {
-            is VInt -> v.sortedBy { (it as VInt).v }
-            is VFloat -> v.sortedBy { (it as VFloat).v }
+            is VInt -> v.sortedBy { (it as? VInt)?.v ?: 0 }
+            is VFloat -> v.sortedBy { (it as? VFloat)?.v ?: 0f }
             else -> v.sortedBy { it.asString() }
         })
     }
@@ -109,6 +109,10 @@ data class VList(var v: MutableList<Value> = mutableListOf()): Value() {
         "clear" -> verbClear(args)
         "reverse" -> verbReverse(args)
         "shuffle" -> verbShuffle(args)
+        "first" -> verbFirst(c, args)
+        "filter" -> verbFilter(c, args)
+        "map" -> verbMap(c, args)
+        "sortedBy" -> verbSortedBy(c, args)
         else -> null
     }
 
@@ -222,6 +226,42 @@ data class VList(var v: MutableList<Value> = mutableListOf()): Value() {
         return VVoid
     }
 
+    private fun verbFirst(c: Context, args: List<Value>): Value {
+        requireArgCount(args, 1, 1)
+        if (args[0] !is VFun) fail(E_TYPE, "${args[0].type} is not FUN")
+        v.forEach { ele ->
+            c.executeForResult(args[0] as VFun, listOf(ele)).also {
+                if (it.isTrue()) return ele
+            }
+        }
+        return VVoid
+    }
+
+    private fun verbFilter(c: Context, args: List<Value>): Value {
+        requireArgCount(args, 1, 1)
+        if (args[0] !is VFun) fail(E_TYPE, "${args[0].type} is not FUN")
+        return make(v.filter { c.executeForResult(args[0] as VFun, listOf(it)).isTrue() })
+    }
+
+    private fun verbMap(c: Context, args: List<Value>): Value {
+        requireArgCount(args, 1, 1)
+        if (args[0] !is VFun) fail(E_TYPE, "${args[0].type} is not FUN")
+        return make(v.map { c.executeForResult(args[0] as VFun, listOf(it)) })
+    }
+
+    private fun verbSortedBy(c: Context, args: List<Value>): Value {
+        requireArgCount(args, 1, 1)
+        if (args[0] !is VFun) fail(E_TYPE, "${args[0].type} is not FUN")
+        if (v.isEmpty()) return make(v)
+        val pairs = v.map { it to c.executeForResult(args[0] as VFun, listOf(it)) }
+        return make(when (pairs[0].second) {
+            is VInt -> pairs.sortedBy { (it.second as? VInt)?.v ?: 0 }
+            is VFloat -> pairs.sortedBy { (it.second as? VFloat)?.v ?: 0f }
+            else -> pairs.sortedBy { it.second.asString() }
+        }.map { it.first })
+    }
+
+    // Check bounds of passed arg as a position in this list.
     private fun positionArg(arg: Value): Int {
         if (arg.type != Type.INT) fail(E_TYPE, "invalid ${arg.type} list position")
         val pos = (arg as VInt).v

diff --git a/src/main/kotlin/vm/Context.kt b/src/main/kotlin/vm/Context.kt
@@ -2,6 +2,7 @@ package com.dlfsystems.yegg.vm
 
 import com.dlfsystems.yegg.server.mcp.Task
 import com.dlfsystems.yegg.value.VObj
+import com.dlfsystems.yegg.value.Value
 
 
 interface Context {
@@ -15,4 +16,6 @@ interface Context {
     var ticksLeft: Int
     var callsLeft: Int
 
+    fun executeForResult(exe: Executable, args: List<Value>): Value
+
 }
diff --git a/src/main/kotlin/vm/VM.kt b/src/main/kotlin/vm/VM.kt
@@ -38,6 +38,9 @@ class VM(
     // Used by optimizer opcodes.
     private var dropReturnValue: Boolean = false
 
+    // Value of this execution as an expression. Returned if we have no other return value.
+    private var exprValue: Value = VVoid
+
     private inline fun push(v: Value) = stack.addFirst(v)
     private inline fun peek() = stack.first()
     private inline fun pop() = stack.removeFirst()
@@ -95,7 +98,7 @@ class VM(
             when (word.opcode) {
 
                 O_DISCARD -> {
-                    if (stack.isNotEmpty()) pop()
+                    if (stack.isNotEmpty()) exprValue = pop()
                 }
 
                 // Value ops
@@ -165,10 +168,10 @@ class VM(
                 O_JUMP -> {
                     val addr = next().address!!
                     // Unresolved jump dest means end-of-code
-                    if (addr >= 0) pc = addr else return Result.Return(VVoid)
+                    if (addr >= 0) pc = addr else return Result.Return(exprValue)
                 }
                 O_RETURN -> {
-                    if (stack.isEmpty()) return Result.Return(VVoid)
+                    if (stack.isEmpty()) return Result.Return(exprValue)
                     if (stack.size > 1) fail(E_SYS, "stack polluted on return!  ${dumpStack()}")
                     return Result.Return(pop())
                 }
@@ -397,7 +400,7 @@ class VM(
                 else -> fail(E_SYS, "unknown opcode $word")
             }
         }
-        return Result.Return(if (stack.isEmpty()) VVoid else pop())
+        return Result.Return(if (stack.isEmpty()) exprValue else pop())
     }
 
 }
diff --git a/src/test/kotlin/LangTest.kt b/src/test/kotlin/LangTest.kt
@@ -184,4 +184,52 @@ class LangTest: YeggTest() {
         """)
     }
 
+    @Test
+    fun `Mixed list sorted by first value type`() = yeggTest {
+        runForOutput($$"""
+            foo = [36, 9, "hello", 88, 5.6]
+            notifyConn(foo.sorted)
+        """, """
+            "hello", 5.6, 9, 36, 88
+        """)
+    }
+
+    @Test
+    fun `List filter`() = yeggTest {
+        runForOutput($$"""
+            foo = [1,5,7,12,26,31,74].filter({ it % 2 == 0 })
+            notifyConn(foo)
+        """, """
+            12, 26, 74
+        """)
+    }
+
+    @Test
+    fun `List map`() = yeggTest {
+        verb("sys", "resultOf", $$"""
+            [input] = args
+            return input * 10
+        """)
+        runForOutput($$"""
+            foo = [1,3,5].map({ "got ${$sys.resultOf(it)}" })
+            for (x in foo) notifyConn("$x")
+        """, """
+            got 10
+            got 30
+            got 50
+        """)
+    }
+
+    @Test
+    fun `List sortedBy`() = yeggTest {
+        runForOutput($$"""
+            foo = ["beer", "egg", "cheese", "me"].sortedBy({ it.length })
+            for (x in foo) notifyConn("$x")
+        """, """
+            me
+            egg
+            beer
+            cheese
+        """)
+    }
 }