v0.9.3 published for all platforms; dyanimc improvements & more

open ObjDynamic
found a pfoblem with dynamic, see todo in OOTest.kt

.github/workflows/gradle.yml

@@ -1,54 +0,0 @@
-# This workflow uses actions that are not certified by GitHub.
-# They are provided by a third-party and are governed by
-# separate terms of service, privacy policy, and support
-# documentation.
-# This workflow will build a Java project with Gradle and cache/restore any dependencies to improve the workflow execution time
-# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-java-with-gradle
-
-name: Java CI with Gradle
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-  workflow_call:
-
-permissions:
-  contents: read
-
-jobs:
-  build:
-    strategy:
-      matrix:
-        include:
-          - target: iosSimulatorArm64Test
-            os: macos-latest
-          - target: jvmTest
-            os: ubuntu-latest
-          - target: linuxX64Test
-            os: ubuntu-latest
-          - target: testDebugUnitTest
-            os: ubuntu-latest
-          - target: testReleaseUnitTest
-            os: ubuntu-latest
-    runs-on: ${{ matrix.os }}
-
-    steps:
-    - uses: actions/checkout@v3
-    - name: Validate Gradle Wrapper
-      uses: gradle/actions/wrapper-validation@v3
-    - uses: actions/cache@v3
-      with:
-        path: |
-          ~/.konan
-        key: ${{ runner.os }}-${{ hashFiles('**/.lock') }}
-    - name: Set up JDK 17
-      uses: actions/setup-java@v3
-      with:
-        java-version: '17'
-        distribution: 'temurin'
-    - name: Build with Gradle
-      uses: gradle/gradle-build-action@ce999babab2de1c4b649dc15f0ee67e6246c994f
-      with:
-        arguments: ${{ matrix.target }}

.github/workflows/publish.yml

@@ -1,25 +0,0 @@
-name: Publish
-on:
-  release:
-    types: [released, prereleased]
-jobs:
-  publish:
-    name: Release build and publish
-    runs-on: macOS-latest
-    steps:
-      - name: Check out code
-        uses: actions/checkout@v4
-      - name: Set up JDK 21
-        uses: actions/setup-java@v4
-        with:
-          distribution: 'zulu'
-          java-version: 21
-      - name: Publish to MavenCentral
-        run: ./gradlew publishToMavenCentral --no-configuration-cache
-        env:
-          ORG_GRADLE_PROJECT_mavenCentralUsername: ${{ secrets.MAVEN_CENTRAL_USERNAME }}
-          ORG_GRADLE_PROJECT_mavenCentralPassword: ${{ secrets.MAVEN_CENTRAL_PASSWORD }}
-          ORG_GRADLE_PROJECT_signingInMemoryKeyId: ${{ secrets.SIGNING_KEY_ID }}
-          ORG_GRADLE_PROJECT_signingInMemoryKeyPassword: ${{ secrets.SIGNING_PASSWORD }}
-          ORG_GRADLE_PROJECT_signingInMemoryKey: ${{ secrets.GPG_KEY_CONTENTS }}
-

.run/Tests in 'lyng.lynglib.jvmTest'.run.xml

@@ -1,42 +0,0 @@
-<!--
-  ~ Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~     http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License.
-  ~
-  -->
-
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Tests in 'lyng.lynglib.jvmTest'" type="GradleRunConfiguration" factoryName="Gradle">
-    <ExternalSystemSettings>
-      <option name="executionName" />
-      <option name="externalProjectPath" value="$PROJECT_DIR$" />
-      <option name="externalSystemIdString" value="GRADLE" />
-      <option name="scriptParameters" value="" />
-      <option name="taskDescriptions">
-        <list />
-      </option>
-      <option name="taskNames">
-        <list>
-          <option value=":lynglib:cleanJvmTest" />
-          <option value=":lynglib:jvmTest" />
-        </list>
-      </option>
-      <option name="vmOptions" />
-    </ExternalSystemSettings>
-    <ExternalSystemDebugServerProcess>false</ExternalSystemDebugServerProcess>
-    <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
-    <DebugAllEnabled>false</DebugAllEnabled>
-    <RunAsTest>true</RunAsTest>
-    <method v="2" />
-  </configuration>
-</component>

docs/OOP.md

@@ -266,7 +266,7 @@ The same we can provide writable dynamic fields (var-type), adding set method:
                 // constant field
                 "foo" -> "bar"
                 // mutable field
-                "bar" -> setValueForBar 
+                "bar" -> storedValueForBar 
 
                 else -> throw SymbolNotFoundException()
             }
@@ -275,8 +275,8 @@ The same we can provide writable dynamic fields (var-type), adding set method:
             // only 'bar' is mutable:
             if( name == "bar" )
                 storedValueForBar = value
-            // the rest is immotable. consider throw also
-            // SymbolNotFoundException when needed.
+                // the rest is immotable. consider throw also
+                // SymbolNotFoundException when needed.
             else throw IllegalAssignmentException("Can't assign "+name)
         }
     }
@@ -289,9 +289,56 @@ The same we can provide writable dynamic fields (var-type), adding set method:
     assertThrows {
         accessor.bad = "!23"
     }
+    void
+    >>> void
 
 Of course, you can return any object from dynamic fields; returning lambdas let create _dynamic methods_ - the callable method. It is very convenient to implement libraries with dynamic remote interfaces, etc.
 
+### Dynamic indexers
+
+Index access for dynamics is passed to the same getter and setter, so it is
+generally the same:
+
+    var storedValue = "bar"
+    val x = dynamic {
+        get { 
+            if( it == "foo" ) storedValue
+            else null
+        }
+    }
+    assertEquals("bar", x["foo"] )
+    assertEquals("bar", x.foo )
+    >>> void
+
+And assigning them works the same. You can make it working
+mimicking arrays, but remember, it is not Collection so
+collection's sugar won't work with it:
+
+    var storedValue = "bar"
+    val x = dynamic {
+        get { 
+            when(it) {
+                "size" -> 1
+                0 -> storedValue
+                else -> null
+            }
+        }
+        set { index, value -> 
+            if( index == 0 ) storedValue = value
+            else throw "Illegal index: "+index
+        }
+    }
+    assertEquals("bar", x[0] )
+    assertEquals(1, x.size )
+    x[0] = "buzz"
+    assertThrows { x[1] = 1 }
+    assertEquals("buzz", storedValue)
+    assertEquals("buzz", x[0])
+    >>> void
+
+If you want dynamic to function like an array, create a [feature
+request](https://gitea.sergeych.net/SergeychWorks/lyng/issues).
+
 # Theory
 
 ## Basic principles:

docs/development/String.md

@@ -0,0 +1,26 @@
+# String
+
+# This document is for developer notes only
+
+--------------------------
+
+
+## Interpolation proposal
+
+"""no $iterpolation"""
+    
+    val inpterpolation1 = "foo"
+    "${interpolation1}"
+    >>> "foo"
+
+"$interpolation2"
+"no $$ interpolatino"
+
+
+## Regexp vs div / ?
+
+```EBNF
+regex_literal = "/", { regchar }, "/", [ flag ]
+foag = "i" | "n"....
+regchar = x`x`
+```

docs/samples/happy_numbers.lyng.bad

@@ -21,10 +21,10 @@ import lyng.time
 //
 // After all optimizations it takes ~120ms.
 //
-//for( r in 1..100 ) {
-//    val start = Instant.now()
+for( r in 1..100 ) {
+    val start = Instant.now()
     val found = naiveCountHappyNumbers()
-//    println("Found happy numbers: %d time %s"(found, Instant.now() - start))
+    println("Found happy numbers: %d time %s"(found, Instant.now() - start))
     assert( found == 55252 )
-//    delay(0.01)
-//}
+    delay(0.1)
+}

docs/tutorial.md

@@ -1403,7 +1403,7 @@ See [math functions](math.md). Other general purpose functions are:
 
 [Range]: Range.md
 
-[String]: String.md
+[String]: development/String.md
 
 [string formatting]: https://github.com/sergeych/mp_stools?tab=readme-ov-file#sprintf-syntax-summary
 

gradle/libs.versions.toml

@@ -1,10 +1,10 @@
 [versions]
 agp = "8.5.2"
 clikt = "5.0.3"
-kotlin = "2.1.21"
+kotlin = "2.2.20"
 android-minSdk = "24"
 android-compileSdk = "34"
-kotlinx-coroutines = "1.9.0"
+kotlinx-coroutines = "1.10.2"
 mp_bintools = "0.1.12"
 firebaseCrashlyticsBuildtools = "3.0.3"
 okioVersion = "3.10.2"

lyng/build.gradle.kts

@@ -16,7 +16,7 @@
  */
 
 plugins {
-    kotlin("multiplatform") version "2.1.21"
+    kotlin("multiplatform") version "2.2.20"
 }
 
 group = "net.sergeych"

lynglib/build.gradle.kts

@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
 import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
 group = "net.sergeych"
-version = "0.9.0-SNAPSHOT"
+version = "0.9.3"
 
 buildscript {
     repositories {
@@ -37,7 +37,7 @@ plugins {
     alias(libs.plugins.kotlinMultiplatform)
     alias(libs.plugins.androidLibrary)
 //    alias(libs.plugins.vanniktech.mavenPublish)
-    kotlin("plugin.serialization") version "2.2.0"
+    kotlin("plugin.serialization") version "2.1.0"
     id("com.codingfeline.buildkonfig") version "0.17.1"
     `maven-publish`
 }
@@ -62,10 +62,14 @@ kotlin {
             jvmTarget.set(JvmTarget.JVM_11)
         }
     }
-//    iosX64()
-//    iosArm64()
-//    iosSimulatorArm64()
+    iosX64()
+    iosArm64()
+    iosSimulatorArm64()
+    macosX64()
+    macosArm64()
+    mingwX64()
     linuxX64()
+    linuxArm64()
     js {
         browser()
         nodejs()
@@ -79,9 +83,9 @@ kotlin {
     sourceSets {
         all {
             languageSettings.optIn("kotlinx.coroutines.ExperimentalCoroutinesApi")
-            languageSettings.optIn("kotlin.contracts.ExperimentalContracts")
             languageSettings.optIn("kotlin.ExperimentalUnsignedTypes")
             languageSettings.optIn("kotlin.coroutines.DelicateCoroutinesApi")
+            languageSettings.optIn("kotlin.contracts.ExperimentalContracts")
             languageSettings.optIn("kotlinx.coroutines.flow.DelicateCoroutinesApi")
         }
 

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

@@ -796,7 +796,7 @@ class Compiler(
             val v = left.getter(context)
             if (v.value == ObjNull && isOptional) return@Accessor v.value.asReadonly
             v.value.callOn(
-                context.copy(
+                context.createChildScope(
                     context.pos,
                     args.toArguments(context, detectedBlockArgument)
 //                Arguments(
@@ -888,6 +888,7 @@ class Compiler(
         }
     }
 
+    @Suppress("SameParameterValue")
     private fun parseNumber(isPlus: Boolean): Obj {
         return parseNumberOrNull(isPlus) ?: throw ScriptError(cc.currentPos(), "Expecting number")
     }
@@ -901,7 +902,7 @@ class Compiler(
             val args = extras?.let { required + it } ?: required
             val fn = scope.get(t.value)?.value ?: scope.raiseSymbolNotFound("annotation not found: ${t.value}")
             if (fn !is Statement) scope.raiseIllegalArgument("annotation must be callable, got ${fn.objClass}")
-            (fn.execute(scope.copy(Arguments(args))) as? Statement)
+            (fn.execute(scope.createChildScope(Arguments(args))) as? Statement)
                 ?: scope.raiseClassCastError("function annotation must return callable")
         }
     }
@@ -1196,7 +1197,7 @@ class Compiler(
                         }
                     }
                     if (exceptionObject != null) {
-                        val catchContext = this.copy(pos = cdata.catchVar.pos)
+                        val catchContext = this.createChildScope(pos = cdata.catchVar.pos)
                         catchContext.addItem(cdata.catchVar.value, false, objException)
                         result = cdata.block.execute(catchContext)
                         isCaught = true
@@ -1312,7 +1313,7 @@ class Compiler(
                 // accessors, constructor registration, etc.
                 addItem(className, false, newClass)
                 if (initScope.isNotEmpty()) {
-                    val classScope = copy(newThisObj = newClass)
+                    val classScope = createChildScope(newThisObj = newClass)
                     newClass.classScope = classScope
                     for (s in initScope)
                         s.execute(classScope)
@@ -1366,7 +1367,7 @@ class Compiler(
 
 
             return statement(body.pos) { cxt ->
-                val forContext = cxt.copy(start)
+                val forContext = cxt.createChildScope(start)
 
                 // loop var: StoredObject
                 val loopSO = forContext.addItem(tVar.value, true, ObjNull)
@@ -1535,7 +1536,7 @@ class Compiler(
             var result: Obj = ObjVoid
             lateinit var doScope: Scope
             do {
-                doScope = it.copy().apply { skipScopeCreation = true }
+                doScope = it.createChildScope().apply { skipScopeCreation = true }
                 try {
                     result = body.execute(doScope)
                 } catch (e: LoopBreakContinueException) {
@@ -1681,7 +1682,7 @@ class Compiler(
 
         cc.skipTokenOfType(Token.Type.NEWLINE, isOptional = true)
         // could be else block:
-        val t2 = cc.next()
+        val t2 = cc.nextNonWhitespace()
 
         // we generate different statements: optimization
         return if (t2.type == Token.Type.ID && t2.value == "else") {
@@ -1815,7 +1816,7 @@ class Compiler(
         val block = parseScript()
         return statement(startPos) {
             // block run on inner context:
-            block.execute(if (it.skipScopeCreation) it else it.copy(startPos))
+            block.execute(if (it.skipScopeCreation) it else it.createChildScope(startPos))
         }.also {
             val t1 = cc.next()
             if (t1.type != Token.Type.RBRACE)

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

@@ -164,6 +164,7 @@ class CompilerContext(val tokens: List<Token>) {
         }
     }
 
+    @Suppress("NOTHING_TO_INLINE")
     inline fun addBreak() {
         breakFound = true
     }

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

@@ -28,7 +28,9 @@ data class Pos(val source: Source, val line: Int, val column: Int) {
         else if( line > 0) Pos(source, line-1, source.lines[line-1].length - 1)
         else throw IllegalStateException("can't go back from line 0, column 0")
 
-    val currentLine: String get() = if( end ) "EOF" else source.lines[line]
+    val currentLine: String get() =
+        if( end ) "EOF"
+        else if( line >= 0 ) source.lines[line] else "<no line information>"
 
     val end: Boolean get() = line >= source.lines.size
 

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

@@ -138,13 +138,27 @@ open class Scope(
                     )
         }
 
-    fun copy(pos: Pos, args: Arguments = Arguments.EMPTY, newThisObj: Obj? = null): Scope =
+    /**
+     * Creates a new child scope using the provided arguments and optional `thisObj`.
+     */
+    fun createChildScope(pos: Pos, args: Arguments = Arguments.EMPTY, newThisObj: Obj? = null): Scope =
         Scope(this, args, pos, newThisObj ?: thisObj)
 
-    fun copy(args: Arguments = Arguments.EMPTY, newThisObj: Obj? = null): Scope =
+    /**
+     * Creates a new child scope using the provided arguments and optional `thisObj`.
+     * The child scope inherits the current scope's properties such as position and the existing `thisObj` if no new `thisObj` is provided.
+     *
+     * @param args The arguments to associate with the child scope. Defaults to [Arguments.EMPTY].
+     * @param newThisObj The new `thisObj` to associate with the child scope. Defaults to the current scope's `thisObj` if not provided.
+     * @return A new instance of [Scope] initialized with the specified arguments and `thisObj`.
+     */
+    fun createChildScope(args: Arguments = Arguments.EMPTY, newThisObj: Obj? = null): Scope =
         Scope(this, args, pos, newThisObj ?: thisObj)
 
-    fun copy() = Scope(this, args, pos, thisObj)
+    /**
+     * @return A child scope with the same arguments, position and [thisObj]
+     */
+    fun createChildScope() = Scope(this, args, pos, thisObj)
 
     fun addItem(
         name: String,
@@ -240,8 +254,6 @@ open class Scope(
             p = p.parent
         }
         println("--------------------")
-        ObjVoid
-
     }
 
     open fun applyClosure(closure: Scope): Scope = ClosureScope(this, closure)

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

@@ -26,6 +26,7 @@ import net.sergeych.lynon.ObjLynonClass
 import net.sergeych.mp_tools.globalDefer
 import kotlin.math.*
 
+@Suppress("TYPE_INTERSECTION_AS_REIFIED_WARNING")
 class Script(
     override val pos: Pos,
     private val statements: List<Statement> = emptyList(),
@@ -182,7 +183,7 @@ class Script(
                 catch( e: ExecutionError ) {
                     e.errorObject
                 }
-                catch (e: ScriptError) {
+                catch (_: ScriptError) {
                     ObjNull
                 }
                 result ?: raiseError(ObjAssertionFailedException(this,"Expected exception but nothing was thrown"))

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

@@ -26,7 +26,7 @@ open class ScriptError(val pos: Pos, val errorMessage: String, cause: Throwable?
         $pos: Error: $errorMessage
         
         ${pos.currentLine}
-        ${"-".repeat(pos.column)}^
+        ${if( pos.column >= 0 ) "-".repeat(pos.column) + "^" else ""}
     """.trimIndent(),
     cause
 )

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

@@ -30,7 +30,7 @@ data class Token(val value: String, val pos: Pos, val type: Type) {
 
     @Suppress("unused")
     enum class Type {
-        ID, INT, REAL, HEX, STRING, CHAR,
+        ID, INT, REAL, HEX, STRING, STRING2, REGEX,  CHAR,
         LPAREN, RPAREN, LBRACE, RBRACE, LBRACKET, RBRACKET, COMMA,
         SEMICOLON, COLON,
         PLUS, MINUS, STAR, SLASH, PERCENT,

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

@@ -17,15 +17,12 @@
 
 package net.sergeych.lyng.obj
 
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 import net.sergeych.lyng.*
 import net.sergeych.lynon.LynonDecoder
 import net.sergeych.lynon.LynonEncoder
 import net.sergeych.lynon.LynonType
-import net.sergeych.synctools.ProtectedOp
 
 open class Obj {
 
@@ -39,12 +36,12 @@ open class Obj {
 
     var isFrozen: Boolean = false
 
-    private val monitor = Mutex()
+//    private val monitor = Mutex()
 
     //    private val memberMutex = Mutex()
-    internal var parentInstances: MutableList<Obj> = mutableListOf()
+//    internal var parentInstances: MutableList<Obj> = mutableListOf()
 
-    private val opInstances = ProtectedOp()
+//    private val opInstances = ProtectedOp()
 
     open suspend fun inspect(scope: Scope): String = toString(scope).value
 
@@ -100,7 +97,7 @@ open class Obj {
         // note that getInstanceMember traverses the hierarchy
         objClass.getInstanceMember(scope.pos, name).value
 
-    fun getMemberOrNull(name: String): Obj? = objClass.getInstanceMemberOrNull(name)?.value
+//    fun getMemberOrNull(name: String): Obj? = objClass.getInstanceMemberOrNull(name)?.value
 
     // methods that to override
 
@@ -232,14 +229,14 @@ open class Obj {
         if (isFrozen) scope.raiseError("attempt to mutate frozen object")
     }
 
-    suspend fun <T> sync(block: () -> T): T = monitor.withLock { block() }
+//    suspend fun <T> sync(block: () -> T): T = monitor.withLock { block() }
 
     open suspend fun readField(scope: Scope, name: String): ObjRecord {
         // could be property or class field:
         val obj = objClass.getInstanceMemberOrNull(name) ?: scope.raiseError("no such field: $name")
         return when (val value = obj.value) {
             is Statement -> {
-                ObjRecord(value.execute(scope.copy(scope.pos, newThisObj = this)), obj.isMutable)
+                ObjRecord(value.execute(scope.createChildScope(scope.pos, newThisObj = this)), obj.isMutable)
             }
             // could be writable property naturally
 //            null -> ObjNull.asReadonly
@@ -268,11 +265,11 @@ open class Obj {
     }
 
     suspend fun invoke(scope: Scope, thisObj: Obj, args: Arguments): Obj =
-        callOn(scope.copy(scope.pos, args = args, newThisObj = thisObj))
+        callOn(scope.createChildScope(scope.pos, args = args, newThisObj = thisObj))
 
     suspend fun invoke(scope: Scope, thisObj: Obj, vararg args: Obj): Obj =
         callOn(
-            scope.copy(
+            scope.createChildScope(
                 scope.pos,
                 args = Arguments(args.toList()),
                 newThisObj = thisObj
@@ -281,7 +278,7 @@ open class Obj {
 
     suspend fun invoke(scope: Scope, thisObj: Obj): Obj =
         callOn(
-            scope.copy(
+            scope.createChildScope(
                 scope.pos,
                 args = Arguments.EMPTY,
                 newThisObj = thisObj
@@ -289,7 +286,7 @@ open class Obj {
         )
 
     suspend fun invoke(scope: Scope, atPos: Pos, thisObj: Obj, args: Arguments): Obj =
-        callOn(scope.copy(atPos, args = args, newThisObj = thisObj))
+        callOn(scope.createChildScope(atPos, args = args, newThisObj = thisObj))
 
 
     val asReadonly: ObjRecord by lazy { ObjRecord(this, false) }
@@ -302,7 +299,7 @@ open class Obj {
     }
 
     fun autoInstanceScope(parent: Scope): Scope {
-        val scope = parent.copy(newThisObj = this, args = parent.args)
+        val scope = parent.createChildScope(newThisObj = this, args = parent.args)
         for (m in objClass.members) {
             scope.objects[m.key] = m.value
         }
@@ -335,7 +332,7 @@ open class Obj {
             }
             // utilities
             addFn("let") {
-                args.firstAndOnly().callOn(copy(Arguments(thisObj)))
+                args.firstAndOnly().callOn(createChildScope(Arguments(thisObj)))
             }
             addFn("apply") {
                 val body = args.firstAndOnly()
@@ -347,7 +344,7 @@ open class Obj {
                 thisObj
             }
             addFn("also") {
-                args.firstAndOnly().callOn(copy(Arguments(thisObj)))
+                args.firstAndOnly().callOn(createChildScope(Arguments(thisObj)))
                 thisObj
             }
             addFn("run") {
@@ -367,6 +364,7 @@ open class Obj {
         }
 
 
+        @Suppress("NOTHING_TO_INLINE")
         inline fun from(obj: Any?): Obj {
             @Suppress("UNCHECKED_CAST")
             return when (obj) {

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

@@ -35,12 +35,12 @@ class ObjBitBuffer(val bitArray: BitArray) : Obj() {
         }.apply {
             addFn("toBuffer") {
                 requireNoArgs()
-                ObjBuffer(thisAs<ObjBitBuffer>().bitArray.asUbyteArray())
+                ObjBuffer(thisAs<ObjBitBuffer>().bitArray.asUByteArray())
             }
             addFn("toDump") {
                 requireNoArgs()
                 ObjString(
-                    thisAs<ObjBitBuffer>().bitArray.asUbyteArray().toDump()
+                    thisAs<ObjBitBuffer>().bitArray.asUByteArray().toDump()
                 )
             }
             addFn("size") {

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

@@ -61,7 +61,7 @@ open class ObjClass(
 
     override suspend fun callOn(scope: Scope): Obj {
         val instance = ObjInstance(this)
-        instance.instanceScope = scope.copy(newThisObj = instance, args = scope.args)
+        instance.instanceScope = scope.createChildScope(newThisObj = instance, args = scope.args)
         if (instanceConstructor != null) {
             instanceConstructor!!.execute(instance.instanceScope)
         }
@@ -69,7 +69,7 @@ open class ObjClass(
     }
 
     suspend fun callWithArgs(scope: Scope, vararg plainArgs: Obj): Obj {
-        return callOn(scope.copy(Arguments(*plainArgs)))
+        return callOn(scope.createChildScope(Arguments(*plainArgs)))
     }
 
 

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

@@ -47,13 +47,20 @@ class ObjDynamicContext(val delegate: ObjDynamic) : Obj() {
     }
 }
 
-class ObjDynamic : Obj() {
+/**
+ * Object that delegates all its field access/invocation operations to a callback. It is used to implement dynamic
+ * objects using "dynamic" keyword.
+ */
+open class ObjDynamic(var readCallback: Statement? = null, var writeCallback: Statement? = null) : Obj() {
 
-    internal var readCallback: Statement? = null
-    internal var writeCallback: Statement? = null
+    override val objClass: ObjClass = type
 
+    /**
+     * Use read callback to dynamically resolve the field name. Note that it does not work
+     * with method invocation which is implemented separately in [invokeInstanceMethod] below.
+     */
     override suspend fun readField(scope: Scope, name: String): ObjRecord {
-        return readCallback?.execute(scope.copy(Arguments(ObjString(name))))?.let {
+        return readCallback?.execute(scope.createChildScope(Arguments(ObjString(name))))?.let {
             if (writeCallback != null)
                 it.asMutable
             else
@@ -62,21 +69,53 @@ class ObjDynamic : Obj() {
             ?: super.readField(scope, name)
     }
 
+    /**
+     * Notice that invocation currently does not rely on [readField], which is a buffy moment to be reconsidered
+     * in the future, so we implement it separately:
+     */
+    override suspend fun invokeInstanceMethod(
+        scope: Scope,
+        name: String,
+        args: Arguments,
+        onNotFoundResult: (() -> Obj?)?
+    ): Obj {
+        val over = readCallback?.execute(
+            scope.createChildScope(
+                Arguments(ObjString(name)
+                )
+            )
+        )
+        return over?.invoke(scope, scope.thisObj, args)
+            ?: super.invokeInstanceMethod(scope, name, args, onNotFoundResult)
+    }
+
     override suspend fun writeField(scope: Scope, name: String, newValue: Obj) {
-        writeCallback?.execute(scope.copy(Arguments(ObjString(name), newValue)))
+        writeCallback?.execute(scope.createChildScope(Arguments(ObjString(name), newValue)))
             ?: super.writeField(scope, name, newValue)
     }
 
+    override suspend fun getAt(scope: Scope, index: Obj): Obj {
+        return readCallback?.execute(scope.createChildScope(Arguments(index)))
+            ?: super.getAt(scope, index)
+    }
+
+    override suspend fun putAt(scope: Scope, index: Obj, newValue: Obj) {
+        writeCallback?.execute(scope.createChildScope(Arguments(index, newValue)))
+            ?: super.putAt(scope, index, newValue)
+    }
+
     companion object {
 
         suspend fun create(scope: Scope, builder: Statement): ObjDynamic {
             val delegate = ObjDynamic()
             val context = ObjDynamicContext(delegate)
-            builder.execute(scope.copy(newThisObj = context))
+            builder.execute(scope.createChildScope(newThisObj = context))
             return delegate
         }
 
-        val type = object : ObjClass("Delegate") {}
+        val type = object : ObjClass("Delegate") {}.apply {
+//            addClassConst("IndexGetName", operatorGetName)
+        }
     }
 
 }

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

@@ -28,9 +28,9 @@ import net.sergeych.synctools.withLock
 import kotlin.contracts.ExperimentalContracts
 
 /**
- * note on [getStackTrace]. If [useStackTrace] is not null, it is used instead. Otherwise, it is calculated
- * from the current scope which is treated as exception scope. It is used to restore serialized
- * exception with stack trace; the scope of the de-serialized exception is not valid
+ * Note on [getStackTrace]. If [useStackTrace] is not null, it is used instead. Otherwise, it is calculated
+ * from the current scope, which is treated as an exception scope. It is used to restore a serialized
+ * exception with stack trace; the scope of the deserialized exception is not valid
  * for stack unwinding.
  */
 open class ObjException(
@@ -127,7 +127,7 @@ open class ObjException(
             }
         }
 
-        val Root = ExceptionClass("Throwable").apply {
+        val Root = ExceptionClass("Exception").apply {
             addConst("message", statement {
                 (thisObj as ObjException).message.toObj()
             })

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

@@ -58,7 +58,7 @@ class ObjFlowBuilder(val output: SendChannel<Obj>) : Obj() {
 private fun createLyngFlowInput(scope: Scope, producer: Statement): ReceiveChannel<Obj> {
     val channel = Channel<Obj>(Channel.RENDEZVOUS)
     val builder = ObjFlowBuilder(channel)
-    val builderScope = scope.copy(newThisObj = builder)
+    val builderScope = scope.createChildScope(newThisObj = builder)
     globalLaunch {
         try {
             producer.execute(builderScope)

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

@@ -32,7 +32,7 @@ class ObjInstanceClass(val name: String) : ObjClass(name) {
         val actualSize = constructorMeta?.params?.size ?: 0
         if (args.size > actualSize)
             scope.raiseIllegalArgument("constructor $name has only $actualSize but serialized version has ${args.size}")
-        val newScope = scope.copy(args = Arguments(args))
+        val newScope = scope.createChildScope(args = Arguments(args))
         return (callOn(newScope) as ObjInstance).apply {
             deserializeStateVars(scope, decoder)
             invokeInstanceMethod(scope, "onDeserialized") { ObjVoid }

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

@@ -93,7 +93,7 @@ val ObjIterable by lazy {
             val fn = requiredArg<Statement>(0)
             while (it.invokeInstanceMethod(this, "hasNext").toBool()) {
                 val x = it.invokeInstanceMethod(this, "next")
-                fn.execute(this.copy(Arguments(listOf(x))))
+                fn.execute(this.createChildScope(Arguments(listOf(x))))
             }
             ObjVoid
         }

lynglib/src/commonMain/kotlin/net/sergeych/lyng/pacman/ImportProvider.kt

@@ -71,7 +71,7 @@ abstract class ImportProvider(
             newModuleAt(pos).also {
                 it.eval("import lyng.stdlib\n")
             }
-        }.copy()
+        }.createChildScope()
 }
 
 

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

@@ -60,7 +60,7 @@ abstract class Statement(
         val type = ObjClass("Callable")
     }
 
-    suspend fun call(scope: Scope, vararg args: Obj) = execute(scope.copy(args =  Arguments(*args)))
+    suspend fun call(scope: Scope, vararg args: Obj) = execute(scope.createChildScope(args =  Arguments(*args)))
 
 }
 

lynglib/src/commonMain/kotlin/net/sergeych/lynon/BitList.kt

@@ -17,8 +17,10 @@
 
 package net.sergeych.lynon
 
+import kotlin.math.min
+
 @Suppress("unused")
-interface BitList {
+interface BitList: Comparable<BitList> {
     operator fun get(bitIndex: Long): Int
     operator fun set(bitIndex: Long,value: Int)
     val size: Long
@@ -31,6 +33,22 @@ interface BitList {
             if( index < size) this@BitList[index++]
             else null
     }
+
+    override fun compareTo(other: BitList): Int {
+        val m = min(size, other.size)
+        for( i in 0 ..< m) {
+            val a = this[i]
+            val b = other[i]
+            when {
+                a < b -> return -1
+                a > b -> return 1
+            }
+        }
+        if( size > other.size) return 1
+        if( size < other.size) return -1
+        return 0
+    }
+
 }
 
 fun bitListOf(vararg bits: Int): BitList {

lynglib/src/commonMain/kotlin/net/sergeych/lynon/LynonDecoder.kt

@@ -91,14 +91,15 @@ open class LynonDecoder(val bin: BitInput, val settings: LynonSettings = LynonSe
             val type = LynonType.entries[getBitsAsInt(4)]
             val list = mutableListOf<Obj>()
             val objClass = if (type == LynonType.Other)
-                decodeClassObj(scope).also { println("detected class obj: $it") }
+                decodeClassObj(scope)//.also { println("detected class obj: $it") }
             else type.objClass
             val size = fixedSize ?: bin.unpackUnsigned().toInt()
-            println("detected homogenous list type $type, $size items")
+//            println("detected homogenous list type $type, $size items")
             for (i in 0..<size) {
-                list += decodeObject(scope, objClass, type).also {
-                    println("decoded: $it")
-                }
+                list += decodeObject(scope, objClass, type)
+                //.also {
+//                    println("decoded: $it")
+//                }
             }
             list
         } else {

lynglib/src/commonMain/kotlin/net/sergeych/lynon/MemoryBitOutput.kt

@@ -17,13 +17,18 @@
 
 package net.sergeych.lynon
 
+import kotlinx.serialization.Serializable
 import kotlin.math.min
 
 /**
  * BitList implementation as fixed suze array of bits; indexing works exactly same as if
  * [MemoryBitInput] is used with [MemoryBitInput.getBit]. See [MemoryBitOutput] for
  * bits order and more information.
+ *
+ * It is [BitList] - comparable, and provides valid [hashCode] and [equals], so it could
+ * also be used as a key in maps.
  */
+@Serializable
 class BitArray(val bytes: UByteArray, val lastByteBits: Int) : BitList {
 
     val bytesSize: Int get() = bytes.size
@@ -73,7 +78,21 @@ class BitArray(val bytes: UByteArray, val lastByteBits: Int) : BitList {
     fun asByteArray(): ByteArray = bytes.asByteArray()
 
     @Suppress("unused")
-    fun asUbyteArray(): UByteArray = bytes
+    fun asUByteArray(): UByteArray = bytes
+
+    override fun equals(other: Any?): Boolean {
+        return when(other) {
+            is BitArray ->
+                // important: size must match as trailing zero bits will generate false eq otherwise:
+                size == other.size && bytes contentEquals other.bytes
+            is BitList -> compareTo(other) == 0
+            else -> false
+        }
+    }
+
+    override fun hashCode(): Int {
+        return bytes.contentHashCode()
+    }
 
     companion object {
 

lynglib/src/commonMain/kotlin/net/sergeych/lynon/bit_tools.kt

@@ -17,6 +17,8 @@
 
 package net.sergeych.lynon
 
+import kotlin.random.Random
+
 /**
  * Hoq many tetrades needed to store the value. It is faster to use this function
  * than to use sizeInBits
@@ -35,7 +37,7 @@ fun sizeInTetrades(value: ULong): Int {
 }
 
 /**
- * How many bits needed to store the value. Size for 0 is 1,
+ * Calculates ow many bits needed to store the value. Size for 0, for example, is 1.
  */
 @Suppress("unused")
 fun sizeInBits(value: ULong): Int {
@@ -49,4 +51,21 @@ fun sizeInBits(value: ULong): Int {
     return size
 }
 
-fun sizeInBits(value: Int): Int = sizeInBits(value.toULong())
+fun sizeInBits(value: Int): Int = sizeInBits(value.toULong())
+
+/**
+ * Generates a random BitArray of the specified size. Important: this is
+ * __not cryptographically secure__. Use random from [crypto2](https://gitea.sergeych.net/sergeych/crypto2),
+ * `randomInt()`, `randomUBytes()`, etc., for cryptographically secure random data.
+ *
+ * @param sizeInBits The size of the BitArray to generate in bits.
+ * @return A BitArray of the specified size filled with random bits.
+ */
+@Suppress("unused")
+fun BitArray.Companion.random(sizeInBits: Int): BitArray {
+    val result = BitArray.withBitSize(sizeInBits.toLong())
+    for (i in 0..<sizeInBits) {
+        result[i.toLong()] = Random.nextInt() and 1
+    }
+    return result
+}

lynglib/src/commonMain/kotlin/net/sergeych/lynon/huffman.kt

@@ -18,7 +18,6 @@
 package net.sergeych.lynon
 
 import net.sergeych.collections.SortedList
-import net.sergeych.lynon.Huffman.Alphabet
 
 
 /**
@@ -285,7 +284,7 @@ object Huffman {
 
     fun <T>decompress(bin: BitInput,alphabet: Alphabet<T>): UByteArray {
         val codes = deserializeCanonicCodes(bin, alphabet)
-        return decompressUsingCodes(bin, codes, alphabet).asUbyteArray()
+        return decompressUsingCodes(bin, codes, alphabet).asUByteArray()
     }
 
 }

lynglib/src/commonMain/kotlin/net/sergeych/lynon/lzw.kt

@@ -21,7 +21,9 @@ import net.sergeych.bintools.ByteChunk
 import kotlin.math.roundToInt
 
 /**
- * LZW lightweight pure kotlin compression.
+ * LZW lightweight pure kotlin compression. LZW works with but streams [BitInput] and [BitOutput]
+ * to be used effectively in Lynon or other bit-grained formats. To safely comress byte arresy and
+ * strings without boilerplate use [lzwCompress], [lzwDecompress], [lzwCompressUtf8] and [lzwDecompressUtf8].
  */
 object LZW {
 
@@ -30,8 +32,10 @@ object LZW {
     val MAX_DICT_SIZE = (STOP_CODE * 0.92).roundToInt()
 
 
-    fun compress(input: ByteArray, bitOutput: BitOutput)
-        = compress(input.asUByteArray(), bitOutput)
+    /**
+     * Compress a byte array using LZW algorithm writing the result to [bitOutput]
+     */
+    fun compress(input: ByteArray, bitOutput: BitOutput) = compress(input.asUByteArray(), bitOutput)
 
     /**
      * Compresses the input string using LZW algorithm
@@ -139,7 +143,42 @@ object LZW {
     }
 }
 
-
 private operator fun ByteChunk.plus(byte: UByte): ByteChunk {
     return ByteChunk(data + byte)
 }
+
+/**
+ * Safely compress binary byte data using the LZW algorithm. This can use up to one byte more space than
+ * with [LZW.compress] and [BitOutput] but you often need byte array operations. Source data size is also
+ * encoded to prevent file-bomb-like attacks. Note that content protection is not included (we assume
+ * LZW is robust).
+ * @param source the data to compress
+ */
+fun lzwCompress(source: UByteArray): UByteArray {
+    val out = MemoryBitOutput()
+    out.packUnsigned(source.size.toULong())
+    LZW.compress(source, out)
+    return out.toBitArray().asUByteArray()
+}
+
+/**
+ * Safely decompress data compressed with [lzwCompress], checking size. Contect checks are not implemented
+ * here as we assume LZW is robust.
+ * @param packed the compressed data
+ * @throws DecompressionException if something goes wrong, like size mismatch or bad compressed data
+ */
+fun lzwDecompress(packed: UByteArray): UByteArray {
+    val inp = MemoryBitInput(packed, 8)
+    val size = inp.unpackUnsigned()
+    return LZW.decompress(inp, size.toInt())
+}
+
+/**
+ * Compress a text using utf-8 encoding and [lzwCompress]
+ */
+fun lzwCompressUtf8(text: String) = lzwCompress(text.encodeToByteArray().toUByteArray())
+
+/**
+ * Decompress a text compressed with [lzwCompressUtf8]. See also [lzwDecompress]
+ */
+fun lzwDecompressUtf8(packed: UByteArray): String = lzwDecompress(packed).asByteArray().decodeToString()

lynglib/src/commonMain/kotlin/net/sergeych/lynon/packer.kt

@@ -56,7 +56,7 @@ object ObjLynonClass : ObjClass("Lynon") {
 @Suppress("unused")
 suspend fun lynonEncodeAny(scope: Scope, value: Obj): UByteArray =
     (ObjLynonClass.encodeAny(scope, value))
-        .bitArray.asUbyteArray()
+        .bitArray.asUByteArray()
 
 @Suppress("unused")
 suspend fun lynonDecodeAny(scope: Scope, encoded: UByteArray): Obj =

lynglib/src/commonTest/kotlin/OOTest.kt

@@ -107,6 +107,26 @@ class OOTest {
         """.trimIndent())
     }
 
+    @Test
+    fun testDynamicIndexAccess() = runTest {
+        eval("""
+            val store = Map()
+            val accessor = dynamic {
+                get { name ->
+                    store[name]
+                }
+                set { name, value ->
+                    store[name] = value
+                }
+            }
+           assertEquals(null, accessor["foo"])
+           assertEquals(null, accessor.foo)
+           accessor["foo"] = "bar"
+           assertEquals("bar", accessor["foo"])
+           assertEquals("bar", accessor.foo)
+        """.trimIndent())
+    }
+
     @Test
     fun testMultilineConstructor() = runTest {
         eval("""
@@ -117,4 +137,53 @@ class OOTest {
             assertEquals(Point(1,2), Point(1,2) )
             """.trimIndent())
     }
+
+    @Test
+    fun testDynamicClass() = runTest {
+        eval("""
+            
+            fun getContract(contractName) {
+                dynamic {
+                    get { name ->
+                        println("Call: %s.%s"(contractName,name))
+                    }
+                }
+            }
+            getContract("foo").bar
+       """)
+    }
+
+    @Test
+    fun testDynamicClassReturn2() = runTest {
+        // todo: should work without extra parenthesis
+        // see below
+        eval("""
+            
+            fun getContract(contractName) {
+                println("1")
+                dynamic {
+                    get { name ->
+                        println("innrer %s.%s"(contractName,name))
+                        { args... ->
+                            if( name == "bar" ) args.sum() else null
+                        }
+                    }
+                }
+            }
+            
+            val cc = dynamic {
+                get { name ->
+                    println("Call cc %s"(name))
+                    getContract(name)
+                }
+            }
+            
+            val x = cc.foo.bar
+            println(x)
+            x(1,2,3)
+            assertEquals(6, x(1,2,3))
+            //               v  HERE    v
+            assertEquals(15, cc.foo.bar(10,2,3))
+       """)
+    }
 }

lynglib/src/commonTest/kotlin/ScriptTest.kt

@@ -3170,6 +3170,34 @@ class ScriptTest {
         )
     }
 
+    @Test
+    fun testExceptionSerializationPlain() = runTest {
+        eval(
+            """
+                import lyng.serialization
+                val x = [1,2,3]
+                assertEquals( "[1,2,3]", x.toString() )
+                try {    
+                    throw "test"
+                }
+                catch (e) {
+                    println(e.stackTrace)
+                    e.printStackTrace()
+                    val coded = Lynon.encode(e)
+                    val decoded = Lynon.decode(coded)
+                    assertEquals( e::class, decoded::class )
+                    assertEquals( e.stackTrace, decoded.stackTrace )
+                    assertEquals( e.message, decoded.message )
+                    println("-------------------- e")
+                    println(e.toString())
+                    println("-------------------- dee")
+                    println(decoded.toString())
+                    assertEquals( e.toString(), decoded.toString() )
+                }
+                """.trimIndent()
+        )
+    }
+
     @Test
     fun testThisInClosure() = runTest {
         eval(
@@ -3287,25 +3315,25 @@ class ScriptTest {
 
 
     //    @Test
-    fun testMinimumOptimization() = runTest {
-        val x = Scope().eval(
-            """
-                fun naiveCountHappyNumbers() {
-                    var count = 0
-                    for( n1 in 0..9 )
-                        for( n2 in 0..9 )
-                            for( n3 in 0..9 )
-                                for( n4 in 0..9 )
-                                    for( n5 in 0..9 )
-                                        for( n6 in 0..9 )
-                                            if( n1 + n2 + n3 == n4 + n5 + n6 ) count++
-                    count
-                }
-                naiveCountHappyNumbers()
-            """.trimIndent()
-        ).toInt()
-        assertEquals(55252, x)
-    }
+//    fun testMinimumOptimization() = runTest {
+//        val x = Scope().eval(
+//            """
+//                fun naiveCountHappyNumbers() {
+//                    var count = 0
+//                    for( n1 in 0..9 )
+//                        for( n2 in 0..9 )
+//                            for( n3 in 0..9 )
+//                                for( n4 in 0..9 )
+//                                    for( n5 in 0..9 )
+//                                        for( n6 in 0..9 )
+//                                            if( n1 + n2 + n3 == n4 + n5 + n6 ) count++
+//                    count
+//                }
+//                naiveCountHappyNumbers()
+//            """.trimIndent()
+//        ).toInt()
+//        assertEquals(55252, x)
+//    }
 
     @Test
     fun testRegex1() = runTest {

lynglib/src/jvmTest/kotlin/LynonTests.kt

@@ -397,6 +397,13 @@ class LynonTests {
         assertEquals(original, decompressed)
     }
 
+    @Test
+    fun testCompressed() {
+        val compressed = lzwCompressUtf8(original)
+        println("${compressed.size/original.encodeToByteArray().size.toDouble()} compression ratio")
+        assertEquals(original, lzwDecompressUtf8(compressed))
+    }
+
     @Test
     fun testTinyBits() {
         var a0 = TinyBits()

lynglib/src/jvmTest/kotlin/OtherTests.kt

@@ -22,7 +22,10 @@ import net.sergeych.lyng.Source
 import net.sergeych.lyng.eval
 import net.sergeych.lyng.pacman.InlineSourcesImportProvider
 import net.sergeych.lyng.toSource
+import net.sergeych.lynon.BitArray
+import net.sergeych.lynon.BitList
 import kotlin.test.Test
+import kotlin.test.assertNotEquals
 
 class OtherTests {
     @Test
@@ -67,4 +70,33 @@ class OtherTests {
         Unit
     }
 
+    @Test
+    fun testBitArrayEqAndHash() {
+
+        val b1 = BitArray.ofBits(1, 0, 1, 1)
+        val b11 = BitArray.ofBits(1, 0, 1, 1)
+        val b2 = BitArray.ofBits(1, 1, 1, 1)
+        val b3 = BitArray.ofBits(1, 0, 1, 1, 0)
+
+        assert( b3 > b1 )
+        assert( b2 > b1)
+        assert( b11.compareTo(b1) == 0)
+
+        assertEquals(b1, b11)
+        assertNotEquals(b1, b2)
+        assertNotEquals(b1, b3)
+
+        assert( b1.hashCode() == b11.hashCode() )
+
+        val x = mutableMapOf<BitList,String>()
+        x[b1] = "wrong"
+        x[b11] = "OK"
+        x[b2] = "other"
+
+        assertEquals("OK", x[b11])
+        assertEquals("OK", x[b1])
+        assertEquals("other", x[b2])
+
+    }
+
 }