+inference bugs

+List.ensureCapacity
optimized List.fill

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

@@ -3424,6 +3424,10 @@ class Compiler(
                     index < expectedParams.size
                 ) {
                     expectedParams[index]
+                } else if (param.type == TypeDecl.TypeAny && index == 0 && argsDeclaration.params.size == 1 &&
+                    implicitItType != null
+                ) {
+                    implicitItType
                 } else {
                     param.type
                 }

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

@@ -528,6 +528,22 @@ open class ObjList(initialList: MutableList<Obj> = mutableListOf()) : Obj() {
                 } else self.list.removeLast()
                 self
             }
+            addFnDoc(
+                name= "ensureCapacity",
+                doc = """
+                    ensure the list capacity allows storing specified amount if items without reallocation. 
+                    If current capacity is greater or equal to `count`, does nothing. Note that possible reallocation
+                    could be a costly operation,
+                """.trimIndent(),
+                params = listOf(ParamDoc("count", type("lyng.Int"))),
+                moduleName = "lyng.stdlib"
+            ) {
+                val self = thisAs<ObjList>()
+                val list = self.list as ArrayList
+                val count = requireOnlyArg<ObjInt>().value.toInt()
+                list.ensureCapacity(count)
+                self
+            }
 
             addFnDoc(
                 name = "removeRange",

lynglib/src/commonTest/kotlin/StdlibTest.kt

@@ -436,4 +436,12 @@ class StdlibTest {
             assertEquals(2, x)
         """.trimIndent())
     }
+
+    @Test
+    fun testListFill() = runTest {
+        eval("""
+            val x = List.fill(5) { i -> i * 10 }
+            assertEquals([0, 10, 20, 30, 40], x)
+        """.trimIndent())
+    }
 }

lynglib/stdlib/lyng/root.lyng

@@ -432,11 +432,19 @@ fun List<T>.sort(): void {
     sortWith { a, b -> a <=> b }
 }
 
-/* Build a new list of `size` elements by calling `block(index)` for each index. */
-static fun List<T>.fill(size: Int, block: (Int)->T): List<T> {
-    val result = List<T>()
-    for( i in 0..<size ) result += block(i)
-    result
+/*
+    Build a new list of `size` elements by calling `block(index)` for each index.
+    `capacity` less size is ignored (size will be used as capacity).
+*/
+static fun List<T>.fill(size: Int, capacity = -1, block: (Int)->T): List<T> {
+    require(size >= 0, "size must not be negative")
+    val capacity = capacity < size ? size : capacity
+    List<T>().also {
+        if( size > 0 ) {
+            it.ensureCapacity(capacity)
+            for( i in 0..<size ) it += block(i)
+        }
+    }
 }
 
 /* Print this exception and its stack trace to standard output. */
@@ -587,7 +595,7 @@ class LaunchPool(maxWorkers, maxQueueSize = Channel.UNLIMITED) {
         mu.withLock {
             if (isClosed) throw IllegalStateException("LaunchPool is closed")
         }
-        val d = CompletableDeferred()
+            val d = CompletableDeferred()
         val wrapper = {
             try { d.complete(lambda()) }
             catch(e) { d.completeExceptionally(e) }