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 }}
-

.gitignore

@@ -14,3 +14,4 @@ xcuserdata
 .gigaide
 /kotlin-js-store/yarn.lock
 /test.lyng
+/sample_texts/1.txt.gz

NOTICE

@@ -0,0 +1,3 @@
+The Lyng programming language.
+Copyright (c) 2024-2025 Sergey Chernov real.sergeych@gmail.com
+

README.md

@@ -2,7 +2,7 @@
 
 A KMP library and a standalone interpreter
 
-- simple, compact, intuitive and elegant modern code style:
+- simple, compact, intuitive and elegant modern code:
 
 ```
 class Point(x,y) {
@@ -15,23 +15,31 @@ fun swapEnds(first, args..., last, f) {
 } 
 ```
 
-- extremely simple Kotlin integration on any platform
+- extremely simple Kotlin integration on any platform (JVM, JS, WasmJS, Lunux, MacOS, iOS, Windows)
 - 100% secure: no access to any API you didn't explicitly provide
-- 100% coroutines! Every function/script is a coroutine, it does not block the thread, no async/await/suspend keyword garbage:
+- 100% coroutines! Every function/script is a coroutine, it does not block the thread, no async/await/suspend keyword garbage, see [parallelism]
 
 ```
+  val deferred = launch {
     delay(1.5) // coroutine is delayed for 1.5s, thread is not blocked!
+    "done"
+  }
+  // ...
+  // suspend current coroutine, no thread is blocked again,
+  // and wait for deferred to return something:
+  assertEquals("donw", deferred.await())
 ```
 and it is multithreaded on platforms supporting it (automatically, no code changes required, just
-`launch` more coroutines and they will be executed concurrently if possible)/
+`launch` more coroutines and they will be executed concurrently if possible). See [parallelism]
 
 - functional style and OOP together, multiple inheritance, implementing interfaces for existing classes, writing extensions.
-- Any unicode letters can be used as identifiers: `assert( sin(π/2) == 1 )`.
+- Any Unicode letters can be used as identifiers: `assert( sin(π/2) == 1 )`.
 
  ## Resources: 
 
 - [introduction and tutorial](docs/tutorial.md) - start here please
 - [Samples directory](docs/samples)
+- [Books directory](docs)
 
 ## Integration in Kotlin multiplatform
 
@@ -75,33 +83,37 @@ runBlocking {
 
 ### Exchanging information
 
-Script is executed over some `Context`. Create instance of the context,
-add your specific vars and functions to it, an call over it:
+Script is executed over some `Scope`. Create instance,
+add your specific vars and functions to it, and call:
 
 ```kotlin
-import new.sergeych.lyng.* 
+
+import com.sun.source.tree.Scope
+import new.sergeych.lyng.*
 
 // simple function
-val context = Context().apply {
-    addFn("addArgs") {
+val scope = Script.newScope().apply {
+    addFn("sumOf") {
         var sum = 0.0
-        for( a in args) sum += a.toDouble()
+        for (a in args) sum += a.toDouble()
         ObjReal(sum)
     }
     addConst("LIGHT_SPEED", ObjReal(299_792_458.0))
-    
+
     // callback back to kotlin to some suspend fn, for example::
     // suspend fun doSomeWork(text: String): Int
     addFn("doSomeWork") {
         // this _is_ a suspend lambda, we can call suspend function,
-        // and it won't consume the thread:
-        doSomeWork(args[0].toString()).toObj()
+        // and it won't consume the thread.
+        // note that in kotlin handler, `args` is a list of `Obj` arguments
+        // and return value from this lambda should be Obj too:
+        doSomeWork(args[0]).toObj()
     }
 }
 // adding constant:
-context.eval("addArgs(1,2,3)") // <- 6
+scope.eval("sumOf(1,2,3)") // <- 6
 ```
-Note that the context stores all changes in it so you can make calls on a single context to preserve state between calls.
+Note that the scope stores all changes in it so you can make calls on a single scope to preserve state between calls.
 
 ## Why? 
 
@@ -117,12 +129,24 @@ Designed to add scripting to kotlin multiplatform application in easy and effici
 
 - Javascript, WasmJS, native, JVM, android - batteries included.
 - dynamic types in most elegant and concise way
-- async, 100% coroutines, supports multiple cores where platofrm supports thread
+- async, 100% coroutines, supports multiple cores where platform supports thread
 - good for functional an object-oriented style
 
 # Language Roadmap
 
-## v1.0.0
+```mermaid
+flowchart
+    v0([the idea])
+    v1([v1: make it happen])
+    v2([v1.5: testmake it fasted and rich featured])
+    v3([v2: ideal script language])
+    v0 --code MVP--> v1
+    v1 --refine and extend--> v2
+    v2 -- optimize --> v3
+    
+```
+
+## v1.0.0 "Make it happen"
 
 Planned autumn 2025. Complete dynamic language with sufficient standard library:
 
@@ -137,29 +161,41 @@ Ready features:
 - [x] exception handling: throw, try-catch-finally, exception classes.
 - [x] multiplatform maven publication
 - [x] documentation for the current state
+- [x] maps, sets and sequences (flows?)
+- [x] modules
+- [x] string formatting and tools
+- [x] launch, deferred, CompletableDeferred, Mutex, etc.
+- [x] multiline strings
+- [x] typesafe bit-effective serialization
+- [x] compression/decompression (integrated in serialization)
+- [x] dynamic fields
+- [x] function annotations
+- [x] better stack reporting
 
-Under way: 
+###  Under way: 
 
-- [ ] maps, sets and sequences (flows?)
-- [ ] regular exceptions
-- [ ] modules
-- [ ] string interpolation and more string tools
+- [ ] regular exceptions + extended `when`
 - [ ] multiple inheritance for user classes
-- [ ] launch, deferred, coroutineScope, mutex, etc.
 - [ ] site with integrated interpreter to give a try
 - [ ] kotlin part public API good docs, integration focused
-- [ ] better stack reporting
 
-## v1.1+
+## plan: v1.0 - v1.5 "Rich and stable"
+
+Estimated spring of 2026
 
 Planned features.
 
 - [ ] type specifications
+- [ ] language server or compose-based lyng-aware editor
 - [ ] source docs and maybe lyng.md to a standard
-- [ ] moacro-style kotlin integration or something else to simplify it
+- [ ] metadata first class access from lyng
 
-Further
+## After 1.5 "Ideal scripting"
+
+Estimated winter 2027
 
 - [ ] client with GUI support based on compose multiplatform somehow
-- [ ] notebook - style workbooks with graphs, formulaes, etc.
-- [ ] language server or compose-based lyng-aware editor
+- [ ] notebook - style workbooks with graphs, formulae, etc.
+- [ ] aggressive optimizations
+
+[parallelism]: docs/parallelism.md

bin/local_jrelease

@@ -0,0 +1,31 @@
+#!/bin/bash
+
+#
+# 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.
+#
+#
+
+set -e
+
+root=./lyng/build/install/lyng-jvm/
+
+./gradlew :lyng:installJvmDist
+#strip $file
+#upx   $file
+rm -rf ~/bin/jlyng-jvm || true
+rm ~/bin/jlyng 2>/dev/null || true
+mkdir -p ~/bin/jlyng-jvm
+cp -R $root ~/bin/jlyng-jvm
+ln -s ~/bin/jlyng-jvm/lyng-jvm/bin/lyng ~/bin/jlyng

bin/local_release

@@ -1,5 +1,22 @@
 #!/bin/bash
 
+#
+# 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.
+#
+#
+
 set -e
 
 file=./lyng/build/bin/linuxX64/releaseExecutable/lyng.kexe

build.gradle.kts

@@ -1,3 +1,20 @@
+/*
+ * 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.
+ *
+ */
+
 plugins {
     alias(libs.plugins.androidLibrary) apply false
     alias(libs.plugins.kotlinMultiplatform) apply  false

docs/Array.md

@@ -0,0 +1,37 @@
+# Array
+
+It's an interface if the [Collection] that provides indexing access, like `array[3] = 0`.
+Array therefore implements [Iterable] too. The well known implementatino of the `Array` is
+[List].
+
+Array adds the following methods:
+
+## Binary search
+
+When applied to sorted arrays, binary search allow to quicly find an index of the element in the array, or where to insert it to keep order:
+
+    val coll = [1,2,3,4,5]
+    assertEquals( 2, coll.binarySearch(3) )
+    assertEquals( 0, coll.binarySearch(1) )
+    assertEquals( 4, coll.binarySearch(5) )
+
+    val src = (1..50).toList().shuffled()
+    val result = []
+    for( x in src ) {
+        val i = result.binarySearch(x)
+        assert( i < 0 )
+        result.insertAt(-i-1, x)
+    }
+    assertEquals( src.sorted(), result )
+    >>> void
+
+So `binarySearch(x)` returns:
+
+- index of `x`, a non-negative number
+- negative: `x` not found, but if inserted at position `-returnedValue-1` will leave array sorted.
+
+To pre-sort and array use `Iterable.sorted*` or in-place `List.sort*` families, see [List] and [Iterable] docs.
+
+[Collection]: Collection.md
+[Iterable]: Iterable.md
+[List]: List.md

docs/Buffer.md

@@ -0,0 +1,151 @@
+# Binary `Buffer`
+
+Buffers are effective unsigned byte arrays of fixed size. Buffers content is mutable,
+unlike its size. Buffers are comparable and implement [Array], thus [Collection] and [Iterable]. Buffer iterators return
+its contents as unsigned bytes converted to `Int`
+
+Buffers needs to be imported with `import lyng.buffer`:
+
+    import lyng.buffer
+
+    assertEquals(5, Buffer("Hello").size)
+    >>> void
+
+Buffer is _immutable_, there is a `MutableBuffer` with same interface but mutable.
+
+## Constructing
+
+There are a lo of ways to construct a buffer:
+
+    import lyng.buffer
+    
+    // from string using utf8 encoding:
+    assertEquals( 5, Buffer("hello").size )
+
+    // from bytes, e.g. integers in range 0..255
+    assertEquals( 255, Buffer(1,2,3,255).last() )
+
+    // from whatever iterable that produces bytes, e.g.
+    // integers in 0..255 range:
+    assertEquals( 129, Buffer([1,2,129]).last() )
+
+    // Empty buffer of fixed size:
+    assertEquals(100, Buffer(100).size)
+    assertEquals(0, Buffer(100)[0])
+
+    // Note that you can use list iteral to create buffer with 1 byte:
+    assertEquals(1, Buffer([100]).size)
+    assertEquals(100, Buffer([100])[0])
+
+    >>> void
+
+## Accessing and modifying
+
+Buffer implement [Array] and therefore can be accessed, and `MutableBuffers` also modified:
+
+    import lyng.buffer
+    val b1 = Buffer( 1, 2, 3)
+    assertEquals( 2, b1[1] )
+
+    val b2 = b1.toMutable()
+    assertEquals( 2, b1[1] )
+    b2[1]++
+    b2[0] = 100
+    assertEquals( Buffer(100, 3, 3), b2)
+
+    // b2 is a mutable copy so b1 has not been changed:
+    assertEquals( Buffer(1, 2, 3), b1)
+
+    >>> void
+
+Buffer provides concatenation with another Buffer:
+
+    import lyng.buffer
+    val b = Buffer(101, 102)
+    assertEquals( Buffer(101, 102, 1, 2), b + [1,2])
+    >>> void
+
+Please note that indexed bytes are _readonly projection_, e.g. you can't modify these with
+
+## Comparing
+
+Buffers are comparable with other buffers (and notice there are _mutable_ buffers, bu default buffers ar _immutable_):
+
+    import lyng.buffer
+    val b1 = Buffer(1, 2, 3)
+    val b2 = Buffer(1, 2, 3)
+    val b3 = MutableBuffer(b2)
+    
+    b3[0] = 101
+
+    assert( b3 > b1 )
+    assert( b2 == b1 )
+    // longer string with same prefix is considered bigger:
+    assert( b2 + "!".characters() > b1 )
+    // note that characters() provide Iterable of characters that 
+    // can be concatenated to Buffer
+
+    >>> void
+
+## Slicing
+
+As with [List], it is possible to use ranges as indexes to slice a Buffer:
+
+    import lyng.buffer
+
+    val a = Buffer( 100, 101, 102, 103, 104, 105 )
+    assertEquals( a[ 0..1 ], Buffer(100, 101) )
+    assertEquals( a[ 0 ..< 2 ], Buffer(100, 101) )
+    assertEquals( a[  ..< 2 ], Buffer(100, 101) )
+    assertEquals( a[  4.. ], Buffer(104, 105) )
+    assertEquals( a[  2..3 ], Buffer(102, 103) )
+
+    >>> void
+
+## Encoding
+
+You can encode `String` to buffer using buffer constructor, as was shown. Also, buffer supports out of the box base64 (
+which is used in `toString`) and hex encoding:
+
+    import lyng.buffer
+    
+    // to UTF8 and back:
+    val b = Buffer("hello")
+    assertEquals( "hello", b.decodeUtf8() )
+    
+    // to base64 and back:
+    assertEquals( b, Buffer.decodeBase64(b.base64) )
+    assertEquals( b, Buffer.decodeHex(b.hex) )
+    >>> void
+
+## Members
+
+| name                       | meaning                                 | type          |
+|----------------------------|-----------------------------------------|---------------|
+| `size`                     | size                                    | Int           |
+| `decodeUtf8`               | decode to String using UTF8 rules       | Any           |
+| `+`                        | buffer concatenation                    | Any           |
+| `toMutable()`              | create a mutable copy                   | MutableBuffer |
+| `hex`                      | encode to hex strign                    | String        |
+| `Buffer.decodeHex(hexStr)  | decode hex string                       | Buffer        |
+| `base64`                   | encode to base64 (url flavor) (2)       | String        |
+| `Buffer.decodeBase64(str)` | decode base64 to new Buffer (2)         | Buffer        |
+| `toBitInput()`             | create bit input from a byte buffer (3) |               |
+
+(1)
+: optimized implementation that override `Iterable` one
+
+(2)
+: base64url alphabet is used without trailing '=', which allows string to be used in URI without escaping. Note that
+decoding supports both traditional and URL alphabets automatically, and ignores filling `=` characters. Base64URL is
+well known and mentioned in the internet, for example, [here](https://base64.guru/standards/base64url).
+
+(3)
+: `BitInput` is a bit buffer that is used, for example, in [Lynon.decode](serialization.md)
+
+Also, it inherits methods from [Iterable] and [Array].
+
+
+[Range]: Range.md
+
+[Iterable]: Iterable.md

docs/Collection.md

@@ -6,6 +6,12 @@ Is a [Iterable] with known `size`, a finite [Iterable]:
         val size
     }
 
+| name                   | description                                          |
+|------------------------|------------------------------------------------------|
+
+(1)
+: `comparator(a,b)` should return -1 if `a < b`, +1 if `a > b` or zero.
+
 See [List], [Set] and [Iterable]
 
 [Iterable]: Iterable.md

docs/Iterable.md

@@ -1,5 +1,15 @@
 # Iterable interface
 
+The interface for anything that can be iterated, e.g. finite or infinite ordered set of data that can be accessed
+sequentially. Almost any data container in `Lyng` implements it: `List`, `Set`, `Buffer`, `RingBuffer`, `BitBuffer`,
+`Range` and many others are `Iterable`, also `Collection` and `Array` interfaces inherit it.
+
+`Map` and `String` have `Iterable` members to access its contents too.
+
+Please see also [Collection] interface: many iterables are also collections, and it adds important features.
+
+## Definition:
+
 Iterable is a class that provides function that creates _the iterator_:
 
     class Iterable {
@@ -17,9 +27,85 @@ Iterator itself is a simple interface that should provide only to method:
 
 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:
+Having `Iterable` in base classes allows to use it in for loop. Also, each `Iterable` has some utility functions
+available, for example
 
-## Instance methods
+    val r = 1..10  // Range is Iterable!  
+    assertEquals( [9,10], r.takeLast(2).toList() )
+    assertEquals( [1,2,3], r.take(3).toList() )
+    assertEquals( [9,10], r.drop(8).toList() )
+    assertEquals( [1,2], r.dropLast(8).toList() )
+    >>> void
+
+## joinToString
+
+This methods convert any iterable to a string joining string representation of each element, optionally transforming it
+and joining using specified suffix.
+
+    Iterable.joinToString(suffux=' ', transform=null)
+
+- if `Iterable` `isEmpty`, the empty string `""` is returned.
+- `suffix` is inserted between items when there are more than one.
+- `transform` of specified is applied to each element, otherwise its `toString()` method is used.
+
+Here is the sample:
+
+    assertEquals( (1..3).joinToString(), "1 2 3")
+    assertEquals( (1..3).joinToString(":"), "1:2:3")
+    assertEquals( (1..3).joinToString { it * 10 }, "10 20 30")
+    >>> void
+
+## `sum` and `sumBy`
+
+These, again, does the thing:
+
+    assertEquals( 6, [1,2,3].sum() )
+    assertEquals( 12, [1,2,3].sumOf { it*2 } )
+
+    // sum of empty collections is null:
+    assertEquals( null, [].sum() )
+    assertEquals( null, [].sumOf { 2*it } )
+
+    >>> void
+
+## Instance methods:
+
+| fun/method             | description                                                                     |
+|------------------------|---------------------------------------------------------------------------------|
+| toList()               | create a list from iterable                                                     |
+| toSet()                | create a set from iterable                                                      |
+| contains(i)            | check that iterable contains `i`                                                |
+| `i in iterator`        | same as `contains(i)`                                                           |
+| isEmpty()              | check iterable is empty                                                         |
+| forEach(f)             | call f for each element                                                         |
+| toMap()                | create a map from list of key-value pairs (arrays of 2 items or like)           |
+| map(f)                 | create a list of values returned by `f` called for each element of the iterable |
+| indexOf(i)             | return index if the first encounter of i or a negative value if not found       |
+| associateBy(kf)        | create a map where keys are returned by kf that will be called for each element |
+| first                  | first element (1)                                                               |
+| last                   | last element (1)                                                                |
+| take(n)                | return [Iterable] of up to n first elements                                     |
+| taleLast(n)            | return [Iterable] of up to n last elements                                      |
+| drop(n)                | return new [Iterable] without first n elements                                  |
+| dropLast(n)            | return new [Iterable] without last n elements                                   |
+| sum()                  | return sum of the collection applying `+` to its elements (3)                   |
+| sumOf(predicate)       | sum of the modified collection items (3)                                        |
+| sorted()               | return [List] with collection items sorted naturally                            |
+| sortedWith(comparator) | sort using a comparator that compares elements (1)                              |
+| sortedBy(predicate)    | sort by comparing results of the predicate function                             |
+| joinToString(s,t)      | convert iterable to string, see (2)                                             |
+| reversed()             | create a list containing items from this in reverse order                       |
+| shuffled()             | create a listof shiffled elements                                               |
+
+(1)
+: throws `NoSuchElementException` if there is no such element
+
+(2)
+: `joinToString(suffix=" ",transform=null)`: suffix is inserted between items if there are more than one, trasnfom is
+optional function applied to each item that must return result string for an item, otherwise `item.toString()` is used.
+
+(3)
+: sum of empty collection is `null`
 
     fun Iterable.toList(): List
     fun Iterable.toSet(): Set
@@ -28,9 +114,9 @@ Having `Iterable` in base classes allows to use it in for loop. Also, each `Iter
     fun Iterable.isEmpty(element): Bool
     fun Iterable.forEach(block: (Any?)->Void ): Void
     fun Iterable.map(block: (Any?)->Void ): List
-    
+    fun Iterable.associateBy( keyMaker: (Any?)->Any): Map
 
-## Abstract methods
+## Abstract methods:
 
     fun iterator(): Iterator
 
@@ -42,7 +128,14 @@ Creates a list by iterating to the end. So, the Iterator should be finite to be
 
 ## Implemented in classes:
 
-- [List], [Range]
+- [List], [Range], [Buffer](Buffer.md), [BitBuffer], [Buffer], [Set], [RingBuffer]
+
+[Collection]: Collection.md
 
 [List]: List.md
-[Range]: Range.md
+
+[Range]: Range.md
+
+[Set]: Set.md
+
+[RingBuffer]: RingBuffer.md

docs/List.md

@@ -24,7 +24,7 @@ There is a shortcut for the last:
 
     val list = [10, 20, 30]
     [list.last, list.lastIndex]
-    >>> [30, 2]
+    >>> [30,2]
 
 __Important__ negative indexes works wherever indexes are used, e.g. in insertion and removal methods too.
 
@@ -92,22 +92,45 @@ Open end ranges remove head and tail elements:
     assert( [1, 2, 3] !== [1, 2, 3])
     >>> void
 
+## In-place sort
+
+List could be sorted in place, just like [Collection] provide sorted copies, in a very like way:
+
+    val l1 = [6,3,1,9]
+    l1.sort()
+    assertEquals( [1,3,6,9], l1)
+    
+    l1.sortBy { -it }
+    assertEquals( [1,3,6,9].reversed(), l1)
+    
+    l1.sort() // 1 3 6 9
+    l1.sortBy { it % 4 }
+    // 1,3,6,9 gives, mod 4:
+    // 1 3 2 1
+    // we hope we got it also stable:
+    assertEquals( [1,9,6,3], l1)
+    >>> void
+
 ## Members
 
-| name                          | meaning                               | type        |
-|-------------------------------|---------------------------------------|-------------|
-| `size`                        | current size                          | Int         |
-| `add(elements...)`            | add one or more elements to the end   | Any         |
-| `insertAt(index,elements...)` | insert elements at position           | Int, Any    |
-| `removeAt(index)`             | remove element at position            | Int         |
-| `remove(from,toNonInclusive)` | remove range from (incl) to (nonincl) | Int, Int    |
-| `remove(Range)`               | remove range                          | Range       |
-| `removeLast()`                | remove last element                   |             |
-| `removeLast(n)`               | remove n last elements                | Int         |
-| `contains(element)`           | check the element is in the list (1)  |             |
-| `[index]`                     | get or set element at index           | Int         |
-| `[Range]`                     | get slice of the array (copy)         | Range       |
-| `+=`                          | append element(s)                     | List or Obj |
+| name                          | meaning                                      | type        |
+|-------------------------------|----------------------------------------------|-------------|
+| `size`                        | current size                                 | Int         |
+| `add(elements...)`            | add one or more elements to the end          | Any         |
+| `insertAt(index,elements...)` | insert elements at position                  | Int, Any    |
+| `removeAt(index)`             | remove element at position                   | Int         |
+| `remove(from,toNonInclusive)` | remove range from (incl) to (nonincl)        | Int, Int    |
+| `remove(Range)`               | remove range                                 | Range       |
+| `removeLast()`                | remove last element                          |             |
+| `removeLast(n)`               | remove n last elements                       | Int         |
+| `contains(element)`           | check the element is in the list (1)         |             |
+| `[index]`                     | get or set element at index                  | Int         |
+| `[Range]`                     | get slice of the array (copy)                | Range       |
+| `+=`                          | append element(s) (2)                        | List or Obj |
+| `sort()`                      | in-place sort, natural order                 | void        |
+| `sortBy(predicate)`           | in-place sort bu `predicate` call result (3) | void        |
+| `sortWith(comparator)`        | in-place sort using `comarator` function (4) | void        |
+| `shiffle()`                   | in-place shiffle contents                    |             |
 
 (1)
 : optimized implementation that override `Array` one
@@ -116,7 +139,16 @@ 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.
+(3)
+: predicate is called on each element, and the returned values are used to sort in natural
+order, e.g. is same as `list.sortWith { a,b -> predicate(a) <=> predicate(b) }`
+
+(4)
+: comparator callable takes tho arguments and must return: negative value when first is less,
+positive if first is greater, and zero if they are equal. For example, the equvalent comparator
+for `sort()` will be `sort { a, b -> a <=> b }
+
+It inherits from [Iterable] too and thus all iterable methods are applicable to any list.
 
 ## Member inherited from Array
 
@@ -134,4 +166,5 @@ It inherits from [Iterable] too.
 
 
 [Range]: Range.md
+
 [Iterable]: Iterable.md

docs/Map.md

@@ -3,20 +3,24 @@
 Map is a mutable collection of key-value pars, where keys are unique. Maps could be created with
 constructor or `.toMap` methods. When constructing from a list, each list item must be a [Collection] with exactly 2 elements, for example, a [List].
 
+Important thing is that maps can't contain `null`: it is used to return from missing elements.
+
 Constructed map instance is of class `Map` and implements `Collection` (and therefore `Iterable`)
 
-    val map = Map( ["foo", 1], ["bar", "buzz"] )
+    val map = Map( "foo" => 1, "bar" => "buzz" )
     assert(map is Map)
     assert(map.size == 2)
     assert(map is Iterable)
     >>> void
 
+Notice usage of the `=>` operator that creates `MapEntry`, which implements also [Collection] of
+two items, first, at index zero, is a key, second, at index 1, is the value. You can use lists too.
 Map keys could be any objects (hashable, e.g. with reasonable hashCode, most of standard types are). You can access elements with indexing operator:
 
     val map = Map( ["foo", 1], ["bar", "buzz"], [42, "answer"] )
     assert( map["bar"] == "buzz")
     assert( map[42] == "answer" )
-    assertThrows { map["nonexistent"] }
+    assertEquals( null, map["nonexisting"])
     assert( map.getOrNull(101) == null )
     assert( map.getOrPut(911) { "nine-eleven" } == "nine-eleven" )
     // now 91 entry is set:
@@ -29,7 +33,7 @@ To remove item from the collection. use `remove`. It returns last removed item o
 hold nulls in the map - this is not a recommended practice when using `remove` returned value. `clear()` 
 removes all.
 
-    val map = Map( ["foo", 1], ["bar", "buzz"], [42, "answer"] )
+    val map = Map( "foo" => 1, "bar" => "buzz", [42, "answer"] )
     assertEquals( 1, map.remove("foo") )
     assert( map.getOrNull("foo") == null)
     assert( map.size == 2 )

docs/OOP.md

@@ -147,7 +147,7 @@ In many cases it is necessary to implement custom comparison and `toString`, sti
 each class is provided with default implementations:
 
 - default toString outputs class name and its _public_ fields.
-- default comparison compares compares all public fields in order of appearance.
+- default comparison compares all fields in order of appearance.
 
 For example, for our class Point:
 
@@ -160,6 +160,185 @@ For example, for our class Point:
     Point(1,1+1)
     >>> Point(x=1,y=2)
 
+## Statics: class fields and class methods
+
+You can mark a field or a method as static. This is borrowed from Java as more plain version of a kotlin's companion object or Scala's object. Static field and functions is one for a class, not for an instance. From inside the class, e.g. from the class method, it is a regular var. From outside, it is accessible as `ClassName.field` or method:
+
+
+    class Value(x) {
+        static var foo = Value("foo")
+
+        static fun exclamation() {
+            // here foo is a regular var:
+            foo.x + "!"
+        }
+    }
+    assertEquals( Value.foo.x, "foo" )
+    assertEquals( "foo!", Value.exclamation() )
+
+    // we can access foo from outside like this:
+    Value.foo = Value("bar")
+    assertEquals( "bar!", Value.exclamation() )
+    >>> void
+
+As usual, private statics are not accessible from the outside:
+
+    class Test {
+        // private, inacessible from outside protected data:
+        private static var data = null
+
+        // the interface to access and change it:
+        static fun getData() { data }
+        static fun setData(value) { data = value }
+    }
+
+    // no direct access:
+    assertThrows { Test.data }
+
+    // accessible with the interface:
+    assertEquals( null, Test.getData() )
+    Test.setData("fubar")
+    assertEquals("fubar", Test.getData() )
+    >>> void
+
+# Extending classes
+
+It sometimes happen that the class is missing some particular functionality that can be _added to it_ without rewriting its inner logic and using its private state. In this case _extension methods_ could be used, for example. we want to create an extension method
+that would test if some object of unknown type contains something that can be interpreted
+as an integer. In this case we _extend_ class `Object`, as it is the parent class for any instance of any type:
+
+        fun Object.isInteger() {
+            when(this) {
+                // already Int?
+                is Int -> true
+
+                // real, but with no declimal part?
+                is Real -> toInt() == this
+
+                // string with int or real reuusig code above
+                is String -> toReal().isInteger()
+                
+                // otherwise, no:
+                else -> false
+            }
+        }
+
+        // Let's test:        
+        assert( 12.isInteger() == true )
+        assert( 12.1.isInteger() == false )
+        assert( "5".isInteger() )
+        assert( ! "5.2".isInteger() )
+        >>> void
+
+__Important note__ as for version 0.6.9, extensions are in __global scope__. It means, that once applied to a global type (Int in our sample), they will be available for _all_ contexts, even new created, 
+as they are modifying the type, not the context.
+
+Beware of it. We might need to reconsider it later.
+
+## dynamic symbols
+
+Sometimes it is convenient to provide methods and variables whose names are not known at compile time. For example, it could be external interfaces not known to library code, user-defined data fields, etc. You can use `dynamic` function to create such:
+
+    // val only dynamic object
+    val accessor = dynamic {
+        // all symbol reads are redirected here:
+        get { name ->
+            // lets provide one dynamic symbol:
+            if( name == "foo" ) "bar" else null
+            // consider also throw SymbolNotDefinedException
+        }
+    }
+    
+    // now we can access dynamic "fields" of accessor:
+    assertEquals("bar", accessor.foo)
+    assertEquals(null, accessor.bar)
+    >>> void
+
+The same we can provide writable dynamic fields (var-type), adding set method:
+
+    // store one dynamic field here
+    var storedValueForBar = null
+    
+    // create dynamic object with 2 fields:
+    val accessor = dynamic {
+        get { name ->
+            when(name) {
+                // constant field
+                "foo" -> "bar"
+                // mutable field
+                "bar" -> storedValueForBar 
+
+                else -> throw SymbolNotFoundException()
+            }
+        }
+        set { name, value ->
+            // only 'bar' is mutable:
+            if( name == "bar" )
+                storedValueForBar = value
+                // the rest is immotable. consider throw also
+                // SymbolNotFoundException when needed.
+            else throw IllegalAssignmentException("Can't assign "+name)
+        }
+    }
+    
+    assertEquals("bar", accessor.foo)
+    assertEquals(null, accessor.bar)
+    accessor.bar = "buzz"
+    assertEquals("buzz", accessor.bar)
+    
+    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:
@@ -216,11 +395,10 @@ Note `Real` class: it is global variable for Real class; there are such class in
     assert('$'::class == Char)
     >>> void
 
-More complex is singleton classes, because you don't need to compare their class
-instances and generally don't need them at all, these are normally just Obj:
+Singleton classes also have class:
 
     null::class
-    >>> Obj
+    >>> Null
 
 At this time, `Obj` can't be accessed as a class.
 

docs/Range.md

@@ -87,7 +87,7 @@ You can use Char as both ends of the closed range:
 Exclusive end char ranges are supported too:
 
     ('a'..<'c').toList 
-    >>> ['a', 'b']
+    >>> [a,b]
 
 
 # Instance members

docs/Real.md

@@ -15,11 +15,11 @@ you can use it's class to ensure type:
 
 ## Member functions
 
-| name            | meaning                            | type |
-|-----------------|------------------------------------|------|
-| `.roundToInt()` | round to nearest int like round(x) | Int  |
-|                 |                                    |      |
-|                 |                                    |      |
-|                 |                                    |      |
-|                 |                                    |      |
-|                 |                                    |      |
+| name            | meaning                                                     | type |
+|-----------------|-------------------------------------------------------------|------|
+| `.roundToInt()` | round to nearest int like round(x)                          | Int  |
+| `.toInt()`      | convert integer part of real to `Int` dropping decimal part | Int  |
+|                 |                                                             |      |
+|                 |                                                             |      |
+|                 |                                                             |      |
+|                 |                                                             |      |

docs/Regex.md

@@ -0,0 +1,91 @@
+# Regular expressions
+
+In lyng, you create regular expressions using class `Regex` or `String.re` methods:
+
+    assert( "\d*".re is Regex )
+    assert( Regex("\d*") is Regex )
+    >>> void
+
+We plan to add slash syntax at some point.
+
+To check that some string matches as whole to some regex:
+
+    assert( "123".matches("\d{3}".re) )
+    assert( !"123".matches("\d{4}".re) )
+    assert( !"1234".matches("\d".re) )
+    >>> void
+
+To check that _part of the string_ matches some regular expession, use _match operator_ `=~` just like in Ruby, and its
+counterpart, _not match_ operator `!~`:
+
+    assert( "abc123def" =~ "\d\d\d".re )
+    assert( "abc" !~ "\d\d\d".re )
+    >>> void
+
+When you need to find groups, and more detailed match information, use `Regex.find`:
+
+    val result = Regex("abc(\d)(\d)(\d)").find( "bad456 good abc123")
+    assert( result  != null )
+    assertEquals( 12 .. 17, result.range )
+    assertEquals( "abc123", result[0] )
+    assertEquals( "1", result[1] )
+    assertEquals( "2", result[2] )
+    assertEquals( "3", result[3] )
+    >>> void
+
+Note that the object `RegexMatch`, returned by [Regex.find], behaves much like in many other languages: it provides the
+index range and groups matches as indexes.
+
+Match operator actually also provides `RegexMatch` in `$~` reserved variable (borrowed from Ruby too):
+
+    assert( "bad456 good abc123" =~ "abc(\d)(\d)(\d)".re )
+    assertEquals( 12 .. 17, $~.range )
+    assertEquals( "abc123", $~[0] )
+    assertEquals( "1", $~[1] )
+    assertEquals( "2", $~[2] )
+    assertEquals( "3", $~[3] )
+    >>> void
+
+This is often more readable than calling `find`.
+
+Note that `=~` and `!~` operators against strings and regular expressions are commutative, e.g. regular expression and a
+string can be either left or right operator, but not both:
+
+    assert( "abc" =~ "\wc".re )
+    assert( "abc" !~ "\w1c".re )
+    assert( "a\wc".re =~ "abcd" )
+    assert( "a[a-z]c".re !~ "a2cd" )
+    >>> void
+
+Also, string indexing is Regex-aware, and works like `Regex.find` (_not findall!_):
+
+    assert( "cd" == "abcdef"[ "c.".re ].value )
+    >>> void
+
+
+# Regex class reference
+
+| name         | description                         | notes |
+|--------------|-------------------------------------|-------|
+| matches(str) | true if the whole `str` matches     |       |
+| find(str)    | find first match in `str` or null   | (1)   |
+| findAll(str) | find all matches in `str` as [List] | (1)   |
+
+(1)
+:: See `RegexMatch` class description below
+
+# RegexMatch
+
+| name  | description                               | notes |
+|-------|-------------------------------------------|-------|
+| range | the [Range] of the match in source string |       |
+| value | the value that matches                    |       |
+| [n]   | [List] of group matches                   | (1)   |
+
+(1)
+:: the [0] element is always value, [1] is group 1 match of any, etc.
+
+[List]: List.md
+
+[Range]: Range.md
+

docs/RingBuffer.md

@@ -0,0 +1,52 @@
+# RingBuffer
+
+This is a fixed size buffer that allow to store N last elements with _O(1)_ effectiveness (no data shifting).
+
+Here is the sample:
+
+    val r = RingBuffer(3)
+    assert( r is RingBuffer )
+    assertEquals(0, r.size)
+    assertEquals(3, r.capacity)
+    
+    r += 10
+    assertEquals(1, r.size)
+    assertEquals(10, r.first)
+    
+    r += 20
+    assertEquals(2, r.size)
+    assertEquals( [10, 20], r.toList() )
+    
+    r += 30
+    assertEquals(3, r.size)
+    assertEquals( [10, 20, 30], r.toList() )
+    
+    // now first value is lost:
+    r += 40
+    assertEquals(3, r.size)
+    assertEquals( [20, 30, 40], r.toList() )
+    assertEquals(3, r.capacity)
+
+    >>> void
+
+Ring buffer implements [Iterable], so any of its methods are available for `RingBuffer`, e.g. `first`, `last`, `toList`,
+`take`, `drop`, `takelast`, `dropLast`, etc.
+
+## Constructor
+
+    RinbBuffer(capacity: Int)
+
+## Instance methods
+
+| method      | description            | remarks |
+|-------------|------------------------|---------|
+| capacity    | max size of the buffer |         |
+| size        | current size           | (1)     |
+| operator += | add new item           | (1)     |
+| add(item)   | add new item           | (1)     |
+| iterator()  | return iterator        | (1)     |
+
+(1)
+: Ringbuffer is not threadsafe, protect it with a mutex to avoid RC where necessary.
+
+[Iterable]: Iterable.md

docs/advanced_topics.md

@@ -1,5 +1,7 @@
 # Advanced topics
 
+__See also:__ [parallelism].
+
 ## Closures/scopes isolation
 
 Each block has own scope, in which it can safely use closures and override
@@ -110,4 +112,49 @@ arguments list in almost arbitrary ways. For example:
     )
     >>> void
 
-,
+# Annotations
+
+Annotation in Lyng resembles these proposed for Javascript. Annotation is just regular functions that, if used as annotation, are called when defining a function, var, val or class. 
+
+## Function annotation
+
+When used without params, annotation calls a function with two arguments: actual function name and callable function body. Function annotation __must return callable for the function__, either what it received as a second argument (most often), or something else. Annotation name convention is upper scaled: 
+
+    var annotated = false
+    
+    // this is annotation function:
+    fun Special(name, body) {
+        assertEquals("foo", name)
+        annotated = true
+        { body(it) + 100 }
+    }
+
+    @Special
+    fun foo(value) { value + 1 }
+
+    assert(annotated)
+    assertEquals(111, foo( 10 ))
+    >>> void
+
+Function annotation can have more args specified at call time. There arguments must follow two mandatory ones (name and body). Use default values in order to allow parameterless annotation to be used simultaneously.
+
+    val registered = Map()
+
+    // it is recommended to provide defaults for extra parameters:
+    fun Registered(name, body, overrideName = null) {
+        registered[ overrideName ?: name ] = body
+        body
+    }
+
+    // witout parameters is Ok as we provided default value
+    @Registered
+    fun foo() { "called foo" }
+
+    @Registered("bar") 
+    fun foo2() { "called foo2" }
+
+    assertEquals(registered["foo"](), "called foo")
+    assertEquals(registered["bar"](), "called foo2")
+    >>> void
+
+[parallelism]: parallelism.md

docs/declaring_arguments.md

@@ -71,7 +71,7 @@ destructuring arrays when calling functions and lambdas:
         [ first, last ]
     }
     getFirstAndLast( ...(1..10) ) // see "splats" section below
-    >>> [1, 10]
+    >>> [1,10]
 
 # Splats
 
@@ -83,7 +83,7 @@ or whatever implementing [Iterable], is called _splats_. Here is how we use it:
     }
     val array = [1,2,3]
     testSplat("start", ...array, "end")
-    >>> ["start", 1, 2, 3, "end"]
+    >>> [start,1,2,3,end]
     >>> void
 
 There could be any number of splats at any positions. You can splat any other [Iterable] type:
@@ -93,7 +93,7 @@ There could be any number of splats at any positions. You can splat any other [I
     }
     val range = 1..3
     testSplat("start", ...range, "end")
-    >>> ["start", 1, 2, 3, "end"]
+    >>> [start,1,2,3,end]
     >>> void
     
 

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/development/scope_resolution.md

@@ -0,0 +1,14 @@
+
+
+Provide:
+
+
+    fun outer(a1)
+        // a1 is caller.a1:arg
+        val a1_local = a1 + 1
+        // we return lambda:
+        { it ->
+            // a1_local
+            a1_lcoal + it
+        }
+    }

docs/exceptions_handling.md

@@ -122,6 +122,32 @@ This way, in turn, can also be shortened, as it is overly popular:
 The trick, though, works with strings only, and always provide `Exception` instances, which is good for debugging but
 most often not enough.
 
+# Exception class
+
+Serializable class that conveys information about the exception. Important members and methods are:
+
+| name              | description                                            |
+|-------------------|--------------------------------------------------------|
+| message           | String message                                         |
+| stackTrace        | lyng stack trace, list of `StackTraceEntry`, see below |
+| printStackTrace() | format and print stack trace using println()           |
+
+## StackTraceEntry
+
+A simple structire that stores single entry in Lyng stack, it is created automatically on exception creation:
+
+```kotlin
+class StackTraceEntry(
+    val sourceName: String,
+    val line: Int,
+    val column: Int,
+    val sourceString: String
+)
+```
+
+- `sourceString` is a line extracted from sources. Note that it _is serialized and printed_, so if you want to conceal it, catch all exceptions and filter out sensitive information.
+
+
 # Custom error classes
 
 _this functionality is not yet released_
@@ -131,7 +157,7 @@ _this functionality is not yet released_
 | class                      | notes                                                 |
 |----------------------------|-------------------------------------------------------|
 | Exception                  | root of al throwable objects                          |
-| NullReferenceException       |                                                       |
+| NullReferenceException     |                                                       |
 | AssertionFailedException   |                                                       | 
 | ClassCastException         |                                                       |
 | IndexOutOfBoundsException  |                                                       |

docs/parallelism.md

@@ -0,0 +1,207 @@
+# Parallelism in Lyng
+
+Lyng is built to me multithreaded where possible (e.g. all targets byt JS and wasmJS as for now)
+and cooperatively parallel (coroutine based) everywhere.
+
+In Lyng, every function, every lambda are _coroutines_. It means, you can have as many of these as you want without risking running out of memory on threads stack, or get too many threads.
+
+Depending on the platform, these coroutines may be executed on different CPU and cores, too, truly in parallel. Where not, like Javascript browser, they are still executed cooperatively. You should not care about the platform capabilities, just call `launch`:
+
+    // track coroutine call: 
+    var xIsCalled = false
+
+    // launch coroutine in parallel
+    val x = launch { 
+        // wait 10ms to let main code to be executed
+        delay(10)
+        // now set the flag
+        xIsCalled = true
+        // and return something useful:
+        "ok"
+    }
+    // corouine is launhed, but not yet executed
+    // due to delay call:
+    assert(!xIsCalled)
+    
+    // now we wait for it to be executed:
+    assertEquals( x.await(), "ok")
+
+    // now glag should be set:
+    assert(xIsCalled)
+    >>> void
+
+This example shows how to launch a coroutine with `launch` which returns [Deferred] instance, the latter have ways to await for the coroutine completion and retrieve possible result.
+
+Launch has the only argument which should be a callable (lambda usually) that is run in parallel (or cooperatively in parallel), and return anything as the result.
+
+## Synchronization: Mutex
+
+Suppose we have a resource, that could be used concurrently, a coutner in our case. If we won'r protect it, concurrent usage cause RC, Race Condition, providing wrong result:
+
+    var counter = 0
+    
+    (1..4).map { 
+        launch {
+            // slow increment:
+            val c = counter
+            delay(10)
+            counter = c + 1
+        }
+    }.forEach { it.await() }
+    assert(counter < 4)
+    >>> void
+
+The obviously wrong result is not 4, as all coroutines capture the counter value, which is 1, then sleep for 5ms, then save 1 + 1 as result. May some coroutines will pass, so it will be 1 or 2, most likely.
+
+Using [Mutex] makes it all working:
+
+    var counter = 0
+    val mutex = Mutex()
+    
+    (1..4).map { 
+        launch {
+            // slow increment:
+            mutex.withLock {
+                val c = counter
+                delay(10)
+                counter = c + 1
+            }
+        }
+    }.forEach { it.await() }
+    assertEquals(4, counter)
+    >>> void
+
+now everything works as expected: `mutex.withLock` makes them all be executed in sequence, not in parallel.
+
+
+## Completable deferred
+
+Sometimes it is convenient to manually set completion status of some deferred result. This is when [CompletableDeferred] is used:
+
+    // this variable will be completed later:
+    val done = CompletableDeferred()
+    
+    // complete it ater delay
+    launch { 
+        delay(10)
+        // complete it setting the result:
+        done.complete("ok")
+    }
+    
+    // now it is still not completed: coroutine is delayed
+    // (ot not started on sinthe-threaded platforms):
+    assert(!done.isCompleted)
+    assert(done.isActive)
+
+    // then we can just await it as any other deferred:
+    assertEquals( done.await(), "ok")
+    // and as any other deferred it is now complete:
+    assert(done.isCompleted)
+
+## True parallelism
+
+Cooperative, coroutine-based parallelism is automatically available on all platforms. Depending on the platform, though, the coroutines could be dispatched also in different threads; where there are multiple cores and/or CPU available, it means the coroutines could be exuted truly in parallel, unless [Mutex] is used:
+
+| platofrm   | multithreaded |
+|------------|---------------|
+| JVM        | yes           |
+| Android    | yes           |
+| Javascript | NO            |
+| wasmJS     | NO            |
+| IOS        | yes           |
+| MacOSX     | yes           |
+| Linux      | yes           |
+| Windows    | yes           |
+
+So it is important to always use [Mutex] where concurrent execution could be a problem (so called Race Conditions, or RC).
+
+## Yield
+
+When the coroutine is executed, on the single-threaded environment all other coroutines are suspended until active one will wait for something. Sometimes, it is undesirable; the coroutine may perform long calculations or some other CPU consuming task. The solution is to call `yield()` periodically. Unlike `delay()`, yield does not pauses the coroutine for some specified time, but it just makes all other coroutines to be executed. In other word, yield interrupts current coroutines and out it to the end of the dispatcher list of active coroutines. It is especially important on Javascript and wasmJS targets as otherwise UI thread could be blocked. 
+
+Usage example:
+
+    fun someLongTask() { // ...
+        do {
+            // execute step
+            if( done ) break
+            yield()
+        } while(true)
+    }
+
+# Data exchange for coroutines
+
+## Flow
+
+Flow is an async cold sequence; it is named after kotlin's Flow as it resembles it closely. The cold means the flow is only evaluated when iterated (collected, in Kotlin terms), before it is inactive. Sequence means that it is potentially unlimited, as in our example of glorious Fibonacci number generator:
+
+    // Fibonacch numbers flow! 
+    val f = flow {
+        println("Starting generator")
+        var n1 = 0
+        var n2 = 1
+        emit(n1)
+        emit(n2)
+        while(true) {
+            val n = n1 + n2
+            emit(n)
+            n1 = n2
+            n2 = n
+        }
+    }
+    val correctFibs = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]
+    println("Generation starts")
+    assertEquals( correctFibs, f.take(correctFibs.size))
+    >>> Generation starts
+    >>> Starting generator
+    >>> void
+
+Great: the generator is not executed until collected bu the `f.take()` call, which picks specified number of elements from the flow, can cancel it.
+
+Important difference from the channels or like, every time you collect the flow, you collect it anew:
+
+    var isStarted = false
+    val f = flow {
+            emit("start")
+            isStarted = true
+            (1..4).forEach { emit(it) }
+    }
+    // flow is not yet started, e.g. not got execited, 
+    // that is called 'cold':
+    assertEquals( false, isStarted )
+
+    // let's collect flow:
+    val result = []
+    for( x in f ) result += x
+    println(result)
+
+    assertEquals( true, isStarted)
+
+    // let's collect it once again, it should be the same:
+    println(f.toList())
+
+    // and again:
+    assertEquals( result, f.toList() )
+
+    >>> [start,1,2,3,4]
+    >>> [start,1,2,3,4]
+    >>> void
+
+Notice that flow's lambda is not called until actual collection is started. Cold flows are
+better in terms of resource consumption.
+
+Flows allow easy transforming of any [Iterable]. See how the standard Lyng library functions use it:
+
+    fun Iterable.filter(predicate) {
+        val list = this
+        flow {
+            for( item in list ) {
+                if( predicate(item) ) {
+                    emit(item)
+                }
+            }
+        }
+    }
+
+
+[Iterable]: Iterable.md

docs/samples/happy_numbers.lyng.bad

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

docs/samples/helloworld.lyng

@@ -1,2 +1,3 @@
+#!/bin/env jlyng
 
 println("Hello, world!");

docs/samples/сумма_ряда.lyng.md

@@ -48,6 +48,7 @@ $$ \ln(1+x)=x-{\dfrac {x^{2}}{2}}+{\dfrac {x^{3}}{3}}-\cdots =\sum \limits _{n=0
     }
     assert( почти_равны( 0.0005, 0.000501 ) )
 
-Во многих случаях вычисление $n+1$ члена значительно проще cчитается от предыдущего члена, в нашем случае это можно было бы записать через итератор, что мы вскоре добавим.
+Во многих случаях вычисление $n+1$ члена значительно проще cчитается от предыдущего члена, в нашем случае это можно было бы записать через итератор, см [Iterable] и `flow` в [parallelism].
 
-(продолжение следует)
+[Iterable]: ../Iterable.md
+[parallelism]: ../parallelism.md

docs/serialization.md

@@ -0,0 +1,46 @@
+# Lyng serialization
+
+Lyng has builting binary bit-effective serialization format, called Lynon for LYng Object Notation. It is typed, binary, implements caching, automatic compression, variable-length ints, one-bit Booleans an many nice features. 
+
+It is as simple as:
+
+    import lyng.serialization
+
+    val text = "
+        We hold these truths to be self-evident, that all men are created equal, 
+        that they are endowed by their Creator with certain unalienable Rights, 
+        that among these are Life, Liberty and the pursuit of Happiness.    
+        "
+    val encodedBits = Lynon.encode(text)
+
+    // decode bits source:
+    assertEquals( text, Lynon.decode(encodedBits) )
+    
+    // compression was used automatically
+    assert( text.length > encodedBits.toBuffer().size )
+    >>> void
+
+Any class you create is serializable by default; lynon serializes first constructor fields, then any `var` member fields:
+
+    import lyng.serialization
+
+    class Point(x,y)
+
+    val p = Lynon.decode( Lynon.encode( Point(5,6) ) )
+    
+    assertEquals( 5, p.x )
+    assertEquals( 6, p.y )
+    >>> void
+
+
+just as expected.
+
+Important is to understand that normally `Lynon.decode` wants [BitBuffer], as `Lynon.encode` produces. If you have the regular [Buffer], be sure to convert it:
+
+    buffer.toBitInput()
+
+this possibly creates extra zero bits at the end, as bit content could be shorter than byte-grained but for the Lynon format it does not make sense. Note that when you serialize [BitBuffer], exact number of bits is written. To convert bit buffer to bytes:
+
+    Lynon.encode("hello").toBuffer()
+
+(topic is incomplete and under construction)

docs/time.md

@@ -0,0 +1,215 @@
+# Lyng time functions
+
+Lyng date and time support requires importing `lyng.time` packages. Lyng uses simple yet modern time object models:
+
+- `Instant` class for time stamps with platform-dependent resolution
+- `Duration` to represent amount of time not depending on the calendar, e.g. in absolute units (milliseconds, seconds,
+  hours, days)
+
+## Time instant: `Instant`
+
+Represent some moment of time not depending on the calendar (calendar for example may b e changed, daylight saving time
+can be for example introduced or dropped). It is similar to `TIMESTAMP` in SQL or `Instant` in Kotlin. Some moment of
+time; not the calendar date.
+
+Instant is comparable to other Instant. Subtracting instants produce `Duration`, period in time that is not dependent on
+the calendar, e.g. absolute time period.
+
+It is possible to add or subtract `Duration` to and from `Instant`, that gives another `Instant`.
+
+Instants are converted to and from `Real` number of seconds before or after Unix Epoch, 01.01.1970. Constructor with
+single number parameter constructs from such number of seconds,
+and any instance provide `.epochSeconds` member:
+
+    import lyng.time
+
+    // default constructor returns time now:
+    val t1 = Instant()
+    val t2 = Instant()
+    assert( t2 - t1 < 1.millisecond )
+    assert( t2.epochSeconds - t1.epochSeconds < 0.001 )
+    >>> void
+
+## Constructing
+
+    import lyng.time
+
+    // empty constructor gives current time instant using system clock:
+    val now = Instant()
+
+    // constructor with Instant instance makes a copy:
+    assertEquals( now, Instant(now) )
+
+    // constructing from a number is trated as seconds since unix epoch:
+    val copyOfNow = Instant( now.epochSeconds )
+
+    // note that instant resolution is higher that Real can hold
+    // so reconstructed from real slightly differs:
+    assert( abs( (copyOfNow - now).milliseconds ) < 0.01 )
+    >>> void
+
+The resolution of system clock could be more precise and double precision real number of `Real`, keep it in mind.
+
+## Comparing and calculating periods
+
+    import lyng.time
+    
+    val now = Instant()
+    
+    // you cam add or subtract periods, and compare
+    assert( now - 5.minutes < now )
+    val oneHourAgo = now - 1.hour
+    assertEquals( now, oneHourAgo + 1.hour)
+
+    >>> void
+
+## Getting the max precision
+
+Normally, subtracting instants gives precision to microseconds, which is well inside the jitter
+the language VM adds. Still `Instant()` or `Instant.now()` capture most precise system timer at hand and provide inner
+value of 12 bytes, up to nanoseconds (hopefully). To access it use:
+
+    import lyng.time
+
+    // capture time
+    val now = Instant.now()
+
+    // this is Int value, number of whole epoch 
+    // milliseconds to the moment, it fits 8 bytes Int well
+    val seconds = now.epochWholeSeconds
+    assert(seconds is Int)
+
+    // and this is Int value of nanoseconds _since_ the epochMillis,
+    // it effectively add 4 more mytes int:
+    val nanos = now.nanosecondsOfSecond
+    assert(nanos is Int)
+    assert( nanos in 0..999_999_999 )
+
+    // we can construct epochSeconds from these parts:
+    assertEquals( now.epochSeconds, nanos * 1e-9 + seconds )
+    >>> void
+
+## Truncating to more realistic precision
+
+Full precision Instant is way too long and impractical to store, especially when serializing,
+so it is possible to truncate it to milliseconds, microseconds or seconds:
+
+    import lyng.time
+    import lyng.serialization
+
+    // max supported size (now microseconds for serialized value):
+    // note that encoding return _bit array_ and this is a _bit size_:
+    val s0 = Lynon.encode(Instant.now()).size
+
+    // shorter: milliseconds only
+    val s1 = Lynon.encode(Instant.now().truncateToMillisecond()).size
+
+    // truncated to seconds, good for file mtime, etc:
+    val s2 = Lynon.encode(Instant.now().truncateToSecond()).size 
+    assert( s1 < s0 )
+    assert( s2 < s1 )
+    >>> void
+
+## Formatting instants
+
+You can freely use `Instant` in string formatting. It supports usual sprintf-style formats:
+
+        import lyng.time
+        val now = Instant()
+
+        // will be something like "now: 12:10:05"
+        val currentTimeOnly24 =  "now: %tT"(now)
+
+        // we can extract epoch second with formatting too,
+        // this was since early C time
+
+        // get epoch while seconds from formatting
+        val unixEpoch = "Now is %ts since unix epoch"(now)
+        
+        // and it is the same as now.epochSeconds, int part:
+        assertEquals( unixEpoch, "Now is %d since unix epoch"(now.epochSeconds.toInt()) )
+        >>> void
+
+See
+the [complete list of available formats](https://github.com/sergeych/mp_stools?tab=readme-ov-file#datetime-formatting)
+and the [formatting reference](https://github.com/sergeych/mp_stools?tab=readme-ov-file#printf--sprintf): it all works
+in Lyng as `"format"(args...)`!
+
+## Instant members
+
+| member                         | description                                             |
+|--------------------------------|---------------------------------------------------------|
+| epochSeconds: Real             | positive or negative offset in seconds since Unix epoch |
+| epochWholeSeconds: Int         | same, but in _whole seconds_. Slightly faster           |
+| nanosecondsOfSecond: Int       | offset from epochWholeSeconds in nanos (1)              |
+| isDistantFuture: Bool          | true if it `Instant.distantFuture`                      |
+| isDistantPast: Bool            | true if it `Instant.distantPast`                        |
+| truncateToSecond: Intant       | create new instnce truncated to second                  |  
+| truncateToMillisecond: Instant | truncate new instance with to millisecond               |
+| truncateToMicrosecond: Instant | truncate new instance to microsecond                    |
+
+(1)
+: The value of nanoseconds is to be added to `epochWholeSeconds` to get exact time point. It is in 0..999_999_999 range.
+The precise time instant value therefore needs as for now 12 bytes integer; we might use bigint later (it is planned to
+be added)
+
+## Class members
+
+| member                         | description                                  |
+|--------------------------------|----------------------------------------------|
+| Instant.now()                  | create new instance with current system time |
+| Instant.distantPast: Instant   | most distant instant in past                 |
+| Instant.distantFuture: Instant | most distant instant in future               |
+
+# `Duraion` class
+
+Represent absolute time distance between two `Instant`.
+
+    import lyng.time
+    val t1 = Instant()
+
+    // yes we can delay to period, and it is not blocking. is suspends!
+    delay(1.millisecond)
+
+    val t2 = Instant()
+    // be suspend, so actual time may vary:
+    assert( t2 - t1 >= 1.millisecond)
+    assert( t2 - t1 < 100.millisecond)
+    >>> void
+
+Duration can be converted from numbers, like `5.minutes` and so on. Extensions are created for
+`Int` and `Real`, so for n as Real or Int it is possible to create durations::
+
+- `n.millisecond`, `n.milliseconds`
+- `n.second`, `n.seconds`
+- `n.minute`, `n.minutes`
+- `n.hour`, `n.hours`
+- `n.day`, `n.days`
+
+The bigger time units like months or years are calendar-dependent and can't be used with `Duration`.
+
+Each duration instance can be converted to number of any of these time units, as `Real` number, if `d` is a `Duration`
+instance:
+
+- `d.microseconds`
+- `d.milliseconds`
+- `d.seconds`
+- `d.minutes`
+- `d.hours`
+- `d.days`
+
+for example
+
+    import lyng.time
+    assertEquals( 60, 1.minute.seconds )
+    assertEquals( 10.milliseconds, 0.01.seconds )
+
+    >>> void
+
+# Utility functions
+
+## delay(duration: Duration)
+
+Suspends current coroutine for at least the specified duration.
+
+

docs/tutorial.md

@@ -14,8 +14,12 @@ __Other documents to read__ maybe after this one:
 - [Advanced topics](advanced_topics.md), [declaring arguments](declaring_arguments.md)
 - [OOP notes](OOP.md), [exception handling](exceptions_handling.md)
 - [math in Lyng](math.md)
-- Some class references: [List], [Set], [Map], [Real], [Range], [Iterable], [Iterator]
-- Some samples: [combinatorics](samples/combinatorics.lyng.md), national vars and loops: [сумма ряда](samples/сумма_ряда.lyng.md). More at [samples folder](samples)
+- [time](time.md) and [parallelism](parallelism.md)
+- [parallelism] - multithreaded code, coroutines, etc.
+- Some class
+  references: [List], [Set], [Map], [Real], [Range], [Iterable], [Iterator], [time manipulation](time.md), [Array], [RingBuffer], [Buffer].
+- Some samples: [combinatorics](samples/combinatorics.lyng.md), national vars and
+  loops: [сумма ряда](samples/сумма_ряда.lyng.md). More at [samples folder](samples)
 
 # Expressions
 
@@ -168,9 +172,10 @@ There is also "elvis operator", null-coalesce infix operator '?:' that returns r
 The following functions simplify nullable values processing and
 allow to improve code look and readability. There are borrowed from Kotlin:
 
-### let 
+### let
 
-`value.let {}` passes to the block value as the single parameter (by default it is assigned to `it`) and return block's returned value. It is useful dealing with null or to
+`value.let {}` passes to the block value as the single parameter (by default it is assigned to `it`) and return block's
+returned value. It is useful dealing with null or to
 get a snapshot of some externally varying value, or with `?.` to process nullable value in a safe manner:
 
     // this state is changed from parallel processes
@@ -221,6 +226,19 @@ It works much like `also`, but is executed in the context of the source object:
     assertEquals(p, Point(2,3))
     >>> void
 
+## run
+
+Executes a block after it returning the value passed by the block. for example, can be used with elvis operator:
+
+    var someVar = null
+    val result = someVar ?: run {
+      someVar = 121
+      "reset"
+    }
+    assertEquals("reset", result)
+    assertEquals(121, someVar)
+    >>> void
+
 ## Math
 
 It is rather simple, like everywhere else:
@@ -257,6 +275,8 @@ Logical operation could be used the same
 |   ===    |     | Any               | (2)      |
 |   !==    |     | Any               | (2)      |
 |    !=    |     | Any               | (1)      |
+|    =~    |     |                   | (3)      |
+|    !~    |     |                   | (3)      |
 | ++a, a++ |     | Int               |          |
 | --a, a-- |     | Int               |          |
 
@@ -268,6 +288,9 @@ Logical operation could be used the same
 singleton object, like `null`, are referentially equal too, while string different literals even being equal are most
 likely referentially not equal
 
+(3)
+: Implemented now in String and Regex as regular expression match and not match, see [Regex].
+
 Reference quality and object equality example:
 
     assert( null == null)  // singletons
@@ -464,7 +487,6 @@ after function call, it is treated as a last argument to the call, e.g.:
     assert( [11, 21, 31] == mapped)
     >>> void
 
-
 # Lists (aka arrays)
 
 Lyng has built-in mutable array class `List` with simple literals:
@@ -472,7 +494,8 @@ Lyng has built-in mutable array class `List` with simple literals:
     [1, "two", 3.33].size
     >>> 3
 
-[List] is an implementation of the type `Array`, and through it `Collection` and [Iterable].
+[List] is an implementation of the type `Array`, and through it `Collection` and [Iterable]. Please read [Iterable],
+many collection based methods are implemented there.
 
 Lists can contain any type of objects, lists too:
 
@@ -489,21 +512,21 @@ Notice usage of indexing. You can use negative indexes to offset from the end of
 When you want to "flatten" it to single array, you can use splat syntax:
 
     [1, ...[2,3], 4]
-    >>> [1, 2, 3, 4]
+    >>> [1,2,3,4]
 
 Of course, you can splat from anything that is List (or list-like, but it will be defined later):
 
     val a = ["one", "two"]
     val b = [10.1, 20.2]
     ["start", ...b, ...a, "end"]
-    >>> ["start", 10.1, 20.2, "one", "two", "end"]
+    >>> [start,10.1,20.2,one,two,end]
 
 Of course, you can set any list element:
 
     val a = [1, 2, 3]
     a[1] = 200
     a
-    >>> [1, 200, 3]
+    >>> [1,200,3]
 
 Lists are comparable, and it works well as long as their respective elements are:
 
@@ -530,10 +553,12 @@ The simplest way to concatenate lists is using `+` and `+=`:
     list += [2, 1]      
     // or you can append a single element:
     list += "end"
-    assert( list == [1, 2, 2, 1, "end"])
+    assertEquals( list, [1, 2, 2, 1, "end"])
+    void
     >>> void
 
-***Important note***: the pitfall of using `+=` is that you can't append in [Iterable] instance as an object: it will always add all its contents. Use `list.add` to add a single iterable instance:
+***Important note***: the pitfall of using `+=` is that you can't append in [Iterable] instance as an object: it will
+always add all its contents. Use `list.add` to add a single iterable instance:
 
     var list = [1, 2]
     val other = [3, 4]
@@ -561,7 +586,6 @@ Use `list.add` to avoid confusion:
     assert( list == [1, 2, [3, 4], (10..12)])
     >>> void
 
-
 To add elements to the list:
 
     val x = [1,2]
@@ -592,21 +616,20 @@ Using splat arguments can simplify inserting list in list:
     val x = [1, 2, 3]
     x.insertAt( 1, ...[0,100,0])
     x
-    >>> [1, 0, 100, 0, 2, 3]
-
+    >>> [1,0,100,0,2,3]
 
 Note that to add to the end you still need to use `add` or positive index of the after-last element:
 
     val x = [1,2,3]
     x.insertAt(3, 10)
     x
-    >>> [1, 2, 3, 10]
+    >>> [1,2,3,10]
 
 but it is much simpler, and we recommend to use '+='
 
     val x = [1,2,3]
     x += 10
-    >>> [1, 2, 3, 10]
+    >>> [1,2,3,10]
 
 ## Removing list items
 
@@ -641,6 +664,11 @@ You can get ranges to extract a portion from a list:
     assertEquals( [2,3], list[1..<3])
     >>> void
 
+# Buffers
+
+[Buffer] is a special implementation of an [Array] of unsigned bytes, in the
+[separate file](Buffer.md).
+
 # Sets
 
 Set are unordered collection of unique elements, see [Set]. Sets are [Iterable] but have no indexing access.
@@ -662,7 +690,6 @@ are [Iterable]:
 
 Please see [Map] reference for detailed description on using Maps.
 
-
 # Flow control operators
 
 ## if-then-else
@@ -734,25 +761,30 @@ Also, you can check the type too:
 
 ### supported when conditions:
 
-#### Contains: 
+#### Contains:
 
-You can thest that _when expression_ is _contained_, or not contained, in some object using `in container` and `!in container`. The container is any object that provides `contains` method, otherwise the runtime exception will be thrown.
+You can thest that _when expression_ is _contained_, or not contained, in some object using `in container` and
+`!in container`. The container is any object that provides `contains` method, otherwise the runtime exception will be
+thrown.
 
-Typical builtin types that are containers (e.g. support `conain`):
+Typical builtin types that are containers (e.g. support `contains`):
 
-| class      | notes                                      |
-|------------|--------------------------------------------|
-| Collection | contains an element (1)                    |
-| Array      | faster maybe that Collection's             |
-| List       | faster than Array's                        |
-| String     | character in string or substring in string |
-| Range      | object is included in the range (2)        |
+| class        | notes                                          |
+|--------------|------------------------------------------------|
+| [Collection] | contains an element (1)                        |
+| Array        | faster maybe that Collection's                 |
+| List         | faster than Array's                            |
+| String       | character in string or substring in string (3) |
+| Range        | object is included in the range (2)            |
+| Buffer       | byte is in buffer                              |
+| RingBuffer   | object is in buffer                            |
 
 (1)
 : Iterable is not the container as it can be infinite
 
 (2)
-: Depending on the inclusivity and open/closed range parameters. BE careful here: String range is allowed, but it is usually not what you expect of it:
+: Depending on the inclusivity and open/closed range parameters. BE careful here: String range is allowed, but it is
+usually not what you expect of it:
 
     assert( "more" in "a".."z") // string range ok
     assert( 'x' !in "a".."z") // char in string range: probably error
@@ -760,6 +792,11 @@ Typical builtin types that are containers (e.g. support `conain`):
     assert( "x" !in 'a'..'z') // string in character range: could be error
     >>> void
 
+(3)
+: `String` also can provide array of characters directly with `str.characters()`, which is [Iterable] and [Array].
+String itself is not iterable as otherwise it will interfere when adding strigns to lists (it will add _characters_ it
+it would be iterable).
+
 So we recommend not to mix characters and string ranges; use `ch in str` that works
 as expected:
 
@@ -836,7 +873,8 @@ We can skip the rest of the loop and restart it, as usual, with `continue` opera
     "found even numbers: " + countEven
     >>> "found even numbers: 5"
 
-`continue` can't "return" anything: it just restarts the loop. It can use labeled loops to restart outer ones (we intentionally avoid using for loops here):
+`continue` can't "return" anything: it just restarts the loop. It can use labeled loops to restart outer ones (we
+intentionally avoid using for loops here):
 
     var count = 0
     var total = 0
@@ -882,21 +920,22 @@ test function (remember function return it's last expression result):
 ```mermaid
 flowchart TD
     S((start)) --> Cond{check}
-    Cond--false, no else--->V((void))
-    Cond--true-->E(["last = loop_body()" ])
-    E--break value---->BV((value))
-    E--> Check2{check}
-    E--break---->V
-    Check2 --false-->E
-    Check2 --true, no else--->L((last))
-    Check2 --true, else-->Else(["else_clause()"])
-    Cond--false, else--->Else
+    Cond -- false, no else ---> V((void))
+    Cond -- true --> E(["last = loop_body()"])
+    E -- break value ----> BV((value))
+    E --> Check2{check}
+    E -- break ----> V
+    Check2 -- false --> E
+    Check2 -- true, no else ---> L((last))
+    Check2 -- true, else --> Else(["else_clause()"])
+    Cond -- false, else ---> Else
     Else --> Ele4$nr((else))
 ```
 
 So the returned value, as seen from diagram could be one of:
 
-- `void`, if the loop was not executed, e.g. `condition` was initially false, and there was no `else` clause, or if the empty break was executed.
+- `void`, if the loop was not executed, e.g. `condition` was initially false, and there was no `else` clause, or if the
+  empty break was executed.
 - value returned from `break value' statement
 - value returned from the `else` clause, of the loop was not broken
 - value returned from the last execution of loop body, if there was no `break` and no `else` clause.
@@ -920,7 +959,8 @@ available in the condition:
     } while( continueLoop )
     >>> "OK"
 
-This is sometimes convenient when condition is complex and has to be calculated inside the loop body. Notice the value returning by the loop:
+This is sometimes convenient when condition is complex and has to be calculated inside the loop body. Notice the value
+returning by the loop:
 
     fun readLine() { "done: result" }
     val result = do {
@@ -931,7 +971,6 @@ This is sometimes convenient when condition is complex and has to be calculated
 
 Suppose readLine() here reads some stream of lines.
 
-
 ## For loops
 
 For loop are intended to traverse collections, and all other objects that supports
@@ -974,7 +1013,8 @@ We can use labels too:
 
 # Exception handling
 
-Very much like in Kotlin. Try block returns its body block result, if no exception was cauht, or the result from the catch block that caught the exception:
+Very much like in Kotlin. Try block returns its body block result, if no exception was cauht, or the result from the
+catch block that caught the exception:
 
     var error = "not caught"
     var finallyCaught = false
@@ -1021,13 +1061,12 @@ And even shortest, for the Lying lang tradition, missing var is `it`:
     assert( caught is IllegalArgumentException )
     >>> void
 
-It is possible to catch several exceptions in the same block too, use 
+It is possible to catch several exceptions in the same block too, use
 `catch( varName: ExceptionClass1, ExceptionClass2)`, etc, use short form of throw and
 many more.
 
 - see [exception handling](exceptions_handling.md) for detailed exceptions tutorial and reference.
 
-
 # Self-assignments in expression
 
 There are auto-increments and auto-decrements:
@@ -1092,6 +1131,38 @@ and you can use ranges in for-loops:
 
 See [Ranges](Range.md) for detailed documentation on it.
 
+# Time routines
+
+These should be imported from [lyng.time](time.md). For example:
+
+    import lyng.time
+
+    val now = Instant()
+    val hourAgo = now - 1.hour
+
+See [more docs on time manipulation](time.md)
+
+# Enums
+
+For the moment, only simple enums are implemented. Enum is a list of constants, represented also by their
+_ordinal_ - [Int] value.
+
+    enum Color {
+        RED, GREEN, BLUE
+    }
+    
+    assert( Color.RED is Color )
+
+    assertEquals( 2, Color.BLUE.ordinal )
+    assertEquals( "BLUE", Color.BLUE.name )
+    
+    assertEquals( [Color.RED,Color.GREEN,Color.BLUE], Color.entries)
+    assertEquals( Color.valueOf("GREEN"), Color.GREEN )
+    >>> void
+
+Enums are serialized as ordinals. Please note that due to caching, serialized string arrays could be even more compact
+than enum arrays, until `Lynon.encodeTyped` will be implemented.
+
 # Comments
 
     // single line comment
@@ -1118,6 +1189,30 @@ See also [math operations](math.md)
 
 The type for the character objects is `Char`.
 
+### String literal escapes
+
+| escape | ASCII value           |
+|--------|-----------------------|
+| \n     | 0x10, newline         |
+| \r     | 0x13, carriage return |
+| \t     | 0x07, tabulation      |
+| \\     | \ slash character     |
+| \"     | " double quote        |
+
+Other `\c` combinations, where c is any char except mentioned above, are left intact, e.g.:
+
+    val s = "\a"
+    assert(s[0] == '\')
+    assert(s[1] == 'a')
+    >>> void
+
+same as:
+
+    val s = "\\a"
+    assert(s[0] == '\')
+    assert(s[1] == 'a')
+    >>> void
+
 ### Char literal escapes
 
 Are the same as in string literals with little difference:
@@ -1125,6 +1220,7 @@ Are the same as in string literals with little difference:
 | escape | ASCII value       |
 |--------|-------------------|
 | \n     | 0x10, newline     |
+| \r     | 0x13, carriage return |
 | \t     | 0x07, tabulation  |
 | \\     | \ slash character |
 | \'     | ' apostrophe      |
@@ -1139,7 +1235,6 @@ Are the same as in string literals with little difference:
 | code   | Int  | Unicode code for the character |
 |        |      |                                |
 
-
 ## String details
 
 Strings are arrays of Unicode characters. It can be indexed, and indexing will
@@ -1167,7 +1262,10 @@ To format a string use sprintf-style modifiers like:
     assertEquals( "hello :11    ", "%-6s:%-6d"(a, b) )
     >>> void
 
-List of format specifiers closely resembles C sprintf() one. See [format specifiers](https://github.com/sergeych/mp_stools?tab=readme-ov-file#sprintf-syntax-summary), this is doe using [mp_stools kotlin multiplatform library](https://github.com/sergeych/mp_stools). Currently supported Lyng types are `String`, `Int`, `Real`, `Bool`, the rest are displayed using their `toString()` representation.
+List of format specifiers closely resembles C sprintf() one.
+See [format specifiers](https://github.com/sergeych/mp_stools?tab=readme-ov-file#sprintf-syntax-summary), this is doe
+using [mp_stools kotlin multiplatform library](https://github.com/sergeych/mp_stools). Currently supported Lyng types
+are `String`, `Int`, `Real`, `Bool`, the rest are displayed using their `toString()` representation.
 
 This list will be extended.
 
@@ -1192,9 +1290,26 @@ Open-ended ranges could be used to get start and end too:
     assertEquals( "pult", "catapult"[ 4.. ])
     >>> void
 
+
 ### String operations
 
-Concatenation is a `+`: `"hello " + name` works as expected. No confusion.
+Concatenation is a `+`: `"hello " + name` works as expected. No confusion. There is also
+[Regex] support for strings, see the link, for example, whole string match:
+
+    assert( !"123".matches( "\d\d".re ) )
+    assert( "123".matches( "\d\d\d".re ) )
+    >>> void
+
+Extraction:
+
+    "abcd42def"[ "\d+".re ].value
+    >>> "42"
+
+Part match:
+
+    assert( "abc foo def" =~ "f[oO]+".re )
+    assert( "foo" == $~.value )
+    >>> void
 
 Typical set of String functions includes:
 
@@ -1202,6 +1317,7 @@ Typical set of String functions includes:
 |--------------------|------------------------------------------------------------|
 | lower()            | change case to unicode upper                               |
 | upper()            | change case to unicode lower                               |
+| trim()             | trim space chars from both ends                            |
 | startsWith(prefix) | true if starts with a prefix                               |
 | endsWith(prefix)   | true if ends with a prefix                                 |
 | take(n)            | get a new string from up to n first characters             |
@@ -1211,14 +1327,23 @@ Typical set of String functions includes:
 | size               | size in characters like `length` because String is [Array] |
 | (args...)          | sprintf-like formatting, see [string formatting]           |
 | [index]            | character at index                                         | 
-| [Range]            | substring at range                                         |
+| [Range]            | substring at range (2)                                     |
+| [Regex]            | find first match of regex, like [Regex.find] (2)           |
 | s1 + s2            | concatenation                                              |
 | s1 += s2           | self-modifying concatenation                               |
+| toReal()           | attempts to parse string as a Real value                   |
+| toInt()            | parse string to Int value                                  |
+| characters()       | create [List] of characters (1)                            |
+| encodeUtf8()       | returns [Buffer] with characters encoded to utf8           |
+| matches(re)        | matches the regular expression (2)                         |
+|                    |                                                            |
 
 
+(1)
+: List is mutable therefore a new copy is created on each call.
 
-
-
+(2)
+: See [Regex]
 
 ### Literals
 
@@ -1227,16 +1352,39 @@ String literal could be multiline:
     "Hello
     World"
 
-though multiline literals is yet work in progress.
+In this case, it will be passed literally ot "hello\n World". But, if there are
+several lines with common left indent, it will be removed, also, forst and last lines,
+if blank, will be removed too, for example:
+
+    println("
+            This is a multiline text.
+            This is a second line.
+        ")
+    >>> This is a multiline text.
+    >>> This is a second line.
+    >>> void
+
+- as expected, empty lines and common indent were removed. It is much like kotlin's `""" ... """.trimIndent()`
+  technique, but simpler ;)
 
 # Built-in functions
 
 See [math functions](math.md). Other general purpose functions are:
 
-| name                                         | description                                              |
-|----------------------------------------------|----------------------------------------------------------|
-| assert(condition,message="assertion failed") | runtime code check. There will be an option to skip them |
-| println(args...)                             | Open for overriding, it prints to stdout.                |
+| name                                         | description                                                |
+|----------------------------------------------|------------------------------------------------------------|
+| assert(condition,message="assertion failed") | runtime code check. There will be an option to skip them   |
+| assertEquals(a,b)                            |                                                            |
+| assertNotEquals(a,b)                         |                                                            |
+| assertTrows { /* block */ }                  |                                                            |
+| check(condition, message=<default>)          | throws IllegalStateException" of condition isn't met       |
+| require(condition, message=<default>)        | throws IllegalArgumentException" of condition isn't met    |
+| println(args...)                             | Open for overriding, it prints to stdout with newline.     |
+| print(args...)                               | Open for overriding, it prints to stdout without newline.  |
+| flow {}                                      | create flow sequence, see [parallelism]                    |
+| delay, launch, yield                         | see [parallelism]                                          |
+| cached(builder)                              | remembers builder() on first invocation and return it then |
+| let, also, apply, run                        | see above, flow controls                                   |
 
 # Built-in constants
 
@@ -1246,11 +1394,31 @@ See [math functions](math.md). Other general purpose functions are:
 | π                                   | See [math](math.md)          |
 
 [List]: List.md
+
 [Iterable]: Iterable.md
+
 [Iterator]: Iterator.md
+
 [Real]: Real.md
+
 [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
+
 [Set]: Set.md
-[Map]: Map.md
+
+[Map]: Map.md
+
+[Buffer]: Buffer.md
+
+[parallelism]: parallelism.md
+
+[RingBuffer]: RingBuffer.md
+
+[Collection]: Collection.md
+
+[Array]: Array.md
+
+[Regex]: Regex.md

gradle.properties

@@ -1,3 +1,20 @@
+#
+# 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.
+#
+#
+
 #Gradle
 org.gradle.jvmargs=-Xmx2048M -Dfile.encoding=UTF-8 -Dkotlin.daemon.jvm.options\="-Xmx2048M"
 org.gradle.caching=true

gradle/libs.versions.toml

@@ -1,13 +1,14 @@
 [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.10.1"
+kotlinx-coroutines = "1.10.2"
 mp_bintools = "0.1.12"
 firebaseCrashlyticsBuildtools = "3.0.3"
 okioVersion = "3.10.2"
+compiler = "3.2.0-alpha11"
 
 [libraries]
 clikt = { module = "com.github.ajalt.clikt:clikt", version.ref = "clikt" }
@@ -19,6 +20,7 @@ mp_bintools = { module = "net.sergeych:mp_bintools", version.ref = "mp_bintools"
 firebase-crashlytics-buildtools = { group = "com.google.firebase", name = "firebase-crashlytics-buildtools", version.ref = "firebaseCrashlyticsBuildtools" }
 okio = { module = "com.squareup.okio:okio", version.ref = "okioVersion" }
 okio-fakefilesystem = { module = "com.squareup.okio:okio-fakefilesystem", version.ref = "okioVersion" }
+compiler = { group = "androidx.databinding", name = "compiler", version.ref = "compiler" }
 
 [plugins]
 androidLibrary = { id = "com.android.library", version.ref = "agp" }

gradle/wrapper/gradle-wrapper.properties

@@ -1,3 +1,20 @@
+#
+# 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.
+#
+#
+
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip

gradlew

@@ -1,13 +1,13 @@
 #!/bin/sh
 
 #
-# Copyright © 2015-2021 the original authors.
+# 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
 #
-#      https://www.apache.org/licenses/LICENSE-2.0
+#     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,
@@ -15,6 +15,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+#
 
 ##############################################################################
 #

lyng/build.gradle.kts

@@ -1,5 +1,22 @@
+/*
+ * 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.
+ *
+ */
+
 plugins {
-    kotlin("multiplatform") version "2.1.21"
+    kotlin("multiplatform") version "2.2.20"
 }
 
 group = "net.sergeych"

lyng/src/commonMain/kotlin/Common.kt

@@ -1,12 +1,37 @@
+/*
+ * 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.
+ *
+ */
+
 package net.sergeych
 
 import com.github.ajalt.clikt.core.CliktCommand
+import com.github.ajalt.clikt.core.Context
+import com.github.ajalt.clikt.core.main
 import com.github.ajalt.clikt.parameters.arguments.argument
 import com.github.ajalt.clikt.parameters.arguments.multiple
 import com.github.ajalt.clikt.parameters.arguments.optional
 import com.github.ajalt.clikt.parameters.options.flag
 import com.github.ajalt.clikt.parameters.options.option
-import net.sergeych.lyng.*
+import kotlinx.coroutines.runBlocking
+import net.sergeych.lyng.LyngVersion
+import net.sergeych.lyng.Script
+import net.sergeych.lyng.ScriptError
+import net.sergeych.lyng.Source
+import net.sergeych.lyng.obj.*
+import net.sergeych.mp_tools.globalDefer
 import okio.FileSystem
 import okio.Path.Companion.toPath
 import okio.SYSTEM
@@ -31,17 +56,32 @@ data class CommandResult(
     val error: String
 )
 
-val baseContext = Context().apply {
-    addFn("exit") {
-        exit(requireOnlyArg<ObjInt>().toInt())
-        ObjVoid
+val baseScopeDefer = globalDefer {
+    Script.newScope().apply {
+        addFn("exit") {
+            exit(requireOnlyArg<ObjInt>().toInt())
+            ObjVoid
+        }
     }
-//    ObjString.type.addFn("shell") {
-//
-//    }
 }
 
-class Lyng(val launcher: (suspend () -> Unit) -> Unit) : CliktCommand() {
+fun runMain(args: Array<String>) {
+    if(args.isNotEmpty()) {
+        if( args.size >= 2 && args[0] == "--" ) {
+            // -- -file.lyng <args>
+            executeFileWithArgs(args[1], args.drop(2))
+            return
+        } else if( args[0][0] != '-') {
+            // file.lyng <args>
+            executeFileWithArgs(args[0], args.drop(1))
+            return
+        }
+    }
+    // normal processing
+    Lyng { runBlocking { it() } }.main(args)
+}
+
+private class Lyng(val launcher: (suspend () -> Unit) -> Unit) : CliktCommand() {
 
     override val printHelpOnEmptyArgs = true
 
@@ -55,7 +95,7 @@ class Lyng(val launcher: (suspend () -> Unit) -> Unit) : CliktCommand() {
 
     val args by argument(help = "arguments for script").multiple()
 
-    override fun help(context: com.github.ajalt.clikt.core.Context): String =
+    override fun help(context: Context): String =
         """
             The Lyng script language interpreter, language version is $LyngVersion.
             
@@ -65,47 +105,57 @@ class Lyng(val launcher: (suspend () -> Unit) -> Unit) : CliktCommand() {
         """.trimIndent()
 
     override fun run() {
-        when {
-            version -> {
-                println("Lyng language version ${LyngVersion}")
-            }
+        runBlocking {
+            val baseScope = baseScopeDefer.await()
+            when {
+                version -> {
+                    println("Lyng language version ${LyngVersion}")
+                }
 
-            execute != null -> {
-                val objargs = mutableListOf<String>()
-                script?.let { objargs += it }
-                objargs += args
-                baseContext.addConst(
-                    "ARGV", ObjList(
-                        objargs.map { ObjString(it) }.toMutableList()
+                execute != null -> {
+                    val objargs = mutableListOf<String>()
+                    script?.let { objargs += it }
+                    objargs += args
+                    baseScope.addConst(
+                        "ARGV", ObjList(
+                            objargs.map { ObjString(it) }.toMutableList()
+                        )
                     )
-                )
-                launcher {
-                    // there is no script name, it is a first argument instead:
-                    processErrors {
-                        baseContext.eval(execute!!)
+                    launcher {
+                        // there is no script name, it is a first argument instead:
+                        processErrors {
+                            baseScope.eval(execute!!)
+                        }
                     }
                 }
-            }
 
-            else -> {
-                if (script == null) {
-                    println(
-                        """
+                else -> {
+                    if (script == null) {
+                        println(
+                            """
                         
                         Error: no script specified.
                         
                     """.trimIndent()
-                    )
-                    echoFormattedHelp()
-                } else {
-                    baseContext.addConst("ARGV", ObjList(args.map { ObjString(it) }.toMutableList()))
-                    launcher { executeFile(script!!) }
+                        )
+                        echoFormattedHelp()
+                    } else {
+                        baseScope.addConst("ARGV", ObjList(args.map { ObjString(it) }.toMutableList()))
+                        launcher { executeFile(script!!) }
+                    }
                 }
             }
         }
     }
 }
 
+fun executeFileWithArgs(fileName: String, args: List<String>) {
+    runBlocking {
+        baseScopeDefer.await().addConst("ARGV", ObjList(args.map { ObjString(it) }.toMutableList()))
+        executeFile(fileName)
+    }
+}
+
 suspend fun executeFile(fileName: String) {
     var text = FileSystem.SYSTEM.source(fileName.toPath()).use { fileSource ->
         fileSource.buffer().use { bs ->
@@ -118,7 +168,7 @@ suspend fun executeFile(fileName: String) {
         text = text.substring(pos + 1)
     }
     processErrors {
-        Compiler().compile(Source(fileName, text)).execute(baseContext)
+        baseScopeDefer.await().eval(Source(fileName, text))
     }
 }
 

lyng/src/jvmMain/kotlin/Common.jvm.kt

@@ -1,3 +1,20 @@
+/*
+ * 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.
+ *
+ */
+
 package net.sergeych
 
 import kotlin.system.exitProcess

lyng/src/jvmMain/kotlin/Shell.jvm.kt

@@ -1,3 +1,20 @@
+/*
+ * 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.
+ *
+ */
+
 @file:Suppress("EXPECT_ACTUAL_CLASSIFIERS_ARE_IN_BETA_WARNING")
 
 package net.sergeych

lyng/src/jvmMain/kotlin/net/sergeych/lyng_cli/Main.kt

@@ -1,9 +1,24 @@
+/*
+ * 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.
+ *
+ */
+
 package net.sergeych.lyng_cli
 
-import com.github.ajalt.clikt.core.main
-import kotlinx.coroutines.runBlocking
-import net.sergeych.Lyng
+import net.sergeych.runMain
 
 fun main(args: Array<String>) {
-    Lyng({ runBlocking { it() } }).main(args)
+    runMain(args)
 }

lyng/src/linuxX64Main/kotlin/Main.kt

@@ -1,7 +1,22 @@
-import com.github.ajalt.clikt.core.main
-import kotlinx.coroutines.runBlocking
-import net.sergeych.Lyng
+/*
+ * 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.
+ *
+ */
+
+import net.sergeych.runMain
 
 fun main(args: Array<String>) {
-    Lyng( { runBlocking { it() } }).main(args)
+    runMain(args)
 }

lyng/src/nativeMain/kotlin/Common.native.kt

@@ -1,4 +1,23 @@
-@file:OptIn(ExperimentalForeignApi::class, ExperimentalForeignApi::class, ExperimentalForeignApi::class)
+/*
+ * 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.
+ *
+ */
+
+@file:OptIn(ExperimentalForeignApi::class, ExperimentalForeignApi::class, ExperimentalForeignApi::class,
+    ExperimentalForeignApi::class
+)
 
 package net.sergeych
 

lynglib/build.gradle.kts

@@ -1,10 +1,27 @@
+/*
+ * 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.
+ *
+ */
+
 import com.codingfeline.buildkonfig.compiler.FieldSpec.Type.STRING
 import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
 import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
 import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
 group = "net.sergeych"
-version = "0.6.7-SNAPSHOT"
+version = "0.9.3"
 
 buildscript {
     repositories {
@@ -20,7 +37,7 @@ plugins {
     alias(libs.plugins.kotlinMultiplatform)
     alias(libs.plugins.androidLibrary)
 //    alias(libs.plugins.vanniktech.mavenPublish)
-    kotlin("plugin.serialization") version "2.1.20"
+    kotlin("plugin.serialization") version "2.1.0"
     id("com.codingfeline.buildkonfig") version "0.17.1"
     `maven-publish`
 }
@@ -45,10 +62,14 @@ kotlin {
             jvmTarget.set(JvmTarget.JVM_11)
         }
     }
-//    iosX64()
-//    iosArm64()
-//    iosSimulatorArm64()
+    iosX64()
+    iosArm64()
+    iosSimulatorArm64()
+    macosX64()
+    macosArm64()
+    mingwX64()
     linuxX64()
+    linuxArm64()
     js {
         browser()
         nodejs()
@@ -62,9 +83,10 @@ 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")
         }
 
         val commonMain by getting {
@@ -99,6 +121,7 @@ android {
 }
 dependencies {
     implementation(libs.firebase.crashlytics.buildtools)
+    implementation(libs.compiler)
 }
 
 publishing {
@@ -119,6 +142,7 @@ publishing {
     }
 }
 
+
 //mavenPublishing {
 //    publishToMavenCentral(SonatypeHost.CENTRAL_PORTAL)
 //

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

@@ -1,3 +1,20 @@
+/*
+ * 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.
+ *
+ */
+
 package net.sergeych.lyng
 
 enum class AccessType(val isMutable: Boolean) {

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

@@ -1,5 +1,26 @@
+/*
+ * 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.
+ *
+ */
+
 package net.sergeych.lyng
 
+import net.sergeych.lyng.obj.Obj
+import net.sergeych.lyng.obj.ObjList
+import net.sergeych.lyng.obj.ObjRecord
+
 /**
  * List of argument declarations in the __definition__ of the lambda, class constructor,
  * function, etc. It is created by [Compiler.parseArgsDeclaration]
@@ -19,17 +40,20 @@ data class ArgsDeclaration(val params: List<Item>, val endTokenType: Token.Type)
     }
 
     /**
-     * parse args and create local vars in a given context
+     * parse args and create local vars in a given context properly interpreting
+     * ellipsis args and default values
      */
     suspend fun assignToContext(
-        context: Context,
-        arguments: Arguments = context.args,
+        scope: Scope,
+        arguments: Arguments = scope.args,
         defaultAccessType: AccessType = AccessType.Var,
-        defaultVisibility: Visibility = Visibility.Public
+        defaultVisibility: Visibility = Visibility.Public,
     ) {
         fun assign(a: Item, value: Obj) {
-            context.addItem(a.name, (a.accessType ?: defaultAccessType).isMutable, value,
-                a.visibility ?: defaultVisibility)
+            scope.addItem(a.name, (a.accessType ?: defaultAccessType).isMutable,
+                value.byValueCopy(),
+                a.visibility ?: defaultVisibility,
+                recordType = ObjRecord.Type.Argument)
         }
 
         // will be used with last lambda arg fix
@@ -52,11 +76,11 @@ data class ArgsDeclaration(val params: List<Item>, val endTokenType: Token.Type)
                 if (a.isEllipsis) break
                 val value = when {
                     i < callArgs.size -> callArgs[i]
-                    a.defaultValue != null -> a.defaultValue.execute(context)
+                    a.defaultValue != null -> a.defaultValue.execute(scope)
                     else -> {
-                        println("callArgs: ${callArgs.joinToString()}")
-                        println("tailBlockMode: ${arguments.tailBlockMode}")
-                        context.raiseIllegalArgument("too few arguments for the call")
+//                        println("callArgs: ${callArgs.joinToString()}")
+//                        println("tailBlockMode: ${arguments.tailBlockMode}")
+                        scope.raiseIllegalArgument("too few arguments for the call")
                     }
                 }
                 assign(a, value)
@@ -76,8 +100,8 @@ data class ArgsDeclaration(val params: List<Item>, val endTokenType: Token.Type)
                         callArgs[j--]
                     }
 
-                    a.defaultValue != null -> a.defaultValue.execute(context)
-                    else -> context.raiseIllegalArgument("too few arguments for the call")
+                    a.defaultValue != null -> a.defaultValue.execute(scope)
+                    else -> scope.raiseIllegalArgument("too few arguments for the call")
                 }
                 assign(a, value)
                 i--
@@ -98,7 +122,7 @@ data class ArgsDeclaration(val params: List<Item>, val endTokenType: Token.Type)
             processEllipsis(leftIndex, end)
         } else {
             if (leftIndex < callArgs.size)
-                context.raiseIllegalArgument("too many arguments for the call")
+                scope.raiseIllegalArgument("too many arguments for the call")
         }
     }
 
@@ -110,7 +134,7 @@ data class ArgsDeclaration(val params: List<Item>, val endTokenType: Token.Type)
      */
     data class Item(
         val name: String,
-        val type: TypeDecl = TypeDecl.Obj,
+        val type: TypeDecl = TypeDecl.TypeAny,
         val pos: Pos = Pos.builtIn,
         val isEllipsis: Boolean = false,
         /**

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

@@ -1,12 +1,33 @@
+/*
+ * 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.
+ *
+ */
+
 package net.sergeych.lyng
 
+import net.sergeych.lyng.obj.Obj
+import net.sergeych.lyng.obj.ObjIterable
+import net.sergeych.lyng.obj.ObjList
+
 data class ParsedArgument(val value: Statement, val pos: Pos, val isSplat: Boolean = false)
 
-suspend fun Collection<ParsedArgument>.toArguments(context: Context,tailBlockMode: Boolean): Arguments {
+suspend fun Collection<ParsedArgument>.toArguments(scope: Scope, tailBlockMode: Boolean): Arguments {
     val list = mutableListOf<Obj>()
 
     for (x in this) {
-        val value = x.value.execute(context)
+        val value = x.value.execute(scope)
         if (x.isSplat) {
             when {
                 value is ObjList -> {
@@ -14,11 +35,11 @@ suspend fun Collection<ParsedArgument>.toArguments(context: Context,tailBlockMod
                 }
 
                 value.isInstanceOf(ObjIterable) -> {
-                    val i = (value.invokeInstanceMethod(context, "toList") as ObjList).list
+                    val i = (value.invokeInstanceMethod(scope, "toList") as ObjList).list
                     i.forEach { list.add(it) }
                 }
 
-                else -> context.raiseClassCastError("expected list of objects for splat argument")
+                else -> scope.raiseClassCastError("expected list of objects for splat argument")
             }
         } else
             list.add(value)
@@ -26,22 +47,24 @@ suspend fun Collection<ParsedArgument>.toArguments(context: Context,tailBlockMod
     return Arguments(list,tailBlockMode)
 }
 
-data class Arguments(val list: List<Obj>,val tailBlockMode: Boolean = false) : List<Obj> by list {
+data class Arguments(val list: List<Obj>, val tailBlockMode: Boolean = false) : List<Obj> by list {
 
     constructor(vararg values: Obj) : this(values.toList())
 
     fun firstAndOnly(pos: Pos = Pos.UNKNOWN): Obj {
         if (list.size != 1) throw ScriptError(pos, "expected one argument, got ${list.size}")
-        return list.first()
+        return list.first().byValueCopy()
     }
 
     /**
      * Convert to list of kotlin objects, see [Obj.toKotlin].
      */
-    suspend fun toKotlinList(context: Context): List<Any?> {
-        return list.map { it.toKotlin(context) }
+    suspend fun toKotlinList(scope: Scope): List<Any?> {
+        return list.map { it.toKotlin(scope) }
     }
 
+    suspend fun inspect(scope: Scope): String = list.map{ it.inspect(scope)}.joinToString(",")
+
     companion object {
         val EMPTY = Arguments(emptyList())
         fun from(values: Collection<Obj>) = Arguments(values.toList())

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

@@ -1,3 +1,20 @@
+/*
+ * 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.
+ *
+ */
+
 package net.sergeych.lyng
 
 //fun buildDoubleFromParts(

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

@@ -0,0 +1,56 @@
+/*
+ * 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.
+ *
+ */
+
+package net.sergeych.lyng
+
+import net.sergeych.lyng.obj.ObjRecord
+
+/**
+ * Scope that adds a "closure" to caller; most often it is used to apply class instance to caller scope.
+ * Inherits [Scope.args] and [Scope.thisObj] from [callScope] and adds lookup for symbols
+ * from [closureScope] with proper precedence
+ */
+class ClosureScope(val callScope: Scope, val closureScope: Scope) :
+    Scope(callScope, callScope.args, thisObj = callScope.thisObj) {
+
+    override fun get(name: String): ObjRecord? {
+        // we take arguments from the callerScope, the rest
+        // from the closure.
+
+        // note using super, not callScope, as arguments are assigned by the constructor
+        // and are not assigned yet to vars in callScope self:
+        super.objects[name]?.let {
+//            if( name == "predicate" ) {
+//                println("predicate: ${it.type.isArgument}: ${it.value}")
+//            }
+            if( it.type.isArgument ) return it
+        }
+        return closureScope.get(name)
+    }
+}
+
+class ApplyScope(_parent: Scope,val applied: Scope) : Scope(_parent, thisObj = applied.thisObj) {
+
+    override fun get(name: String): ObjRecord? {
+        return applied.get(name) ?: super.get(name)
+    }
+
+    override fun applyClosure(closure: Scope): Scope {
+        return this
+    }
+
+}

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

@@ -0,0 +1,24 @@
+/*
+ * 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.
+ *
+ */
+
+package net.sergeych.lyng
+
+sealed class CodeContext {
+    class Module(@Suppress("unused") val packageName: String?): CodeContext()
+    class Function(val name: String): CodeContext()
+    class ClassBody(val name: String): CodeContext()
+}

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

@@ -1,13 +1,28 @@
+/*
+ * 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.
+ *
+ */
+
 package net.sergeych.lyng
 
-internal class CompilerContext(val tokens: List<Token>) {
+class CompilerContext(val tokens: List<Token>) {
     val labels = mutableSetOf<String>()
 
     var breakFound = false
-        private set
 
     var loopLevel = 0
-        private set
 
     inline fun <T> parseLoop(f: () -> T): Pair<Boolean, T> {
         if (++loopLevel == 0) breakFound = false
@@ -22,9 +37,8 @@ internal class CompilerContext(val tokens: List<Token>) {
     fun hasNext() = currentIndex < tokens.size
     fun hasPrevious() = currentIndex > 0
     fun next() =
-        if( currentIndex < tokens.size ) tokens[currentIndex++]
+        if (currentIndex < tokens.size) tokens[currentIndex++]
         else Token("", tokens.last().pos, Token.Type.EOF)
-//        throw IllegalStateException("No more tokens")
 
     fun previous() = if (!hasPrevious()) throw IllegalStateException("No previous token") else tokens[--currentIndex]
 
@@ -51,8 +65,26 @@ internal class CompilerContext(val tokens: List<Token>) {
         throw ScriptError(at, message)
     }
 
+    fun syntaxError(message: String = "Syntax error"): Nothing {
+        throw ScriptError(currentPos(), message)
+    }
+
     fun currentPos(): Pos = tokens[currentIndex].pos
 
+    /**
+     * If the next token is identifier `name`, skip it and return `true`.
+     * else leave where it is and return `false`
+     */
+    fun skipId(name: String): Boolean {
+        current().let { t ->
+            if (t.type == Token.Type.ID && t.value == name) {
+                next()
+                return true
+            }
+        }
+        return false
+    }
+
     /**
      * Skips next token if its type is `tokenType`, returns `true` if so.
      * @param errorMessage message to throw if next token is not `tokenType`
@@ -77,6 +109,20 @@ internal class CompilerContext(val tokens: List<Token>) {
         } else true
     }
 
+    /**
+     * If next token is one of these types, skip it.
+     * @return true if token was found and skipped
+     */
+    fun skipNextIf(vararg types: Token.Type): Boolean {
+        val t = next()
+        return if (t.type in types)
+            true
+        else {
+            previous()
+            false
+        }
+    }
+
     @Suppress("unused")
     fun skipTokens(vararg tokenTypes: Token.Type) {
         while (next().type in tokenTypes) { /**/
@@ -84,8 +130,30 @@ internal class CompilerContext(val tokens: List<Token>) {
         previous()
     }
 
+    fun nextNonWhitespace(): Token {
+        while (true) {
+            val t = next()
+            if (t.type !in wstokens) return t
+        }
+    }
 
-    fun ifNextIs(typeId: Token.Type, f: (Token) -> Unit): Boolean {
+    /**
+     * Find next non-whitespace token and return it. The token is not extracted,
+     * is will be returned on [next] call.
+     * @return next non-whitespace token without extracting it from tokens list
+     */
+    fun peekNextNonWhitespace(): Token {
+        while (true) {
+            val t = next()
+            if (t.type !in wstokens) {
+                previous()
+                return t
+            }
+        }
+    }
+
+
+    inline fun ifNextIs(typeId: Token.Type, f: (Token) -> Unit): Boolean {
         val t = next()
         return if (t.type == typeId) {
             f(t)
@@ -128,19 +196,24 @@ internal class CompilerContext(val tokens: List<Token>) {
     fun matchQualifiers(keyword: String, vararg qualifiers: String): Boolean {
         val pos = savePos()
         var count = 0
-        while( count < qualifiers.size) {
+        while (count < qualifiers.size) {
             val t = next()
-            when(t.type) {
+            when (t.type) {
                 Token.Type.ID -> {
-                    if( t.value in qualifiers ) count++
-                    else { restorePos(pos); return false }
+                    if (t.value in qualifiers) count++
+                    else {
+                        restorePos(pos); return false
+                    }
                 }
+
                 Token.Type.MULTILINE_COMMENT, Token.Type.SINLGE_LINE_COMMENT, Token.Type.NEWLINE -> {}
-                else -> { restorePos(pos); return false }
+                else -> {
+                    restorePos(pos); return false
+                }
             }
         }
         val t = next()
-        if( t.type == Token.Type.ID && t.value == keyword ) {
+        if (t.type == Token.Type.ID && t.value == keyword) {
             return true
         } else {
             restorePos(pos)
@@ -153,8 +226,10 @@ internal class CompilerContext(val tokens: List<Token>) {
      * Note that [Token.Type.EOF] is not considered a whitespace token.
      */
     fun skipWsTokens(): Token {
-        while( current().type in wstokens ) next()
-        return next()
+        while (current().type in wstokens) {
+            next()
+        }
+        return current()
     }
 
     companion object {

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

@@ -1,141 +0,0 @@
-package net.sergeych.lyng
-
-class Context(
-    val parent: Context?,
-    val args: Arguments = Arguments.EMPTY,
-    var pos: Pos = Pos.builtIn,
-    var thisObj: Obj = ObjVoid,
-    var skipContextCreation: Boolean = false,
-) {
-    constructor(
-        args: Arguments = Arguments.EMPTY,
-        pos: Pos = Pos.builtIn,
-    )
-            : this(Script.defaultContext, args, pos)
-
-    /**
-     * Making this context priority one
-     */
-    fun applyContext(other: Context): Context {
-        if (other.thisObj != ObjVoid) thisObj = other.thisObj
-        appliedContext = other
-        return this
-    }
-
-    fun raiseNotImplemented(what: String = "operation"): Nothing = raiseError("$what is not implemented")
-
-    @Suppress("unused")
-    fun raiseNPE(): Nothing = raiseError(ObjNullReferenceException(this))
-
-    @Suppress("unused")
-    fun raiseIndexOutOfBounds(message: String = "Index out of bounds"): Nothing =
-        raiseError(ObjIndexOutOfBoundsException(this, message))
-
-    @Suppress("unused")
-    fun raiseIllegalArgument(message: String = "Illegal argument error"): Nothing =
-        raiseError(ObjIllegalArgumentException(this, message))
-
-    @Suppress("unused")
-    fun raiseNoSuchElement(message: String = "No such element"): Nothing =
-        raiseError(ObjIllegalArgumentException(this, message))
-
-    fun raiseClassCastError(msg: String): Nothing = raiseError(ObjClassCastException(this, msg))
-
-    @Suppress("unused")
-    fun raiseSymbolNotFound(name: String): Nothing =
-        raiseError(ObjSymbolNotDefinedException(this, "symbol is not defined: $name"))
-
-    fun raiseError(message: String): Nothing {
-        throw ExecutionError(ObjException(this, message))
-    }
-
-    fun raiseError(obj: ObjException): Nothing {
-        throw ExecutionError(obj)
-    }
-
-    inline fun <reified T : Obj> requiredArg(index: Int): T {
-        if (args.list.size <= index) raiseError("Expected at least ${index + 1} argument, got ${args.list.size}")
-        return (args.list[index] as? T)
-            ?: raiseClassCastError("Expected type ${T::class.simpleName}, got ${args.list[index]::class.simpleName}")
-    }
-
-    inline fun <reified T : Obj> requireOnlyArg(): T {
-        if (args.list.size != 1) raiseError("Expected exactly 1 argument, got ${args.list.size}")
-        return requiredArg(0)
-    }
-
-    @Suppress("unused")
-    fun requireExactCount(count: Int) {
-        if (args.list.size != count) {
-            raiseError("Expected exactly $count arguments, got ${args.list.size}")
-        }
-    }
-
-    inline fun <reified T : Obj> thisAs(): T = (thisObj as? T)
-        ?: raiseClassCastError("Cannot cast ${thisObj.objClass.className} to ${T::class.simpleName}")
-
-    internal var appliedContext: Context? = null
-    internal val objects = mutableMapOf<String, ObjRecord>()
-
-    operator fun get(name: String): ObjRecord? =
-        if (name == "this") thisObj.asReadonly
-        else {
-            objects[name]
-                ?: parent?.get(name)
-                ?: appliedContext?.get(name)
-        }
-
-    fun copy(pos: Pos, args: Arguments = Arguments.EMPTY, newThisObj: Obj? = null): Context =
-        Context(this, args, pos, newThisObj ?: thisObj)
-
-    fun copy(args: Arguments = Arguments.EMPTY, newThisObj: Obj? = null): Context =
-        Context(this, args, pos, newThisObj ?: thisObj)
-
-    fun copy() = Context(this, args, pos, thisObj)
-
-    fun addItem(
-        name: String,
-        isMutable: Boolean,
-        value: Obj,
-        visibility: Visibility = Visibility.Public
-    ): ObjRecord {
-        return ObjRecord(value, isMutable, visibility).also { objects[name] = it }
-    }
-
-    fun getOrCreateNamespace(name: String): ObjClass {
-        val ns = objects.getOrPut(name) { ObjRecord(ObjNamespace(name), isMutable = false) }.value
-        return ns.objClass
-    }
-
-    inline fun addVoidFn(vararg names: String, crossinline fn: suspend Context.() -> Unit) {
-        addFn<ObjVoid>(*names) {
-            fn(this)
-            ObjVoid
-        }
-    }
-
-    inline fun <reified T : Obj> addFn(vararg names: String, crossinline fn: suspend Context.() -> T) {
-        val newFn = object : Statement() {
-            override val pos: Pos = Pos.builtIn
-
-            override suspend fun execute(context: Context): Obj = context.fn()
-
-        }
-        for (name in names) {
-            addItem(
-                name,
-                false,
-                newFn
-            )
-        }
-    }
-
-    fun addConst(name: String, value: Obj) = addItem(name, false, value)
-
-    suspend fun eval(code: String): Obj =
-        Compiler().compile(code.toSource()).execute(this)
-
-    fun containsLocal(name: String): Boolean = name in objects
-
-
-}

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

@@ -1,5 +1,24 @@
+/*
+ * 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.
+ *
+ */
+
 package net.sergeych.lyng
 
+import net.sergeych.lyng.obj.Accessor
+
 sealed class ListEntry {
     data class Element(val accessor: Accessor) : ListEntry()
 

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

@@ -1,5 +1,25 @@
+/*
+ * 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.
+ *
+ */
+
 package net.sergeych.lyng
 
+import net.sergeych.lyng.obj.Obj
+import net.sergeych.lyng.obj.ObjVoid
+
 class LoopBreakContinueException(
     val doContinue: Boolean,
     val result: Obj = ObjVoid,

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

@@ -0,0 +1,78 @@
+/*
+ * 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.
+ *
+ */
+
+package net.sergeych.lyng
+
+import net.sergeych.lyng.obj.ObjRecord
+import net.sergeych.lyng.obj.ObjString
+import net.sergeych.lyng.pacman.ImportProvider
+
+/**
+ * Module scope supports importing and contains the [importProvider]; it should be the same
+ * used in [Compiler];
+ */
+class ModuleScope(
+    var importProvider: ImportProvider,
+    pos: Pos = Pos.builtIn,
+    override val packageName: String
+) : Scope(importProvider.rootScope, Arguments.EMPTY, pos) {
+
+    constructor(importProvider: ImportProvider, source: Source) : this(importProvider, source.startPos, source.fileName)
+
+    /**
+     * Import symbols into the scope. It _is called_ after the module is imported by [ImportProvider.prepareImport]
+     * which checks symbol availability and accessibility prior to execution.
+     * @param scope where to copy symbols from this module
+     * @param symbols symbols to import, ir present, only symbols keys will be imported renamed to corresponding values
+     */
+    override suspend fun importInto(scope: Scope, symbols: Map<String, String>?) {
+        val symbolsToImport = symbols?.keys?.toMutableSet()
+        for ((symbol, record) in this.objects) {
+            if (record.visibility.isPublic) {
+                val newName = symbols?.let { ss: Map<String, String> ->
+                    ss[symbol]
+                        ?.also { symbolsToImport!!.remove(it) }
+                        ?: scope.raiseError("internal error: symbol $symbol not found though the module is cached")
+                } ?: symbol
+                val existing = scope.objects[newName]
+                if (existing != null ) {
+                    if (existing.importedFrom != record.importedFrom)
+                        scope.raiseError("symbol ${existing.importedFrom?.packageName}.$newName already exists, redefinition on import is not allowed")
+                    // already imported
+                }
+                else {
+                    // when importing records, we keep track of its package (not otherwise needed)
+                    if (record.importedFrom == null) record.importedFrom = this
+                    scope.objects[newName] = record
+                }
+            }
+        }
+        if (!symbolsToImport.isNullOrEmpty())
+            scope.raiseSymbolNotFound("symbols $packageName.{$symbolsToImport} are.were not found")
+    }
+
+    val packageNameObj by lazy { ObjString(packageName).asReadonly }
+
+    override fun get(name: String): ObjRecord? {
+        return if (name == "__PACKAGE__")
+            packageNameObj
+        else
+            super.get(name)
+    }
+}
+
+

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

@@ -1,502 +0,0 @@
-package net.sergeych.lyng
-
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
-import net.sergeych.bintools.encodeToHex
-import net.sergeych.synctools.ProtectedOp
-import net.sergeych.synctools.withLock
-import kotlin.contracts.ExperimentalContracts
-
-/**
- * Record to store object with access rules, e.g. [isMutable] and access level [visibility].
- */
-data class ObjRecord(
-    var value: Obj,
-    val isMutable: Boolean,
-    val visibility: Visibility = Visibility.Public
-)
-
-/**
- * When we need read-write access to an object in some abstract storage, we need Accessor,
- * as in-site assigning is not always sufficient, in general case we need to replace the object
- * in the storage.
- *
- * Note that assigning new value is more complex than just replacing the object, see how assignment
- * operator is implemented in [Compiler.allOps].
- */
-data class Accessor(
-    val getter: suspend (Context) -> ObjRecord,
-    val setterOrNull: (suspend (Context, Obj) -> Unit)?
-) {
-    /**
-     * Simplified constructor for immutable stores.
-     */
-    constructor(getter: suspend (Context) -> ObjRecord) : this(getter, null)
-
-    /**
-     * Get the setter or throw.
-     */
-    fun setter(pos: Pos) = setterOrNull ?: throw ScriptError(pos, "can't assign value")
-}
-
-open class Obj {
-
-    val isNull by lazy { this === ObjNull }
-
-    var isFrozen: Boolean = false
-
-    private val monitor = Mutex()
-
-    //    private val memberMutex = Mutex()
-    internal var parentInstances: MutableList<Obj> = mutableListOf()
-
-    private val opInstances = ProtectedOp()
-
-    open fun inspect(): String = toString()
-
-    /**
-     * Some objects are by-value, historically [ObjInt] and [ObjReal] are usually treated as such.
-     * When initializing a var with it, by value objects must be copied. By-reference ones aren't.
-     *
-     * Almost all objects are by-reference.
-     */
-    open fun byValueCopy(): Obj = this
-
-    @Suppress("SuspiciousEqualsCombination")
-    fun isInstanceOf(someClass: Obj) = someClass === objClass ||
-            objClass.allParentsSet.contains(someClass) ||
-            someClass == rootObjectType
-
-
-    suspend fun invokeInstanceMethod(context: Context, name: String, vararg args: Obj): Obj =
-        invokeInstanceMethod(context, name, Arguments(args.toList()))
-
-    suspend inline fun <reified T : Obj> callMethod(
-        context: Context,
-        name: String,
-        args: Arguments = Arguments.EMPTY
-    ): T = invokeInstanceMethod(context, name, args) as T
-
-    open suspend fun invokeInstanceMethod(
-        context: Context,
-        name: String,
-        args: Arguments = Arguments.EMPTY
-    ): Obj =
-        // note that getInstanceMember traverses the hierarchy
-        objClass.getInstanceMember(context.pos, name).value.invoke(context, this, args)
-
-    fun getMemberOrNull(name: String): Obj? = objClass.getInstanceMemberOrNull(name)?.value
-
-    // methods that to override
-
-    open suspend fun compareTo(context: Context, other: Obj): Int {
-        context.raiseNotImplemented()
-    }
-
-    open suspend fun contains(context: Context, other: Obj): Boolean {
-        return invokeInstanceMethod(context, "contains", other).toBool()
-    }
-
-    open val asStr: ObjString by lazy {
-        if (this is ObjString) this else ObjString(this.toString())
-    }
-
-    /**
-     * Class of the object: definition of member functions (top-level), etc.
-     * Note that using lazy allows to avoid endless recursion here
-     */
-    open val objClass: ObjClass = rootObjectType
-
-    open suspend fun plus(context: Context, other: Obj): Obj {
-        context.raiseNotImplemented()
-    }
-
-    open suspend fun minus(context: Context, other: Obj): Obj {
-        context.raiseNotImplemented()
-    }
-
-    open suspend fun mul(context: Context, other: Obj): Obj {
-        context.raiseNotImplemented()
-    }
-
-    open suspend fun div(context: Context, other: Obj): Obj {
-        context.raiseNotImplemented()
-    }
-
-    open suspend fun mod(context: Context, other: Obj): Obj {
-        context.raiseNotImplemented()
-    }
-
-    open suspend fun logicalNot(context: Context): Obj {
-        context.raiseNotImplemented()
-    }
-
-    open suspend fun logicalAnd(context: Context, other: Obj): Obj {
-        context.raiseNotImplemented()
-    }
-
-    open suspend fun logicalOr(context: Context, other: Obj): Obj {
-        context.raiseNotImplemented()
-    }
-
-    open suspend fun assign(context: Context, other: Obj): Obj? = null
-
-    /**
-     * a += b
-     * if( the operation is not defined, it returns null and the compiler would try
-     * to generate it as 'this = this + other', reassigning its variable
-     */
-    open suspend fun plusAssign(context: Context, other: Obj): Obj? = null
-
-    /**
-     * `-=` operations, see [plusAssign]
-     */
-    open suspend fun minusAssign(context: Context, other: Obj): Obj? = null
-    open suspend fun mulAssign(context: Context, other: Obj): Obj? = null
-    open suspend fun divAssign(context: Context, other: Obj): Obj? = null
-    open suspend fun modAssign(context: Context, other: Obj): Obj? = null
-
-    open suspend fun getAndIncrement(context: Context): Obj {
-        context.raiseNotImplemented()
-    }
-
-    open suspend fun incrementAndGet(context: Context): Obj {
-        context.raiseNotImplemented()
-    }
-
-    open suspend fun decrementAndGet(context: Context): Obj {
-        context.raiseNotImplemented()
-    }
-
-    open suspend fun getAndDecrement(context: Context): Obj {
-        context.raiseNotImplemented()
-    }
-
-    /**
-     * Convert Lyng object to its Kotlin counterpart
-     */
-    open suspend fun toKotlin(context: Context): Any? {
-        return toString()
-    }
-
-    fun willMutate(context: Context) {
-        if (isFrozen) context.raiseError("attempt to mutate frozen object")
-    }
-
-    suspend fun <T> sync(block: () -> T): T = monitor.withLock { block() }
-
-    open suspend fun readField(context: Context, name: String): ObjRecord {
-        // could be property or class field:
-        val obj = objClass.getInstanceMemberOrNull(name) ?: context.raiseError("no such field: $name")
-        return when (val value = obj.value) {
-            is Statement -> {
-                ObjRecord(value.execute(context.copy(context.pos, newThisObj = this)), obj.isMutable)
-            }
-            // could be writable property naturally
-//            null -> ObjNull.asReadonly
-            else -> obj
-        }
-    }
-
-    open suspend fun writeField(context: Context, name: String, newValue: Obj) {
-        willMutate(context)
-        val field = objClass.getInstanceMemberOrNull(name) ?: context.raiseError("no such field: $name")
-        if (field.isMutable) field.value = newValue else context.raiseError("can't assign to read-only field: $name")
-    }
-
-    open suspend fun getAt(context: Context, index: Obj): Obj {
-        context.raiseNotImplemented("indexing")
-    }
-
-    open suspend fun putAt(context: Context, index: Int, newValue: Obj) {
-        context.raiseNotImplemented("indexing")
-    }
-
-    open suspend fun callOn(context: Context): Obj {
-        context.raiseNotImplemented()
-    }
-
-    suspend fun invoke(context: Context, thisObj: Obj, args: Arguments): Obj =
-        callOn(context.copy(context.pos, args = args, newThisObj = thisObj))
-
-    suspend fun invoke(context: Context, thisObj: Obj, vararg args: Obj): Obj =
-        callOn(
-            context.copy(
-                context.pos,
-                args = Arguments(args.toList()),
-                newThisObj = thisObj
-            )
-        )
-
-    suspend fun invoke(context: Context, thisObj: Obj): Obj =
-        callOn(
-            context.copy(
-                context.pos,
-                args = Arguments.EMPTY,
-                newThisObj = thisObj
-            )
-        )
-
-    suspend fun invoke(context: Context, atPos: Pos, thisObj: Obj, args: Arguments): Obj =
-        callOn(context.copy(atPos, args = args, newThisObj = thisObj))
-
-
-    val asReadonly: ObjRecord by lazy { ObjRecord(this, false) }
-    val asMutable: ObjRecord by lazy { ObjRecord(this, true) }
-
-
-    companion object {
-
-        val rootObjectType = ObjClass("Obj").apply {
-                addFn("toString") {
-                    thisObj.asStr
-                }
-                addFn("contains") {
-                    ObjBool(thisObj.contains(this, args.firstAndOnly()))
-                }
-                // utilities
-                addFn("let") {
-                    args.firstAndOnly().callOn(copy(Arguments(thisObj)))
-                }
-                addFn("apply") {
-                    val newContext = ( thisObj as? ObjInstance)?.instanceContext ?: this
-                    args.firstAndOnly()
-                        .callOn(newContext)
-                    thisObj
-                }
-                addFn("also") {
-                    args.firstAndOnly().callOn(copy(Arguments(thisObj)))
-                    thisObj
-                }
-            }
-
-
-        inline fun from(obj: Any?): Obj {
-            @Suppress("UNCHECKED_CAST")
-            return when (obj) {
-                is Obj -> obj
-                is Double -> ObjReal(obj)
-                is Float -> ObjReal(obj.toDouble())
-                is Int -> ObjInt(obj.toLong())
-                is Long -> ObjInt(obj)
-                is String -> ObjString(obj)
-                is CharSequence -> ObjString(obj.toString())
-                is Boolean -> ObjBool(obj)
-                is Set<*> -> ObjSet((obj as Set<Obj>).toMutableSet())
-                Unit -> ObjVoid
-                null -> ObjNull
-                is Iterator<*> -> ObjKotlinIterator(obj)
-                is Map.Entry<*, *> -> {
-                    obj as MutableMap.MutableEntry<Obj, Obj>
-                    ObjMapEntry(obj.key, obj.value)
-                }
-
-                else -> throw IllegalArgumentException("cannot convert to Obj: $obj")
-            }
-        }
-    }
-}
-
-@Suppress("unused")
-inline fun <reified T> T.toObj(): Obj = Obj.from(this)
-
-@Serializable
-@SerialName("void")
-object ObjVoid : Obj() {
-    override fun equals(other: Any?): Boolean {
-        return other is ObjVoid || other is Unit
-    }
-
-    override suspend fun compareTo(context: Context, other: Obj): Int {
-        return if (other === this) 0 else -1
-    }
-
-    override fun toString(): String = "void"
-}
-
-@Serializable
-@SerialName("null")
-object ObjNull : Obj() {
-    override suspend fun compareTo(context: Context, other: Obj): Int {
-        return if (other === this) 0 else -1
-    }
-
-    override fun equals(other: Any?): Boolean {
-        return other is ObjNull || other == null
-    }
-
-    override suspend fun readField(context: Context, name: String): ObjRecord {
-        context.raiseNPE()
-    }
-
-    override suspend fun invokeInstanceMethod(context: Context, name: String, args: Arguments): Obj {
-        context.raiseNPE()
-    }
-
-    override suspend fun getAt(context: Context, index: Obj): Obj {
-        context.raiseNPE()
-    }
-
-    override suspend fun putAt(context: Context, index: Int, newValue: Obj) {
-        context.raiseNPE()
-    }
-
-    override suspend fun callOn(context: Context): Obj {
-        context.raiseNPE()
-    }
-
-    override fun toString(): String = "null"
-
-    override suspend fun toKotlin(context: Context): Any? {
-        return null
-    }
-}
-
-interface Numeric {
-    val longValue: Long
-    val doubleValue: Double
-    val toObjInt: ObjInt
-    val toObjReal: ObjReal
-}
-
-fun Obj.toDouble(): Double =
-    (this as? Numeric)?.doubleValue
-        ?: (this as? ObjString)?.value?.toDouble()
-        ?: throw IllegalArgumentException("cannot convert to double $this")
-
-@Suppress("unused")
-fun Obj.toLong(): Long =
-    when (this) {
-        is Numeric -> longValue
-        is ObjString -> value.toLong()
-        is ObjChar -> value.code.toLong()
-        else -> throw IllegalArgumentException("cannot convert to double $this")
-    }
-
-fun Obj.toInt(): Int = toLong().toInt()
-
-fun Obj.toBool(): Boolean =
-    (this as? ObjBool)?.value ?: throw IllegalArgumentException("cannot convert to boolean $this")
-
-
-data class ObjNamespace(val name: String) : Obj() {
-    override val objClass by lazy { ObjClass(name) }
-
-    override fun inspect(): String = "Ns[$name]"
-
-    override fun toString(): String {
-        return "package $name"
-    }
-}
-
-open class ObjException(exceptionClass: ExceptionClass, val context: Context, val message: String) : Obj() {
-    constructor(name: String, context: Context, message: String) : this(
-        getOrCreateExceptionClass(name),
-        context,
-        message
-    )
-
-    constructor(context: Context, message: String) : this(Root, context, message)
-
-    fun raise(): Nothing {
-        throw ExecutionError(this)
-    }
-
-    override val objClass: ObjClass = exceptionClass
-
-    override fun toString(): String {
-        return "ObjException:${objClass.className}:${context.pos}@${hashCode().encodeToHex()}"
-    }
-
-    companion object {
-
-        class ExceptionClass(val name: String, vararg parents: ObjClass) : ObjClass(name, *parents) {
-            override suspend fun callOn(context: Context): Obj {
-                val message = context.args.getOrNull(0)?.toString() ?: name
-                return ObjException(this, context, message)
-            }
-
-            override fun toString(): String = "ExceptionClass[$name]@${hashCode().encodeToHex()}"
-        }
-
-        val Root = ExceptionClass("Throwable").apply {
-            addConst("message", statement {
-                (thisObj as ObjException).message.toObj()
-            })
-        }
-
-        private val op = ProtectedOp()
-        private val existingErrorClasses = mutableMapOf<String, ExceptionClass>()
-
-
-        @OptIn(ExperimentalContracts::class)
-        protected fun getOrCreateExceptionClass(name: String): ExceptionClass {
-            return op.withLock {
-                existingErrorClasses.getOrPut(name) {
-                    ExceptionClass(name, Root)
-                }
-            }
-        }
-
-        /**
-         * Get [ObjClass] for error class by name if exists.
-         */
-        @OptIn(ExperimentalContracts::class)
-        fun getErrorClass(name: String): ObjClass? = op.withLock {
-            existingErrorClasses[name]
-        }
-
-        fun addExceptionsToContext(context: Context) {
-            context.addConst("Exception", Root)
-            existingErrorClasses["Exception"] = Root
-            for (name in listOf(
-                "NullReferenceException",
-                "AssertionFailedException",
-                "ClassCastException",
-                "IndexOutOfBoundsException",
-                "IllegalArgumentException",
-                "NoSuchElementException",
-                "IllegalAssignmentException",
-                "SymbolNotDefinedException",
-                "IterationEndException",
-                "AccessException",
-                "UnknownException",
-            )) {
-                context.addConst(name, getOrCreateExceptionClass(name))
-            }
-        }
-    }
-}
-
-class ObjNullReferenceException(context: Context) : ObjException("NullReferenceException", context, "object is null")
-
-class ObjAssertionFailedException(context: Context, message: String) :
-    ObjException("AssertionFailedException", context, message)
-
-class ObjClassCastException(context: Context, message: String) : ObjException("ClassCastException", context, message)
-class ObjIndexOutOfBoundsException(context: Context, message: String = "index out of bounds") :
-    ObjException("IndexOutOfBoundsException", context, message)
-
-class ObjIllegalArgumentException(context: Context, message: String = "illegal argument") :
-    ObjException("IllegalArgumentException", context, message)
-
-@Suppress("unused")
-class ObjNoSuchElementException(context: Context, message: String = "no such element") :
-    ObjException("IllegalArgumentException", context, message)
-
-class ObjIllegalAssignmentException(context: Context, message: String = "illegal assignment") :
-    ObjException("NoSuchElementException", context, message)
-
-class ObjSymbolNotDefinedException(context: Context, message: String = "symbol is not defined") :
-    ObjException("SymbolNotDefinedException", context, message)
-
-class ObjIterationFinishedException(context: Context) :
-    ObjException("IterationEndException", context, "iteration finished")
-
-class ObjAccessException(context: Context, message: String = "access not allowed error") :
-    ObjException("AccessException", context, message)
-
-class ObjUnknownException(context: Context, message: String = "access not allowed error") :
-    ObjException("UnknownException", context, message)

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

@@ -1,38 +0,0 @@
-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/ObjBool.kt

@@ -1,31 +0,0 @@
-package net.sergeych.lyng
-
-data class ObjBool(val value: Boolean) : Obj() {
-    override val asStr by lazy { ObjString(value.toString()) }
-
-    override suspend fun compareTo(context: Context, other: Obj): Int {
-        if (other !is ObjBool) return -2
-        return value.compareTo(other.value)
-    }
-
-    override fun toString(): String = value.toString()
-
-    override val objClass: ObjClass = type
-
-    override suspend fun logicalNot(context: Context): Obj = ObjBool(!value)
-
-    override suspend fun logicalAnd(context: Context, other: Obj): Obj = ObjBool(value && other.toBool())
-
-    override suspend fun logicalOr(context: Context, other: Obj): Obj = ObjBool(value || other.toBool())
-
-    override suspend fun toKotlin(context: Context): Any {
-        return value
-    }
-
-    companion object {
-        val type = ObjClass("Bool")
-    }
-}
-
-val ObjTrue = ObjBool(true)
-val ObjFalse = ObjBool(false)

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

@@ -1,19 +0,0 @@
-package net.sergeych.lyng
-
-class ObjChar(val value: Char): Obj() {
-
-    override val objClass: ObjClass = type
-
-    override suspend fun compareTo(context: Context, other: Obj): Int =
-        (other as? ObjChar)?.let { value.compareTo(it.value) } ?: -1
-
-    override fun toString(): String = value.toString()
-
-    override fun inspect(): String = "'$value'"
-
-    companion object {
-        val type = ObjClass("Char").apply {
-            addFn("code") { ObjInt(thisAs<ObjChar>().value.code.toLong()) }
-        }
-    }
-}

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

@@ -1,73 +0,0 @@
-package net.sergeych.lyng
-
-val ObjClassType by lazy { ObjClass("Class") }
-
-open class ObjClass(
-    val className: String,
-    vararg val parents: ObjClass,
-) : Obj() {
-
-    var instanceConstructor: Statement? = null
-
-    val allParentsSet: Set<ObjClass> =
-        parents.flatMap {
-            listOf(it) + it.allParentsSet
-        }.toMutableSet()
-
-    override val objClass: ObjClass by lazy { ObjClassType }
-
-    // members: fields most often
-    private val members = mutableMapOf<String, ObjRecord>()
-
-    override fun toString(): String = className
-
-    override suspend fun compareTo(context: Context, other: Obj): Int = if (other === this) 0 else -1
-
-    override suspend fun callOn(context: Context): Obj {
-        val instance = ObjInstance(this)
-        instance.instanceContext = context.copy(newThisObj = instance,args = context.args)
-        if (instanceConstructor != null) {
-            instanceConstructor!!.execute(instance.instanceContext)
-        }
-        return instance
-    }
-
-    fun defaultInstance(): Obj = object : Obj() {
-        override val objClass: ObjClass = this@ObjClass
-    }
-
-    fun createField(
-        name: String,
-        initialValue: Obj,
-        isMutable: Boolean = false,
-        visibility: Visibility = Visibility.Public,
-        pos: Pos = Pos.builtIn
-    ) {
-        val existing = members[name] ?: allParentsSet.firstNotNullOfOrNull { it.members[name] }
-        if( existing?.isMutable == false)
-            throw ScriptError(pos, "$name is already defined in $objClass or one of its supertypes")
-        members[name] = ObjRecord(initialValue, isMutable, visibility)
-    }
-
-    fun addFn(name: String, isOpen: Boolean = false, code: suspend Context.() -> Obj) {
-        createField(name, statement { code() }, isOpen)
-    }
-
-    fun addConst(name: String, value: Obj) = createField(name, value, isMutable = false)
-
-
-    /**
-     * Get instance member traversing the hierarchy if needed. Its meaning is different for different objects.
-     */
-    fun getInstanceMemberOrNull(name: String): ObjRecord? {
-        members[name]?.let { return it }
-        allParentsSet.forEach { parent -> parent.getInstanceMemberOrNull(name)?.let { return it } }
-        return rootObjectType.members[name]
-    }
-
-    fun getInstanceMember(atPos: Pos, name: String): ObjRecord =
-        getInstanceMemberOrNull(name)
-            ?: throw ScriptError(atPos, "symbol doesn't exist: $name")
-}
-
-

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

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

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

@@ -1,55 +0,0 @@
-package net.sergeych.lyng
-
-class ObjInstance(override val objClass: ObjClass) : Obj() {
-
-    internal lateinit var instanceContext: Context
-
-    override suspend fun readField(context: Context, name: String): ObjRecord {
-        return instanceContext[name]?.let {
-            if (it.visibility.isPublic)
-                it
-            else
-                context.raiseError(ObjAccessException(context, "can't access non-public field $name"))
-        }
-            ?: super.readField(context, name)
-    }
-
-    override suspend fun writeField(context: Context, name: String, newValue: Obj) {
-        instanceContext[name]?.let { f ->
-            if (!f.visibility.isPublic)
-                ObjIllegalAssignmentException(context, "can't assign to non-public field $name")
-            if (!f.isMutable) ObjIllegalAssignmentException(context, "can't reassign val $name").raise()
-            if (f.value.assign(context, newValue) == null)
-                f.value = newValue
-        } ?: super.writeField(context, name, newValue)
-    }
-
-    override suspend fun invokeInstanceMethod(context: Context, name: String, args: Arguments): Obj =
-        instanceContext[name]?.let {
-            if (it.visibility.isPublic)
-                it.value.invoke(context, this, args)
-            else
-                context.raiseError(ObjAccessException(context, "can't invoke non-public method $name"))
-        }
-            ?: super.invokeInstanceMethod(context, name, args)
-
-    private val publicFields: Map<String, ObjRecord>
-        get() = instanceContext.objects.filter { it.value.visibility.isPublic }
-
-    override fun toString(): String {
-        val fields = publicFields.map { "${it.key}=${it.value.value}" }.joinToString(",")
-        return "${objClass.className}($fields)"
-    }
-
-    override suspend fun compareTo(context: Context, other: Obj): Int {
-        if (other !is ObjInstance) return -1
-        if (other.objClass != objClass) return -1
-        for (f in publicFields) {
-            val a = f.value.value
-            val b = other.instanceContext[f.key]!!.value
-            val d = a.compareTo(context, b)
-            if (d != 0) return d
-        }
-        return 0
-    }
-}

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

@@ -1,99 +0,0 @@
-package net.sergeych.lyng
-
-data class ObjInt(var value: Long) : Obj(), Numeric {
-    override val asStr get() = ObjString(value.toString())
-    override val longValue get() = value
-    override val doubleValue get() = value.toDouble()
-    override val toObjInt get() = this
-    override val toObjReal = ObjReal(doubleValue)
-
-    override fun byValueCopy(): Obj = ObjInt(value)
-
-    override fun hashCode(): Int {
-        return value.hashCode()
-    }
-
-    override suspend fun getAndIncrement(context: Context): Obj {
-        return ObjInt(value).also { value++ }
-    }
-
-    override suspend fun getAndDecrement(context: Context): Obj {
-        return ObjInt(value).also { value-- }
-    }
-
-    override suspend fun incrementAndGet(context: Context): Obj {
-        return ObjInt(++value)
-    }
-
-    override suspend fun decrementAndGet(context: Context): Obj {
-        return ObjInt(--value)
-    }
-
-    override suspend fun compareTo(context: Context, other: Obj): Int {
-        if (other !is Numeric) return -2
-        return value.compareTo(other.doubleValue)
-    }
-
-    override fun toString(): String = value.toString()
-
-    override val objClass: ObjClass = type
-
-    override suspend fun plus(context: Context, other: Obj): Obj =
-        if (other is ObjInt)
-            ObjInt(this.value + other.value)
-        else
-            ObjReal(this.doubleValue + other.toDouble())
-
-    override suspend fun minus(context: Context, other: Obj): Obj =
-        if (other is ObjInt)
-            ObjInt(this.value - other.value)
-        else
-            ObjReal(this.doubleValue - other.toDouble())
-
-    override suspend fun mul(context: Context, other: Obj): Obj =
-        if (other is ObjInt) {
-            ObjInt(this.value * other.value)
-        } else ObjReal(this.value * other.toDouble())
-
-    override suspend fun div(context: Context, other: Obj): Obj =
-        if (other is ObjInt)
-            ObjInt(this.value / other.value)
-        else ObjReal(this.value / other.toDouble())
-
-    override suspend fun mod(context: Context, other: Obj): Obj =
-        if (other is ObjInt)
-            ObjInt(this.value % other.value)
-        else ObjReal(this.value.toDouble() % other.toDouble())
-
-    /**
-     * We are by-value type ([byValueCopy] is implemented) so we can do in-place
-     * assignment
-     */
-    override suspend fun assign(context: Context, other: Obj): Obj? {
-        return if (other is ObjInt) {
-            value = other.value
-            this
-        } else null
-    }
-
-    override suspend fun toKotlin(context: Context): Any {
-        return value
-    }
-
-    override fun equals(other: Any?): Boolean {
-        if (this === other) return true
-        if (other == null || this::class != other::class) return false
-
-        other as ObjInt
-
-        return value == other.value
-    }
-
-    companion object {
-        val Zero = ObjInt(0)
-        val One = ObjInt(1)
-        val type = ObjClass("Int")
-    }
-}
-
-fun Int.toObj() = ObjInt(this.toLong())

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

@@ -1,89 +0,0 @@
-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("toMap") {
-            val result = mutableListOf<Obj>()
-            val it = thisObj.invokeInstanceMethod(this, "iterator")
-            while (it.invokeInstanceMethod(this, "hasNext").toBool()) {
-                result += it.invokeInstanceMethod(this, "next")
-            }
-            ObjMap(ObjMap.listToMap(this, 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

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

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

@@ -1,39 +0,0 @@
-@file:Suppress("unused")
-
-package net.sergeych.lyng
-
-/**
- * Iterator wrapper to allow Kotlin collections to be returned from Lyng objects;
- * each object is converted to a Lyng object.
- */
-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() }
-        }
-
-    }
-}
-
-/**
- * Propagate kotlin iterator that already produces Lyng objects, no conversion
- * is applied
- */
-class ObjKotlinObjIterator(val iterator: Iterator<Obj>) : Obj() {
-
-    override val objClass = type
-
-    companion object {
-        val type = ObjClass("KotlinIterator", ObjIterator).apply {
-            addFn("next") {
-                thisAs<ObjKotlinObjIterator>().iterator.next()
-            }
-            addFn("hasNext") { thisAs<ObjKotlinIterator>().iterator.hasNext().toObj() }
-        }
-
-    }
-}

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

@@ -1,114 +0,0 @@
-package net.sergeych.lyng
-
-class ObjMapEntry(val key: Obj, val value: Obj) : Obj() {
-
-    override suspend fun compareTo(context: Context, other: Obj): Int {
-        if (other !is ObjMapEntry) return -1
-        val c = key.compareTo(context, other.key)
-        if (c != 0) return c
-        return value.compareTo(context, other.value)
-    }
-
-    override suspend fun getAt(context: Context, index: Obj): Obj = when (index.toInt()) {
-        0 -> key
-        1 -> value
-        else -> context.raiseIndexOutOfBounds()
-    }
-
-    override fun toString(): String {
-        return "$key=>$value"
-    }
-
-    override val objClass = type
-
-    companion object {
-        val type = object : ObjClass("MapEntry", ObjArray) {
-            override suspend fun callOn(context: Context): Obj {
-                return ObjMapEntry(context.requiredArg<Obj>(0), context.requiredArg<Obj>(1))
-            }
-        }.apply {
-            addFn("key") { thisAs<ObjMapEntry>().key }
-            addFn("value") { thisAs<ObjMapEntry>().value }
-            addFn("size") { 2.toObj() }
-        }
-    }
-}
-
-class ObjMap(val map: MutableMap<Obj, Obj>) : Obj() {
-
-    override val objClass = type
-
-    override suspend fun getAt(context: Context, index: Obj): Obj =
-        map.getOrElse(index) { context.raiseNoSuchElement() }
-
-    override suspend fun contains(context: Context, other: Obj): Boolean {
-        return other in map
-    }
-
-    override suspend fun compareTo(context: Context, other: Obj): Int {
-        if( other is ObjMap && other.map == map) return 0
-        return -1
-    }
-    override fun toString(): String = map.toString()
-
-    companion object {
-
-        suspend fun listToMap(context: Context, list: List<Obj>): MutableMap<Obj, Obj> {
-            val map = mutableMapOf<Obj, Obj>()
-            if (list.isEmpty()) return map
-
-            val first = list.first()
-            if (first.isInstanceOf(ObjArray)) {
-                if (first.invokeInstanceMethod(context, "size").toInt() != 2)
-                    context.raiseIllegalArgument(
-                        "list to construct map entry should exactly be 2 element Array like [key,value], got $list"
-                    )
-            } else context.raiseIllegalArgument("first element of map list be a Collection of 2 elements; got $first")
-
-
-
-            list.forEach {
-                map[it.getAt(context, ObjInt.Zero)] = it.getAt(context, ObjInt.One)
-            }
-            return map
-        }
-
-
-        val type = object : ObjClass("Map", ObjCollection) {
-            override suspend fun callOn(context: Context): Obj {
-                return ObjMap(listToMap(context, context.args.list))
-            }
-        }.apply {
-            addFn("getOrNull") {
-                val key = args.firstAndOnly(pos)
-                thisAs<ObjMap>().map.getOrElse(key) { ObjNull }
-            }
-            addFn("getOrPut") {
-                val key = requiredArg<Obj>(0)
-                thisAs<ObjMap>().map.getOrPut(key) {
-                    val lambda = requiredArg<Statement>(1)
-                    lambda.execute(this)
-                }
-            }
-            addFn("size") {
-                thisAs<ObjMap>().map.size.toObj()
-            }
-            addFn("remove") {
-                thisAs<ObjMap>().map.remove(requiredArg<Obj>(0))?.toObj() ?: ObjNull
-            }
-            addFn("clear") {
-                thisAs<ObjMap>().map.clear()
-                thisObj
-            }
-            addFn("keys") {
-                thisAs<ObjMap>().map.keys.toObj()
-            }
-            addFn("values") {
-                ObjList(thisAs<ObjMap>().map.values.toMutableList())
-            }
-            addFn("iterator") {
-                ObjKotlinIterator(thisAs<ObjMap>().map.entries.iterator())
-            }
-        }
-    }
-}

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

@@ -1,104 +0,0 @@
-package net.sergeych.lyng
-
-class ObjRange(val start: Obj?, val end: Obj?, val isEndInclusive: Boolean) : Obj() {
-
-    val isOpenStart by lazy { start == null || start.isNull }
-    val isOpenEnd by lazy { end == null || end.isNull }
-
-    override val objClass: ObjClass = type
-
-    override fun toString(): String {
-        val result = StringBuilder()
-        result.append("${start?.inspect() ?: '∞'} ..")
-        if (!isEndInclusive) result.append('<')
-        result.append(" ${end?.inspect() ?: '∞'}")
-        return result.toString()
-    }
-
-    suspend fun containsRange(context: Context, other: ObjRange): Boolean {
-        if (start != null) {
-            // our start is not -∞ so other start should be GTE or is not contained:
-            if (other.start != null && start.compareTo(context, other.start) > 0) return false
-        }
-        if (end != null) {
-            // same with the end: if it is open, it can't be contained in ours:
-            if (other.end == null) return false
-            // both exists, now there could be 4 cases:
-            return when {
-                other.isEndInclusive && isEndInclusive ->
-                    end.compareTo(context, other.end) >= 0
-
-                !other.isEndInclusive && !isEndInclusive ->
-                    end.compareTo(context, other.end) >= 0
-
-                other.isEndInclusive && !isEndInclusive ->
-                    end.compareTo(context, other.end) > 0
-
-                !other.isEndInclusive && isEndInclusive ->
-                    end.compareTo(context, other.end) >= 0
-
-                else -> throw IllegalStateException("unknown comparison")
-            }
-        }
-        return true
-    }
-
-    override suspend fun contains(context: Context, other: Obj): Boolean {
-
-        if (other is ObjRange)
-            return containsRange(context, other)
-
-        if (start == null && end == null) return true
-        if (start != null) {
-            if (start.compareTo(context, other) > 0) return false
-        }
-        if (end != null) {
-            val cmp = end.compareTo(context, other)
-            if (isEndInclusive && cmp < 0 || !isEndInclusive && cmp <= 0) return false
-        }
-        return true
-    }
-
-    val isIntRange: Boolean by lazy {
-        start is ObjInt && end is ObjInt
-    }
-
-    val isCharRange: Boolean by lazy {
-        start is ObjChar && end is ObjChar
-    }
-
-    override suspend fun compareTo(context: Context, other: Obj): Int {
-        return (other as? ObjRange)?.let {
-            if( start == other.start && end == other.end ) 0 else -1
-        }
-            ?: -1
-    }
-
-    companion object {
-        val type = ObjClass("Range", ObjIterable).apply {
-            addFn("start") {
-                thisAs<ObjRange>().start ?: ObjNull
-            }
-            addFn("end") {
-                thisAs<ObjRange>().end ?: ObjNull
-            }
-            addFn("isOpen") {
-                thisAs<ObjRange>().let { it.start == null || it.end == null }.toObj()
-            }
-            addFn("isIntRange") {
-                thisAs<ObjRange>().isIntRange.toObj()
-            }
-            addFn("isCharRange") {
-                thisAs<ObjRange>().isCharRange.toObj()
-            }
-            addFn("isEndInclusive") {
-                thisAs<ObjRange>().isEndInclusive.toObj()
-            }
-            addFn("iterator") {
-                val self = thisAs<ObjRange>()
-                ObjRangeIterator(self).apply { init() }
-            }
-        }
-    }
-}
-

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

@@ -1,69 +0,0 @@
-package net.sergeych.lyng
-
-import kotlin.math.floor
-import kotlin.math.roundToLong
-
-data class ObjReal(val value: Double) : Obj(), Numeric {
-    override val asStr by lazy { ObjString(value.toString()) }
-    override val longValue: Long by lazy { floor(value).toLong() }
-    override val doubleValue: Double by lazy { value }
-    override val toObjInt: ObjInt by lazy { ObjInt(longValue) }
-    override val toObjReal: ObjReal by lazy { ObjReal(value) }
-
-    override val objClass: ObjClass = type
-
-    override fun byValueCopy(): Obj = ObjReal(value)
-
-    override suspend fun compareTo(context: Context, other: Obj): Int {
-        if (other !is Numeric) return -2
-        return value.compareTo(other.doubleValue)
-    }
-
-    override fun toString(): String = value.toString()
-
-    override fun hashCode(): Int {
-        return value.hashCode()
-    }
-
-    override suspend fun plus(context: Context, other: Obj): Obj =
-        ObjReal(this.value + other.toDouble())
-
-    override suspend fun minus(context: Context, other: Obj): Obj =
-        ObjReal(this.value - other.toDouble())
-
-    override suspend fun mul(context: Context, other: Obj): Obj =
-        ObjReal(this.value * other.toDouble())
-
-    override suspend fun div(context: Context, other: Obj): Obj =
-        ObjReal(this.value / other.toDouble())
-
-    override suspend fun mod(context: Context, other: Obj): Obj =
-        ObjReal(this.value % other.toDouble())
-
-    /**
-     * Returns unboxed Double value
-     */
-    override suspend fun toKotlin(context: Context): Any {
-        return value
-    }
-
-    override fun equals(other: Any?): Boolean {
-        if (this === other) return true
-        if (other == null || this::class != other::class) return false
-
-        other as ObjReal
-
-        return value == other.value
-    }
-
-    companion object {
-        val type: ObjClass = ObjClass("Real").apply {
-            createField(
-                "roundToInt",
-                statement(Pos.builtIn) {
-                    (it.thisObj as ObjReal).value.roundToLong().toObj()
-                },
-            )
-        }
-    }
-}

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

@@ -1,99 +0,0 @@
-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.raiseIllegalArgument("set operator * requires another set")
-    }
-
-    override suspend fun minus(context: Context, other: Obj): Obj {
-        if (other !is ObjSet)
-            context.raiseIllegalArgument("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/ObjString.kt

@@ -1,117 +0,0 @@
-package net.sergeych.lyng
-
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
-import net.sergeych.sprintf.sprintf
-
-@Serializable
-@SerialName("string")
-data class ObjString(val value: String) : Obj() {
-
-//    fun normalize(context: Context, index: Int, allowsEndInclusive: Boolean = false): Int {
-//        val i = if (index < 0) value.length + index else index
-//        if (allowsEndInclusive && i == value.length) return i
-//        if (i !in value.indices) context.raiseError("index $index out of bounds for length ${value.length} of \"$value\"")
-//        return i
-//    }
-
-
-    override suspend fun compareTo(context: Context, other: Obj): Int {
-        if (other !is ObjString) return -2
-        return this.value.compareTo(other.value)
-    }
-
-    override fun toString(): String = value
-
-    override val asStr: ObjString by lazy { this }
-
-    override fun inspect(): String {
-        return "\"$value\""
-    }
-
-    override val objClass: ObjClass
-        get() = type
-
-    override suspend fun plus(context: Context, other: Obj): Obj {
-        return ObjString(value + other.asStr.value)
-    }
-
-    override suspend fun getAt(context: Context, index: Obj): Obj {
-        if( index is ObjInt ) return ObjChar(value[index.toInt()])
-        if( index is ObjRange ) {
-            val start = if(index.start == null || index.start.isNull) 0 else  index.start.toInt()
-            val end = if( index.end  == null || index.end.isNull ) value.length else  {
-                val e = index.end.toInt()
-                if( index.isEndInclusive) e + 1 else e
-            }
-            return ObjString(value.substring(start, end))
-        }
-        context.raiseIllegalArgument("String index must be Int or Range")
-    }
-
-    override fun hashCode(): Int {
-        return value.hashCode()
-    }
-
-    override suspend fun callOn(context: Context): Obj {
-        return ObjString(this.value.sprintf(*context.args.toKotlinList(context).toTypedArray()))
-    }
-
-    override suspend fun contains(context: Context, other: Obj): Boolean {
-        return if (other is ObjString)
-            value.contains(other.value)
-        else if (other is ObjChar)
-            value.contains(other.value)
-        else context.raiseIllegalArgument("String.contains can't take $other")
-    }
-
-    override fun equals(other: Any?): Boolean {
-        if (this === other) return true
-        if (other == null || this::class != other::class) return false
-
-        other as ObjString
-
-        return value == other.value
-    }
-
-    companion object {
-        val type = ObjClass("String").apply {
-            addFn("startsWith") {
-                ObjBool(thisAs<ObjString>().value.startsWith(requiredArg<ObjString>(0).value))
-            }
-            addFn("endsWith") {
-                ObjBool(thisAs<ObjString>().value.endsWith(requiredArg<ObjString>(0).value))
-            }
-            addConst("length",
-                statement { ObjInt(thisAs<ObjString>().value.length.toLong()) }
-            )
-            addFn("takeLast") {
-                thisAs<ObjString>().value.takeLast(
-                    requiredArg<ObjInt>(0).toInt()
-                ).let(::ObjString)
-            }
-            addFn("take") {
-                thisAs<ObjString>().value.take(
-                    requiredArg<ObjInt>(0).toInt()
-                ).let(::ObjString)
-            }
-            addFn("drop") {
-                thisAs<ObjString>().value.drop(
-                    requiredArg<ObjInt>(0).toInt()
-                ).let(::ObjString)
-            }
-            addFn("dropLast") {
-                thisAs<ObjString>().value.dropLast(
-                    requiredArg<ObjInt>(0).toInt()
-                ).let(::ObjString)
-            }
-            addFn("lower") {
-                thisAs<ObjString>().value.lowercase().let(::ObjString)
-            }
-            addFn("upper") {
-                thisAs<ObjString>().value.uppercase().let(::ObjString)
-            }
-            addFn("size") { ObjInt(thisAs<ObjString>().value.length.toLong()) }
-        }
-    }
-}

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

@@ -1,12 +1,29 @@
+/*
+ * 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.
+ *
+ */
+
 package net.sergeych.lyng
 
 val digitsSet = ('0'..'9').toSet()
 val digits = { d: Char -> d in digitsSet }
 val hexDigits = digitsSet + ('a'..'f') + ('A'..'F')
-val idNextChars = { d: Char -> d.isLetter() || d == '_' || d.isDigit() }
+val idNextChars = { d: Char -> d.isLetter() || d == '_' || d.isDigit() || d == '$' || d == '~' }
 
 @Suppress("unused")
-val idFirstChars = { d: Char -> d.isLetter() || d == '_' }
+val idFirstChars = { d: Char -> d.isLetter() || d == '_' || d == '$' }
 
 fun parseLyng(source: Source): List<Token> {
     val p = Parser(fromPos = source.startPos)
@@ -50,13 +67,16 @@ private class Parser(fromPos: Pos) {
                             pos.advance()
                             Token("===", from, Token.Type.REF_EQ)
                         }
+
                         else -> Token("==", from, Token.Type.EQ)
                     }
-                } else if( currentChar == '>' ) {
+                } else if (currentChar == '>') {
                     pos.advance()
                     Token("=>", from, Token.Type.EQARROW)
-                }
-                else
+                } else if (currentChar == '~') {
+                    pos.advance()
+                    Token("=~", from, Token.Type.MATCH)
+                } else
                     Token("=", from, Token.Type.ASSIGN)
             }
 
@@ -109,7 +129,7 @@ private class Parser(fromPos: Pos) {
             '/' -> when (currentChar) {
                 '/' -> {
                     pos.advance()
-                    Token(loadToEnd().trim(), from, Token.Type.SINLGE_LINE_COMMENT)
+                    Token(loadToEndOfLine().trim(), from, Token.Type.SINLGE_LINE_COMMENT)
                 }
 
                 '*' -> {
@@ -210,6 +230,9 @@ private class Parser(fromPos: Pos) {
                             Token("!==", from, Token.Type.REF_NEQ)
                         } else
                             Token("!=", from, Token.Type.NEQ)
+                    } else if (currentChar == '~') {
+                        pos.advance()
+                        Token("!~", from, Token.Type.NOTMATCH)
                     } else
                         Token("!", from, Token.Type.NOT)
             }
@@ -250,7 +273,7 @@ private class Parser(fromPos: Pos) {
 
             in digitsSet -> {
                 pos.back()
-                decodeNumber(loadChars(digits), from)
+                decodeNumber(loadChars { it in digitsSet || it == '_' }, from)
             }
 
             '\'' -> {
@@ -274,7 +297,7 @@ private class Parser(fromPos: Pos) {
             }
 
             '?' -> {
-                when(currentChar.also { pos.advance() }) {
+                when (currentChar.also { pos.advance() }) {
                     ':' -> Token("??", from, Token.Type.ELVIS)
                     '?' -> Token("??", from, Token.Type.ELVIS)
                     '.' -> Token("?.", from, Token.Type.NULL_COALESCE)
@@ -293,7 +316,7 @@ private class Parser(fromPos: Pos) {
                 // Labels processing is complicated!
                 // some@ statement: label 'some', ID 'statement'
                 // statement@some: ID 'statement', LABEL 'some'!
-                if (ch.isLetter() || ch == '_') {
+                if (idNextChars(ch)) {
                     val text = ch + loadChars(idNextChars)
                     if (currentChar == '@') {
                         pos.advance()
@@ -375,6 +398,31 @@ private class Parser(fromPos: Pos) {
 
     private val currentChar: Char get() = pos.currentChar
 
+    private fun fixMultilineStringLiteral(source: String): String {
+        val sizes = mutableListOf<Int>()
+        val lines = source.lines().toMutableList()
+        if (lines.size == 0) return ""
+        if (lines[0].isBlank()) lines.removeFirst()
+        if (lines.isEmpty()) return ""
+        if (lines.last().isBlank()) lines.removeLast()
+
+        val normalized = lines.map { l ->
+            if (l.isBlank()) {
+                sizes.add(-1)
+                ""
+            } else {
+                val margin = leftMargin(l)
+                sizes += margin
+                " ".repeat(margin) + l.trim()
+            }
+        }
+        val commonMargin = sizes.filter { it >= 0 }.min()
+        val fixed = if (commonMargin < 1) lines else normalized.map {
+            if (it.isBlank()) "" else it.drop(commonMargin)
+        }
+        return fixed.joinToString("\n")
+    }
+
     private fun loadStringToken(): Token {
         val start = currentPos
 
@@ -383,20 +431,46 @@ private class Parser(fromPos: Pos) {
 //        start = start.back()
 
         val sb = StringBuilder()
+        var newlineDetected = false
         while (currentChar != '"') {
             if (pos.end) throw ScriptError(start, "unterminated string started there")
             when (currentChar) {
                 '\\' -> {
                     pos.advance() ?: raise("unterminated string")
                     when (currentChar) {
-                        'n' -> sb.append('\n')
-                        'r' -> sb.append('\r')
-                        't' -> sb.append('\t')
-                        '"' -> sb.append('"')
-                        else -> sb.append('\\').append(currentChar)
+                        'n' -> {
+                            sb.append('\n'); pos.advance()
+                        }
+
+                        'r' -> {
+                            sb.append('\r'); pos.advance()
+                        }
+
+                        't' -> {
+                            sb.append('\t'); pos.advance()
+                        }
+
+                        '"' -> {
+                            sb.append('"'); pos.advance()
+                        }
+
+                        '\\' -> {
+                            sb.append('\\'); pos.advance()
+                        }
+
+                        else -> {
+                            sb.append('\\').append(currentChar)
+                            pos.advance()
+                        }
                     }
                 }
 
+                '\n', '\r' -> {
+                    newlineDetected = true
+                    sb.append(currentChar)
+                    pos.advance()
+                }
+
                 else -> {
                     sb.append(currentChar)
                     pos.advance()
@@ -404,7 +478,10 @@ private class Parser(fromPos: Pos) {
             }
         }
         pos.advance()
-        return Token(sb.toString(), start, Token.Type.STRING)
+
+        val result = sb.toString().let { if (newlineDetected) fixMultilineStringLiteral(it) else it }
+
+        return Token(result, start, Token.Type.STRING)
     }
 
     /**
@@ -445,7 +522,7 @@ private class Parser(fromPos: Pos) {
         }
     }
 
-    private fun loadToEnd(): String {
+    private fun loadToEndOfLine(): String {
         val result = StringBuilder()
         val l = pos.line
         do {
@@ -479,4 +556,10 @@ private class Parser(fromPos: Pos) {
         return null
     }
 
+    init {
+        // skip shebang
+        if (pos.readFragment("#!"))
+            loadToEndOfLine()
+    }
+
 }

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

@@ -1,3 +1,20 @@
+/*
+ * 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.
+ *
+ */
+
 package net.sergeych.lyng
 
 data class Pos(val source: Source, val line: Int, val column: Int) {
@@ -11,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

@@ -0,0 +1,266 @@
+/*
+ * 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.
+ *
+ */
+
+package net.sergeych.lyng
+
+import net.sergeych.lyng.obj.*
+import net.sergeych.lyng.pacman.ImportManager
+import net.sergeych.lyng.pacman.ImportProvider
+
+/**
+ * Scope is where local variables and methods are stored. Scope is also a parent scope for other scopes.
+ * Each block usually creates a scope. Accessing Lyng closures usually is done via a scope.
+ *
+ * To create default scope, use default `Scope()` constructor, it will create a scope with a parent
+ * module scope with default [ImportManager], you can access with [currentImportProvider] as needed.
+ *
+ * If you want to create [ModuleScope] by hand, try [currentImportProvider] and [ImportManager.newModule],
+ * or [ImportManager.newModuleAt].
+ *
+ *  There are special types of scopes:
+ *
+ *  - [ClosureScope] - scope used to apply a closure to some thisObj scope
+ */
+open class Scope(
+    val parent: Scope?,
+    val args: Arguments = Arguments.EMPTY,
+    var pos: Pos = Pos.builtIn,
+    var thisObj: Obj = ObjVoid,
+    var skipScopeCreation: Boolean = false,
+) {
+    open val packageName: String = "<anonymous package>"
+
+    constructor(
+        args: Arguments = Arguments.EMPTY,
+        pos: Pos = Pos.builtIn,
+    )
+            : this(Script.defaultImportManager.copy().newModuleAt(pos), args, pos)
+
+    fun raiseNotImplemented(what: String = "operation"): Nothing = raiseError("$what is not implemented")
+
+    @Suppress("unused")
+    fun raiseNPE(): Nothing = raiseError(ObjNullReferenceException(this))
+
+    @Suppress("unused")
+    fun raiseIndexOutOfBounds(message: String = "Index out of bounds"): Nothing =
+        raiseError(ObjIndexOutOfBoundsException(this, message))
+
+    @Suppress("unused")
+    fun raiseIllegalArgument(message: String = "Illegal argument error"): Nothing =
+        raiseError(ObjIllegalArgumentException(this, message))
+
+    @Suppress("unused")
+    fun raiseIllegalState(message: String = "Illegal argument error"): Nothing =
+        raiseError(ObjIllegalStateException(this, message))
+
+    fun raiseIllegalAssignment(message: String): Nothing =
+        raiseError(ObjIllegalAssignmentException(this, message))
+
+    @Suppress("unused")
+    fun raiseNoSuchElement(message: String = "No such element"): Nothing =
+        raiseError(ObjIllegalArgumentException(this, message))
+
+    fun raiseClassCastError(msg: String): Nothing = raiseError(ObjClassCastException(this, msg))
+
+    @Suppress("unused")
+    fun raiseSymbolNotFound(name: String): Nothing =
+        raiseError(ObjSymbolNotDefinedException(this, "symbol is not defined: $name"))
+
+    fun raiseError(message: String): Nothing {
+        throw ExecutionError(ObjException(this, message))
+    }
+
+    fun raiseError(obj: ObjException): Nothing {
+        throw ExecutionError(obj)
+    }
+
+    @Suppress("unused")
+    fun raiseNotFound(message: String="not found"): Nothing {
+        throw ExecutionError(ObjNotFoundException(this,message))
+    }
+
+    inline fun <reified T : Obj> requiredArg(index: Int): T {
+        if (args.list.size <= index) raiseError("Expected at least ${index + 1} argument, got ${args.list.size}")
+        return (args.list[index].byValueCopy() as? T)
+            ?: raiseClassCastError("Expected type ${T::class.simpleName}, got ${args.list[index]::class.simpleName}")
+    }
+
+    inline fun <reified T : Obj> requireOnlyArg(): T {
+        if (args.list.size != 1) raiseError("Expected exactly 1 argument, got ${args.list.size}")
+        return requiredArg(0)
+    }
+
+    @Suppress("unused")
+    fun requireExactCount(count: Int) {
+        if (args.list.size != count) {
+            raiseError("Expected exactly $count arguments, got ${args.list.size}")
+        }
+    }
+
+    fun requireNoArgs() {
+        if( args.list.isNotEmpty())
+            raiseError("This function does not accept any arguments")
+    }
+
+    inline fun <reified T : Obj> thisAs(): T {
+        var s: Scope? = this
+        do {
+            val t = s!!.thisObj
+            if (t is T) return t
+            s = s.parent
+        } while(s != null)
+        raiseClassCastError("Cannot cast ${thisObj.objClass.className} to ${T::class.simpleName}")
+    }
+
+    internal val objects = mutableMapOf<String, ObjRecord>()
+
+    open operator fun get(name: String): ObjRecord? =
+        if (name == "this") thisObj.asReadonly
+        else {
+            (objects[name]
+                ?: parent?.get(name)
+                ?: thisObj.objClass
+                    .getInstanceMemberOrNull(name)
+                    )
+        }
+
+    /**
+     * 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)
+
+    /**
+     * 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)
+
+    /**
+     * @return A child scope with the same arguments, position and [thisObj]
+     */
+    fun createChildScope() = Scope(this, args, pos, thisObj)
+
+    fun addItem(
+        name: String,
+        isMutable: Boolean,
+        value: Obj,
+        visibility: Visibility = Visibility.Public,
+        recordType: ObjRecord.Type = ObjRecord.Type.Other
+    ): ObjRecord {
+        return ObjRecord(value, isMutable, visibility,type = recordType).also { objects[name] = it }
+    }
+
+    fun getOrCreateNamespace(name: String): ObjClass {
+        val ns = objects.getOrPut(name) { ObjRecord(ObjNamespace(name), isMutable = false) }.value
+        return ns.objClass
+    }
+
+    inline fun addVoidFn(vararg names: String, crossinline fn: suspend Scope.() -> Unit) {
+        addFn<ObjVoid>(*names) {
+            fn(this)
+            ObjVoid
+        }
+    }
+
+    inline fun <reified T : Obj> addFn(vararg names: String, crossinline fn: suspend Scope.() -> T) {
+        val newFn = object : Statement() {
+            override val pos: Pos = Pos.builtIn
+
+            override suspend fun execute(scope: Scope): Obj = scope.fn()
+
+        }
+        for (name in names) {
+            addItem(
+                name,
+                false,
+                newFn
+            )
+        }
+    }
+
+    fun addConst(name: String, value: Obj) = addItem(name, false, value)
+
+    suspend fun eval(code: String): Obj =
+        eval(code.toSource())
+
+    suspend fun eval(source: Source): Obj {
+        return Compiler.compile(
+            source,
+            currentImportProvider
+        ).execute(this)
+    }
+
+    fun containsLocal(name: String): Boolean = name in objects
+
+    /**
+     * Some scopes can be imported into other scopes, like [ModuleScope]. Those must correctly implement this method.
+     * @param scope where to copy symbols from this module
+     * @param symbols symbols to import, ir present, only symbols keys will be imported renamed to corresponding values
+     */
+    open suspend fun importInto(scope: Scope, symbols: Map<String, String>? = null) {
+        scope.raiseError(ObjIllegalOperationException(scope, "Import is not allowed here: import $packageName"))
+    }
+
+    /**
+     * Find a first [ImportManager] in this Scope hierarchy. Normally there should be one. Found instance is cached.
+     *
+     * Use it to register your package sources, see [ImportManager] features.
+     *
+     * @throws IllegalStateException if there is no such manager (if you create some specific scope with no manager,
+     *      then you knew what you did)
+     */
+    val currentImportProvider: ImportProvider by lazy {
+        if (this is ModuleScope)
+            importProvider.getActualProvider()
+        else
+            parent?.currentImportProvider ?: throw IllegalStateException("this scope has no manager in the chain")
+    }
+
+    val importManager by lazy { (currentImportProvider as? ImportManager)
+        ?: throw IllegalStateException("this scope has no manager in the chain (provided $currentImportProvider") }
+
+    override fun toString(): String {
+        val contents = objects.entries.joinToString { "${if( it.value.isMutable ) "var" else "val" } ${it.key}=${it.value.value}" }
+        return "S[this=$thisObj $contents]"
+    }
+
+    fun trace(text: String="") {
+        println("trace Scope: $text ------------------")
+        var p = this.parent
+        var level = 0
+        while (p != null) {
+            println("     parent#${++level}: $p")
+            println("     ( ${p.args.list} )")
+            p = p.parent
+        }
+        println("--------------------")
+    }
+
+    open fun applyClosure(closure: Scope): Scope = ClosureScope(this, closure)
+
+    companion object {
+
+        fun new(): Scope =
+            Script.defaultImportManager.copy().newModuleAt(Pos.builtIn)
+    }
+}

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

@@ -1,31 +1,72 @@
+/*
+ * 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.
+ *
+ */
+
 package net.sergeych.lyng
 
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.yield
+import net.sergeych.lyng.obj.*
+import net.sergeych.lyng.pacman.ImportManager
+import net.sergeych.lyng.stdlib_included.rootLyng
+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(),
 //    private val catchReturn: Boolean = false,
 ) : Statement() {
 
-    override suspend fun execute(context: Context): Obj {
+    override suspend fun execute(scope: Scope): Obj {
         var lastResult: Obj = ObjVoid
         for (s in statements) {
-            lastResult = s.execute(context)
+            lastResult = s.execute(scope)
         }
         return lastResult
     }
 
-    suspend fun execute() = execute(defaultContext.copy(pos = pos))
+    suspend fun execute() = execute(
+        defaultImportManager.newStdScope()
+    )
 
     companion object {
-        val defaultContext: Context = Context().apply {
+
+        /**
+         * Create new scope using standard safe set of modules, using [defaultImportManager]. It is
+         * suspended as first time calls requires compilation of standard library or other
+         * asynchronous initialization.
+         */
+        suspend fun newScope(pos: Pos = Pos.builtIn) = defaultImportManager.newStdScope(pos)
+
+        internal val rootScope: Scope = Scope(null).apply {
             ObjException.addExceptionsToContext(this)
+            addFn("print") {
+                for ((i, a) in args.withIndex()) {
+                    if (i > 0) print(' ' + a.toString(this).value)
+                    else print(a.toString(this).value)
+                }
+                ObjVoid
+            }
             addFn("println") {
                 for ((i, a) in args.withIndex()) {
-                    if (i > 0) print(' ' + a.asStr.value)
-                    else print(a.asStr.value)
+                    if (i > 0) print(' ' + a.toString(this).value)
+                    else print(a.toString(this).value)
                 }
                 println()
                 ObjVoid
@@ -112,7 +153,7 @@ class Script(
             }
             addFn( "abs" ) {
                 val x = args.firstAndOnly()
-                if( x is ObjInt ) ObjInt( x.value.absoluteValue ) else ObjReal( x.toDouble().absoluteValue )
+                if( x is ObjInt) ObjInt( x.value.absoluteValue ) else ObjReal( x.toDouble().absoluteValue )
             }
 
             addVoidFn("assert") {
@@ -125,7 +166,13 @@ class Script(
                 val a = requiredArg<Obj>(0)
                 val b = requiredArg<Obj>(1)
                 if( a.compareTo(this, b) != 0 )
-                    raiseError(ObjAssertionFailedException(this,"Assertion failed: ${a.inspect()} == ${b.inspect()}"))
+                    raiseError(ObjAssertionFailedException(this,"Assertion failed: ${a.inspect(this)} == ${b.inspect(this)}"))
+            }
+            addVoidFn("assertNotEquals") {
+                val a = requiredArg<Obj>(0)
+                val b = requiredArg<Obj>(1)
+                if( a.compareTo(this, b) == 0 )
+                    raiseError(ObjAssertionFailedException(this,"Assertion failed: ${a.inspect(this)} != ${b.inspect(this)}"))
             }
             addFn("assertThrows") {
                 val code = requireOnlyArg<Statement>()
@@ -136,12 +183,37 @@ class Script(
                 catch( e: ExecutionError ) {
                     e.errorObject
                 }
-                catch (e: ScriptError) {
+                catch (_: ScriptError) {
                     ObjNull
                 }
                 result ?: raiseError(ObjAssertionFailedException(this,"Expected exception but nothing was thrown"))
             }
 
+            addFn("dynamic") {
+                ObjDynamic.create(this, requireOnlyArg())
+            }
+
+            addFn("require") {
+                val condition = requiredArg<ObjBool>(0)
+                if( !condition.value ) {
+                    val message = args.list.getOrNull(1)?.toString() ?: "requirement not met"
+                    raiseIllegalArgument(message)
+                }
+                ObjVoid
+            }
+            addFn("check") {
+                val condition = requiredArg<ObjBool>(0)
+                if( !condition.value ) {
+                    val message = args.list.getOrNull(1)?.toString() ?: "check failed"
+                    raiseIllegalState(message)
+                }
+                ObjVoid
+            }
+            addFn("traceScope") {
+                this.trace(args.getOrNull(0)?.toString() ?: "")
+                ObjVoid
+            }
+
             addVoidFn("delay") {
                 delay((this.args.firstAndOnly().toDouble()/1000.0).roundToLong())
             }
@@ -163,15 +235,69 @@ class Script(
             addConst("Iterable", ObjIterable)
             addConst("Collection", ObjCollection)
             addConst("Array", ObjArray)
+            addConst("RingBuffer", ObjRingBuffer.type)
             addConst("Class", ObjClassType)
 
+            addConst("Deferred", ObjDeferred.type)
+            addConst("CompletableDeferred", ObjCompletableDeferred.type)
+            addConst("Mutex", ObjMutex.type)
+
+            addConst("Regex", ObjRegex.type)
+
+            addFn("launch") {
+                val callable = requireOnlyArg<Statement>()
+                ObjDeferred(globalDefer {
+                    callable.execute(this@addFn)
+                })
+            }
+
+            addFn("yield") {
+                yield()
+                ObjVoid
+            }
+
+            addFn("flow") {
+                // important is: current context contains closure often used in call;
+                // we'll need it for the producer
+                ObjFlow(requireOnlyArg<Statement>(), this)
+            }
+
             val pi = ObjReal(PI)
             addConst("π", pi)
             getOrCreateNamespace("Math").apply {
                 addConst("PI", pi)
             }
+        }
 
+        val defaultImportManager: ImportManager by lazy {
+            ImportManager(rootScope, SecurityManager.allowAll).apply {
+                addTextPackages(
+                    rootLyng
+                )
+                addPackage("lyng.buffer") {
+                    it.addConst("Buffer", ObjBuffer.type)
+                    it.addConst("MutableBuffer", ObjMutableBuffer.type)
+                }
+                addPackage("lyng.serialization") {
+                    it.addConst("Lynon", ObjLynonClass)
+                }
+                addPackage("lyng.time") {
+                    it.addConst("Instant", ObjInstant.type)
+                    it.addConst("Duration", ObjDuration.type)
+                    it.addFn("delay") {
+                        val a = args.firstAndOnly()
+                        when(a) {
+                            is ObjInt -> delay(a.value * 1000)
+                            is ObjReal -> delay((a.value * 1000).roundToLong())
+                            is ObjDuration -> delay(a.duration)
+                            else -> raiseIllegalArgument("Expected Duration, Int or Real, got ${a.inspect(this)}")
+                        }
+                        ObjVoid
+                    }
+                }
+            }
 
         }
+
     }
 }

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

@@ -1,15 +1,38 @@
+/*
+ * 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.
+ *
+ */
+
 @file:Suppress("CanBeParameter")
 
 package net.sergeych.lyng
 
-open class ScriptError(val pos: Pos, val errorMessage: String,cause: Throwable?=null) : Exception(
+import net.sergeych.lyng.obj.ObjException
+
+open class ScriptError(val pos: Pos, val errorMessage: String, cause: Throwable? = null) : Exception(
     """
         $pos: Error: $errorMessage
         
         ${pos.currentLine}
-        ${"-".repeat(pos.column)}^
+        ${if( pos.column >= 0 ) "-".repeat(pos.column) + "^" else ""}
     """.trimIndent(),
     cause
 )
 
-class ExecutionError(val errorObject: ObjException) : ScriptError(errorObject.context.pos, errorObject.message)
+class ScriptFlowIsNoMoreCollected: Exception()
+
+class ExecutionError(val errorObject: ObjException) : ScriptError(errorObject.scope.pos, errorObject.message.value)
+
+class ImportException(pos: Pos, message: String) : ScriptError(pos, message)

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

@@ -0,0 +1,39 @@
+/*
+ * 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.
+ *
+ */
+
+package net.sergeych.lyng
+
+interface SecurityManager {
+    /**
+     * Check that any symbol from the corresponding module can be imported. If it returns false,
+     * the module will not be imported and no further processing will be done
+     */
+    fun canImportModule(name: String): Boolean
+
+    /**\
+     * if [canImportModule] this method allows fine-grained control over symbols.
+     */
+    fun canImportSymbol(moduleName: String, symbolName: String): Boolean = true
+
+    companion object {
+        val allowAll: SecurityManager = object : SecurityManager {
+            override fun canImportModule(name: String): Boolean = true
+            override fun canImportSymbol(moduleName: String, symbolName: String): Boolean = true
+        }
+    }
+
+}

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

@@ -1,9 +1,30 @@
+/*
+ * 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.
+ *
+ */
+
 package net.sergeych.lyng
 
+import net.sergeych.lyng.obj.ObjString
+
 class Source(val fileName: String, text: String) {
 
     val lines = text.lines().map { it.trimEnd() }
 
+    val objSourceName by lazy { ObjString(fileName) }
+
     companion object {
         val builtIn: Source by lazy { Source("built-in", "") }
         val UNKNOWN: Source by lazy { Source("UNKNOWN", "") }
@@ -12,4 +33,15 @@ class Source(val fileName: String, text: String) {
     val startPos: Pos = Pos(this, 0, 0)
 
     fun posAt(line: Int, column: Int): Pos = Pos(this, line, column)
+
+    fun extractPackageName(): String {
+        for ((n,line) in lines.withIndex()) {
+            if( line.isBlank() || line.isEmpty() )
+                continue
+            if( line.startsWith("package ") )
+                return line.substring(8).trim()
+            else throw ScriptError(Pos(this, n, 0),"package declaration expected")
+        }
+        throw ScriptError(Pos(this, 0, 0),"package declaration expected")
+    }
 }

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

@@ -1,18 +1,43 @@
+/*
+ * 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.
+ *
+ */
+
 package net.sergeych.lyng
 
 data class Token(val value: String, val pos: Pos, val type: Type) {
+    fun raiseSyntax(text: String): Nothing {
+        throw ScriptError(pos, text)
+    }
+
     val isComment: Boolean by lazy { type == Type.SINLGE_LINE_COMMENT || type == Type.MULTILINE_COMMENT }
 
+    fun isId(text: String) =
+        type == Type.ID && value == text
+
+
     @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,
         ASSIGN, PLUSASSIGN, MINUSASSIGN, STARASSIGN, SLASHASSIGN, PERCENTASSIGN,
         PLUS2, MINUS2,
         IN, NOTIN, IS, NOTIS,
-        EQ, NEQ, LT, LTE, GT, GTE, REF_EQ, REF_NEQ,
+        EQ, NEQ, LT, LTE, GT, GTE, REF_EQ, REF_NEQ, MATCH, NOTMATCH,
         SHUTTLE,
         AND, BITAND, OR, BITOR, NOT, BITNOT, DOT, ARROW, EQARROW, QUESTION, COLONCOLON,
         SINLGE_LINE_COMMENT, MULTILINE_COMMENT,

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

@@ -1,9 +1,31 @@
+/*
+ * 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.
+ *
+ */
+
+@file:Suppress("unused")
+
 package net.sergeych.lyng
 
 // this is highly experimental and subject to complete redesign
 // very soon
-sealed class TypeDecl {
+sealed class TypeDecl(val isNullable:Boolean = false) {
     // ??
 //    data class Fn(val argTypes: List<ArgsDeclaration.Item>, val retType: TypeDecl) : TypeDecl()
-    object Obj : TypeDecl()
+    object TypeAny : TypeDecl()
+    object TypeNullableAny : TypeDecl(true)
+
+    class Simple(val name: String,isNullable: Boolean) : TypeDecl(isNullable)
 }

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

@@ -1,3 +1,20 @@
+/*
+ * 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.
+ *
+ */
+
 package net.sergeych.lyng
 
 enum class Visibility {

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

@@ -1,3 +1,20 @@
+/*
+ * 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.
+ *
+ */
+
 package net.sergeych.lyng
 
 

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

@@ -0,0 +1,50 @@
+/*
+ * 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.
+ *
+ */
+
+
+package net.sergeych.lyng.obj
+
+import net.sergeych.lyng.Compiler
+import net.sergeych.lyng.Pos
+import net.sergeych.lyng.Scope
+import net.sergeych.lyng.ScriptError
+
+// avoid KDOC bug: keep it
+@Suppress("unused")
+typealias DocCompiler = Compiler
+/**
+ * When we need read-write access to an object in some abstract storage, we need Accessor,
+ * as in-site assigning is not always sufficient, in general case we need to replace the object
+ * in the storage.
+ *
+ * Note that assigning new value is more complex than just replacing the object, see how assignment
+ * operator is implemented in [Compiler.allOps].
+ */
+data class Accessor(
+    val getter: suspend (Scope) -> ObjRecord,
+    val setterOrNull: (suspend (Scope, Obj) -> Unit)?
+) {
+    /**
+     * Simplified constructor for immutable stores.
+     */
+    constructor(getter: suspend (Scope) -> ObjRecord) : this(getter, null)
+
+    /**
+     * Get the setter or throw.
+     */
+    fun setter(pos: Pos) = setterOrNull ?: throw ScriptError(pos, "can't assign value")
+}

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

@@ -0,0 +1,517 @@
+/*
+ * 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.
+ *
+ */
+
+package net.sergeych.lyng.obj
+
+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
+
+open class Obj {
+
+    open val isConst: Boolean = false
+
+    fun ensureNotConst(scope: Scope) {
+        if (isConst) scope.raiseError("can't assign to constant")
+    }
+
+    val isNull by lazy { this === ObjNull }
+
+    var isFrozen: Boolean = false
+
+//    private val monitor = Mutex()
+
+    //    private val memberMutex = Mutex()
+//    internal var parentInstances: MutableList<Obj> = mutableListOf()
+
+//    private val opInstances = ProtectedOp()
+
+    open suspend fun inspect(scope: Scope): String = toString(scope).value
+
+    /**
+     * Some objects are by-value, historically [ObjInt] and [ObjReal] are usually treated as such.
+     * When initializing a var with it, by value objects must be copied. By-reference ones aren't.
+     *
+     * Almost all objects are by-reference.
+     */
+    open fun byValueCopy(): Obj = this
+
+    @Suppress("SuspiciousEqualsCombination")
+    fun isInstanceOf(someClass: Obj) = someClass === objClass ||
+            objClass.allParentsSet.contains(someClass) ||
+            someClass == rootObjectType
+
+
+    suspend fun invokeInstanceMethod(scope: Scope, name: String, vararg args: Obj): Obj =
+        invokeInstanceMethod(scope, name, Arguments(args.toList()))
+
+    suspend inline fun <reified T : Obj> callMethod(
+        scope: Scope,
+        name: String,
+        args: Arguments = Arguments.EMPTY
+    ): T =
+        invokeInstanceMethod(scope, name, args) as T
+
+    /**
+     * Invoke a method of the object if exists
+     * it [onNotFoundResult] is not null, it returns it when symbol is not found
+     * otherwise throws [ObjSymbolNotDefinedException] object exception
+     */
+    open suspend fun invokeInstanceMethod(
+        scope: Scope,
+        name: String,
+        args: Arguments = Arguments.EMPTY,
+        onNotFoundResult: (() -> Obj?)? = null
+    ): Obj {
+        return objClass.getInstanceMemberOrNull(name)?.value?.invoke(
+            scope,
+            this,
+            args
+        )
+            ?: onNotFoundResult?.invoke()
+            ?: scope.raiseSymbolNotFound(name)
+    }
+
+    open suspend fun getInstanceMethod(
+        scope: Scope,
+        name: String,
+        args: Arguments = Arguments.EMPTY
+    ): Obj =
+        // note that getInstanceMember traverses the hierarchy
+        objClass.getInstanceMember(scope.pos, name).value
+
+//    fun getMemberOrNull(name: String): Obj? = objClass.getInstanceMemberOrNull(name)?.value
+
+    // methods that to override
+
+    open suspend fun compareTo(scope: Scope, other: Obj): Int {
+        scope.raiseNotImplemented()
+    }
+
+    open suspend fun contains(scope: Scope, other: Obj): Boolean {
+        return invokeInstanceMethod(scope, "contains", other).toBool()
+    }
+
+    /**
+     * Default toString implementation:
+     *
+     * - if the object is a string, returns it
+     * - otherwise, if not [calledFromLyng], calls Lyng override `toString()` if exists
+     * - otherwise, meaning either called from Lyng `toString`, or there is no
+     *   Lyng override, returns the object's Kotlin variant of `toString()
+     *
+     * Note on kotlin's `toString()`: it is preferred to use this, 'scoped` version,
+     * as it can execute Lyng code using the scope and being suspending one.
+     *
+     * @param scope the scope where the string representation was requested
+     * @param calledFromLyng true if called from Lyng's `toString`. Normally this parameter should be ignored,
+     *      but it is used to avoid endless recursion in [Obj.toString] base implementation
+     */
+    suspend open fun toString(scope: Scope,calledFromLyng: Boolean=false): ObjString {
+        return if (this is ObjString) this
+        else if( !calledFromLyng ) {
+            invokeInstanceMethod(scope, "toString") {
+                ObjString(this.toString())
+            } as ObjString
+        } else { ObjString(this.toString()) }
+    }
+
+    /**
+     * Class of the object: definition of member functions (top-level), etc.
+     * Note that using lazy allows to avoid endless recursion here
+     */
+    open val objClass: ObjClass = rootObjectType
+
+    open suspend fun plus(scope: Scope, other: Obj): Obj {
+        scope.raiseNotImplemented()
+    }
+
+    open suspend fun minus(scope: Scope, other: Obj): Obj {
+        scope.raiseNotImplemented()
+    }
+
+    open suspend fun negate(scope: Scope): Obj {
+        scope.raiseNotImplemented()
+    }
+
+    open suspend fun mul(scope: Scope, other: Obj): Obj {
+        scope.raiseNotImplemented()
+    }
+
+    open suspend fun div(scope: Scope, other: Obj): Obj {
+        scope.raiseNotImplemented()
+    }
+
+    open suspend fun mod(scope: Scope, other: Obj): Obj {
+        scope.raiseNotImplemented()
+    }
+
+    open suspend fun logicalNot(scope: Scope): Obj {
+        scope.raiseNotImplemented()
+    }
+
+    open suspend fun logicalAnd(scope: Scope, other: Obj): Obj {
+        scope.raiseNotImplemented()
+    }
+
+    open suspend fun logicalOr(scope: Scope, other: Obj): Obj {
+        scope.raiseNotImplemented()
+    }
+
+    open suspend fun operatorMatch(scope: Scope, other: Obj): Obj {
+        scope.raiseNotImplemented()
+    }
+
+    open suspend fun operatorNotMatch(scope: Scope, other: Obj): Obj {
+        return operatorMatch(scope,other).logicalNot(scope)
+    }
+
+    open suspend fun assign(scope: Scope, other: Obj): Obj? = null
+
+    open fun getValue(scope: Scope) = this
+
+    /**
+     * a += b
+     * if( the operation is not defined, it returns null and the compiler would try
+     * to generate it as 'this = this + other', reassigning its variable
+     */
+    open suspend fun plusAssign(scope: Scope, other: Obj): Obj? = null
+
+    /**
+     * `-=` operations, see [plusAssign]
+     */
+    open suspend fun minusAssign(scope: Scope, other: Obj): Obj? = null
+    open suspend fun mulAssign(scope: Scope, other: Obj): Obj? = null
+    open suspend fun divAssign(scope: Scope, other: Obj): Obj? = null
+    open suspend fun modAssign(scope: Scope, other: Obj): Obj? = null
+
+    open suspend fun getAndIncrement(scope: Scope): Obj {
+        scope.raiseNotImplemented()
+    }
+
+    open suspend fun incrementAndGet(scope: Scope): Obj {
+        scope.raiseNotImplemented()
+    }
+
+    open suspend fun decrementAndGet(scope: Scope): Obj {
+        scope.raiseNotImplemented()
+    }
+
+    open suspend fun getAndDecrement(scope: Scope): Obj {
+        scope.raiseNotImplemented()
+    }
+
+    /**
+     * Convert Lyng object to its Kotlin counterpart
+     */
+    open suspend fun toKotlin(scope: Scope): Any? {
+        return toString()
+    }
+
+    fun willMutate(scope: Scope) {
+        if (isFrozen) scope.raiseError("attempt to mutate frozen object")
+    }
+
+//    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.createChildScope(scope.pos, newThisObj = this)), obj.isMutable)
+            }
+            // could be writable property naturally
+//            null -> ObjNull.asReadonly
+            else -> obj
+        }
+    }
+
+    open suspend fun writeField(scope: Scope, name: String, newValue: Obj) {
+        willMutate(scope)
+        val field = objClass.getInstanceMemberOrNull(name) ?: scope.raiseError("no such field: $name")
+        if (field.isMutable) field.value = newValue else scope.raiseError("can't assign to read-only field: $name")
+    }
+
+    open suspend fun getAt(scope: Scope, index: Obj): Obj {
+        scope.raiseNotImplemented("indexing")
+    }
+
+    suspend fun getAt(scope: Scope, index: Int): Obj = getAt(scope, ObjInt(index.toLong()))
+
+    open suspend fun putAt(scope: Scope, index: Obj, newValue: Obj) {
+        scope.raiseNotImplemented("indexing")
+    }
+
+    open suspend fun callOn(scope: Scope): Obj {
+        scope.raiseNotImplemented()
+    }
+
+    suspend fun invoke(scope: Scope, thisObj: Obj, args: Arguments): Obj =
+        callOn(scope.createChildScope(scope.pos, args = args, newThisObj = thisObj))
+
+    suspend fun invoke(scope: Scope, thisObj: Obj, vararg args: Obj): Obj =
+        callOn(
+            scope.createChildScope(
+                scope.pos,
+                args = Arguments(args.toList()),
+                newThisObj = thisObj
+            )
+        )
+
+    suspend fun invoke(scope: Scope, thisObj: Obj): Obj =
+        callOn(
+            scope.createChildScope(
+                scope.pos,
+                args = Arguments.EMPTY,
+                newThisObj = thisObj
+            )
+        )
+
+    suspend fun invoke(scope: Scope, atPos: Pos, thisObj: Obj, args: Arguments): Obj =
+        callOn(scope.createChildScope(atPos, args = args, newThisObj = thisObj))
+
+
+    val asReadonly: ObjRecord by lazy { ObjRecord(this, false) }
+    val asMutable: ObjRecord by lazy { ObjRecord(this, true) }
+
+    open suspend fun lynonType(): LynonType = LynonType.Other
+
+    open suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
+        scope.raiseNotImplemented()
+    }
+
+    fun autoInstanceScope(parent: Scope): Scope {
+        val scope = parent.createChildScope(newThisObj = this, args = parent.args)
+        for (m in objClass.members) {
+            scope.objects[m.key] = m.value
+        }
+        return scope
+    }
+
+    inline fun <reified R: Obj> cast(scope: Scope): R {
+        castOrNull<R>()?.let { return it }
+        scope.raiseClassCastError("can't cast ${this::class.simpleName} to ${R::class.simpleName}")
+
+    }
+
+    inline fun <reified R: Obj> castOrNull(): R? {
+        (this as? R)?.let { return it }
+        // todo: check for subclasses
+        return null
+    }
+
+    companion object {
+
+        val rootObjectType = ObjClass("Obj").apply {
+            addFn("toString", true) {
+                thisObj.toString(this, true)
+            }
+            addFn("inspect", true) {
+                thisObj.inspect(this).toObj()
+            }
+            addFn("contains") {
+                ObjBool(thisObj.contains(this, args.firstAndOnly()))
+            }
+            // utilities
+            addFn("let") {
+                args.firstAndOnly().callOn(createChildScope(Arguments(thisObj)))
+            }
+            addFn("apply") {
+                val body = args.firstAndOnly()
+                (thisObj as? ObjInstance)?.let {
+                    body.callOn(ApplyScope(this, it.instanceScope))
+                } ?: run {
+                    body.callOn(this)
+                }
+                thisObj
+            }
+            addFn("also") {
+                args.firstAndOnly().callOn(createChildScope(Arguments(thisObj)))
+                thisObj
+            }
+            addFn("run") {
+                args.firstAndOnly().callOn(this)
+            }
+            addFn("getAt") {
+                requireExactCount(1)
+                thisObj.getAt(this, requiredArg<Obj>(0))
+            }
+            addFn("putAt") {
+                requireExactCount(2)
+                val newValue = args[1]
+                thisObj.putAt(this, requiredArg<Obj>(0), newValue)
+                newValue
+            }
+
+        }
+
+
+        @Suppress("NOTHING_TO_INLINE")
+        inline fun from(obj: Any?): Obj {
+            @Suppress("UNCHECKED_CAST")
+            return when (obj) {
+                is Obj -> obj
+                is Double -> ObjReal(obj)
+                is Float -> ObjReal(obj.toDouble())
+                is Int -> ObjInt(obj.toLong())
+                is Long -> ObjInt(obj)
+                is String -> ObjString(obj)
+                is CharSequence -> ObjString(obj.toString())
+                is Boolean -> ObjBool(obj)
+                is Set<*> -> ObjSet((obj as Set<Obj>).toMutableSet())
+                Unit -> ObjVoid
+                null -> ObjNull
+                is Iterator<*> -> ObjKotlinIterator(obj)
+                is Map.Entry<*, *> -> {
+                    obj as MutableMap.MutableEntry<Obj, Obj>
+                    ObjMapEntry(obj.key, obj.value)
+                }
+
+                else -> throw IllegalArgumentException("cannot convert to Obj: $obj")
+            }
+        }
+    }
+}
+
+fun Double.toObj(): Obj = ObjReal(this)
+
+@Suppress("unused")
+inline fun <reified T> T.toObj(): Obj = Obj.from(this)
+
+@Serializable
+@SerialName("void")
+object ObjVoid : Obj() {
+    override fun equals(other: Any?): Boolean {
+        return other is ObjVoid || other is Unit
+    }
+
+    override suspend fun compareTo(scope: Scope, other: Obj): Int {
+        return if (other === this) 0 else -1
+    }
+
+    override fun toString(): String = "void"
+}
+
+@Serializable
+@SerialName("null")
+object ObjNull : Obj() {
+    override suspend fun compareTo(scope: Scope, other: Obj): Int {
+        return if (other === this) 0 else -1
+    }
+
+    override fun equals(other: Any?): Boolean {
+        return other is ObjNull || other == null
+    }
+
+    override suspend fun readField(scope: Scope, name: String): ObjRecord {
+        scope.raiseNPE()
+    }
+
+//    override suspend fun invokeInstanceMethod(
+//        scope: Scope,
+//        name: String,
+//        args: Arguments,
+//        onNotFoundResult: (()->Obj?)?
+//    ): Obj {
+//        scope.raiseNPE()
+//    }
+
+    override suspend fun getAt(scope: Scope, index: Obj): Obj {
+        scope.raiseNPE()
+    }
+
+    override suspend fun putAt(scope: Scope, index: Obj, newValue: Obj) {
+        scope.raiseNPE()
+    }
+
+    override suspend fun callOn(scope: Scope): Obj {
+        scope.raiseNPE()
+    }
+
+    override fun toString(): String = "null"
+
+    override suspend fun toKotlin(scope: Scope): Any? {
+        return null
+    }
+
+    override suspend fun lynonType(): LynonType {
+        return LynonType.Null
+    }
+
+    override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
+        if (lynonType == null) {
+            encoder.putBit(0)
+        }
+    }
+
+    override val objClass: ObjClass by lazy {
+        object : ObjClass("Null") {
+            override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj {
+                if (lynonType == LynonType.Null)
+                    return this@ObjNull
+                else
+                    scope.raiseIllegalState("can't deserialize null directly or with wrong type: ${lynonType}")
+            }
+        }
+    }
+}
+
+/**
+ * TODO: get rid of it. Maybe we ise some Lyng inheritance instead
+ */
+interface Numeric {
+    val longValue: Long
+    val doubleValue: Double
+    val toObjInt: ObjInt
+    val toObjReal: ObjReal
+}
+
+fun Obj.toDouble(): Double =
+    (this as? Numeric)?.doubleValue
+        ?: (this as? ObjString)?.value?.toDouble()
+        ?: throw IllegalArgumentException("cannot convert to double $this")
+
+@Suppress("unused")
+fun Obj.toLong(): Long =
+    when (this) {
+        is Numeric -> longValue
+        is ObjString -> value.toLong()
+        is ObjChar -> value.code.toLong()
+        else -> throw IllegalArgumentException("cannot convert to double $this")
+    }
+
+fun Obj.toInt(): Int = toLong().toInt()
+
+fun Obj.toBool(): Boolean =
+    (this as? ObjBool)?.value ?: throw IllegalArgumentException("cannot convert to boolean $this")
+
+
+data class ObjNamespace(val name: String) : Obj() {
+    override val objClass by lazy { ObjClass(name) }
+
+    override suspend fun inspect(scope: Scope): String = "Ns[$name]"
+
+    override fun toString(): String {
+        return "package $name"
+    }
+}
+
+

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

@@ -0,0 +1,75 @@
+/*
+ * 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.
+ *
+ */
+
+package net.sergeych.lyng.obj
+
+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)
+        }
+
+        addFn("binarySearch") {
+            val target = args.firstAndOnly()
+            var low = 0
+            var high = thisObj.invokeInstanceMethod(this, "size").toInt() - 1
+
+            while (low <= high) {
+                val mid = (low + high) / 2
+                val midVal = thisObj.getAt(this, ObjInt(mid.toLong()))
+
+                val cmp = midVal.compareTo(this, target)
+                when {
+                    cmp == 0 -> return@addFn (mid).toObj()
+                    cmp > 0 -> high = mid - 1
+                    else -> low = mid + 1
+                }
+            }
+
+            // Элемент не найден, возвращаем -(точка вставки) - 1
+            (-low - 1).toObj()
+        }
+    }
+}

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

@@ -1,4 +1,23 @@
-package net.sergeych.lyng
+/*
+ * 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.
+ *
+ */
+
+package net.sergeych.lyng.obj
+
+import net.sergeych.lyng.Scope
 
 class ObjArrayIterator(val array: Obj) : Obj() {
 
@@ -7,9 +26,9 @@ class ObjArrayIterator(val array: Obj) : Obj() {
     private var nextIndex = 0
     private var lastIndex = 0
 
-    suspend fun init(context: Context) {
+    suspend fun init(scope: Scope) {
         nextIndex = 0
-        lastIndex = array.invokeInstanceMethod(context, "size").toInt()
+        lastIndex = array.invokeInstanceMethod(scope, "size").toInt()
         ObjVoid
     }
 

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

@@ -0,0 +1,54 @@
+/*
+ * 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.
+ *
+ */
+
+package net.sergeych.lyng.obj
+
+import net.sergeych.bintools.toDump
+import net.sergeych.lyng.Scope
+import net.sergeych.lynon.BitArray
+
+class ObjBitBuffer(val bitArray: BitArray) : Obj() {
+
+    override val objClass = type
+
+    override suspend fun getAt(scope: Scope, index: Obj): Obj {
+        return bitArray[index.toLong()].toObj()
+    }
+
+    companion object {
+        val type = object: ObjClass("BitBuffer", ObjArray) {
+
+        }.apply {
+            addFn("toBuffer") {
+                requireNoArgs()
+                ObjBuffer(thisAs<ObjBitBuffer>().bitArray.asUByteArray())
+            }
+            addFn("toDump") {
+                requireNoArgs()
+                ObjString(
+                    thisAs<ObjBitBuffer>().bitArray.asUByteArray().toDump()
+                )
+            }
+            addFn("size") {
+                thisAs<ObjBitBuffer>().bitArray.size.toObj()
+            }
+            addFn("sizeInBytes") {
+                ObjInt((thisAs<ObjBitBuffer>().bitArray.size + 7) shr 3)
+            }
+        }
+    }
+}

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

@@ -0,0 +1,75 @@
+/*
+ * 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.
+ *
+ */
+
+package net.sergeych.lyng.obj
+
+import net.sergeych.lyng.Scope
+import net.sergeych.lynon.LynonDecoder
+import net.sergeych.lynon.LynonEncoder
+import net.sergeych.lynon.LynonType
+
+data class ObjBool(val value: Boolean) : Obj() {
+
+    override suspend fun compareTo(scope: Scope, other: Obj): Int {
+        if (other !is ObjBool) return -2
+        return value.compareTo(other.value)
+    }
+
+    override fun hashCode(): Int {
+        return value.hashCode()
+    }
+
+    override fun toString(): String = value.toString()
+
+    override val objClass: ObjClass = type
+
+    override suspend fun logicalNot(scope: Scope): Obj = ObjBool(!value)
+
+    override suspend fun logicalAnd(scope: Scope, other: Obj): Obj = ObjBool(value && other.toBool())
+
+    override suspend fun logicalOr(scope: Scope, other: Obj): Obj = ObjBool(value || other.toBool())
+
+    override suspend fun toKotlin(scope: Scope): Any {
+        return value
+    }
+
+    override suspend fun lynonType(): LynonType = LynonType.Bool
+
+    override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
+        encoder.encodeBoolean(value)
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || this::class != other::class) return false
+
+        other as ObjBool
+
+        return value == other.value
+    }
+
+    companion object {
+        val type = object : ObjClass("Bool") {
+            override suspend fun deserialize(scope: Scope, decoder: LynonDecoder,lynonType: LynonType?): Obj {
+                return ObjBool(decoder.unpackBoolean())
+            }
+        }
+    }
+}
+
+val ObjTrue = ObjBool(true)
+val ObjFalse = ObjBool(false)

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

@@ -0,0 +1,209 @@
+/*
+ * 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.
+ *
+ */
+
+package net.sergeych.lyng.obj
+
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.toList
+import net.sergeych.bintools.decodeHex
+import net.sergeych.bintools.encodeToHex
+import net.sergeych.bintools.toDump
+import net.sergeych.lyng.Scope
+import net.sergeych.lyng.statement
+import net.sergeych.lynon.BitArray
+import net.sergeych.lynon.LynonDecoder
+import net.sergeych.lynon.LynonEncoder
+import net.sergeych.lynon.LynonType
+import net.sergeych.mp_tools.decodeBase64Url
+import net.sergeych.mp_tools.encodeToBase64Url
+import kotlin.math.min
+
+open class ObjBuffer(val byteArray: UByteArray) : Obj() {
+
+    override val objClass: ObjClass = type
+
+    val hex by lazy { byteArray.encodeToHex("")}
+    val base64 by lazy { byteArray.toByteArray().encodeToBase64Url()}
+
+    fun checkIndex(scope: Scope, index: Obj): Int {
+        if (index !is ObjInt)
+            scope.raiseIllegalArgument("index must be Int")
+        val i = index.value.toInt()
+        if (i < 0) scope.raiseIllegalArgument("index must be positive")
+        if (i >= byteArray.size)
+            scope.raiseIndexOutOfBounds("index $i is out of bounds 0..<${byteArray.size}")
+        return i
+    }
+
+    override suspend fun getAt(scope: Scope, index: Obj): Obj {
+        // notice: we create a copy if content, so we don't want it
+        // to be treated as modifiable, or putAt will not be called:
+        return if (index is ObjRange) {
+            val start: Int = index.startInt(scope)
+            val end: Int = index.exclusiveIntEnd(scope) ?: size
+            ObjBuffer(byteArray.sliceArray(start..<end))
+        } else ObjInt(byteArray[checkIndex(scope, index)].toLong(), true)
+    }
+
+    val size by byteArray::size
+
+    override fun hashCode(): Int {
+        return byteArray.hashCode()
+    }
+
+    override suspend fun compareTo(scope: Scope, other: Obj): Int {
+        if (other !is ObjBuffer) return super.compareTo(scope, other)
+        val limit = min(size, other.size)
+        for (i in 0..<limit) {
+            val own = byteArray[i]
+            val their = other.byteArray[i]
+            if (own < their) return -1
+            else if (own > their) return 1
+        }
+        if (size < other.size) return -1
+        if (size > other.size) return 1
+        return 0
+    }
+
+    override suspend fun plus(scope: Scope, other: Obj): Obj {
+        return if (other is ObjBuffer)
+            ObjBuffer(byteArray + other.byteArray)
+        else if (other.isInstanceOf(ObjIterable)) {
+            ObjBuffer(
+                byteArray + other.toFlow(scope).map { it.toLong().toUByte() }.toList().toTypedArray()
+                    .toUByteArray()
+            )
+        } else scope.raiseIllegalArgument("can't concatenate buffer with ${other.inspect(scope)}")
+    }
+
+    override fun toString(): String = base64
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || this::class != other::class) return false
+
+        other as ObjBuffer
+
+        return byteArray contentEquals other.byteArray
+    }
+
+    override suspend fun lynonType(): LynonType = LynonType.Buffer
+
+    override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
+        encoder.encodeCachedBytes(byteArray.asByteArray())
+    }
+
+    override suspend fun inspect(scope: Scope): String = "Buf($base64)"
+
+    companion object {
+        private suspend fun createBufferFrom(scope: Scope, obj: Obj): ObjBuffer =
+            when (obj) {
+                is ObjBuffer -> ObjBuffer(obj.byteArray.copyOf())
+                is ObjInt -> {
+                    if (obj.value < 0)
+                        scope.raiseIllegalArgument("buffer size must be positive")
+                    val data = UByteArray(obj.value.toInt())
+                    ObjBuffer(data)
+                }
+
+                is ObjString -> ObjBuffer(obj.value.encodeToByteArray().asUByteArray())
+                else -> {
+                    if (obj.isInstanceOf(ObjIterable)) {
+                        ObjBuffer(
+                            obj.toFlow(scope).map { it.toLong().toUByte() }.toList().toTypedArray()
+                                .toUByteArray()
+                        )
+                    } else
+                        scope.raiseIllegalArgument(
+                            "can't construct buffer from ${obj.inspect(scope)}"
+                        )
+                }
+            }
+
+        val type = object : ObjClass("Buffer", ObjArray) {
+            override suspend fun callOn(scope: Scope): Obj {
+                val args = scope.args.list
+                return when (args.size) {
+                    // empty buffer
+                    0 -> ObjBuffer(ubyteArrayOf())
+                    1 -> createBufferFrom(scope, args[0])
+                    else -> {
+                        // create buffer from array, each argument should be a byte then:
+                        val data = UByteArray(args.size)
+                        for ((i, b) in args.withIndex()) {
+                            val code = when (b) {
+                                is ObjChar -> b.value.code.toUByte()
+                                is ObjInt -> b.value.toUByte()
+                                else -> scope.raiseIllegalArgument(
+                                    "invalid byte value for buffer constructor at index $i: ${b.inspect(scope)}"
+                                )
+                            }
+                            data[i] = code
+                        }
+                        ObjBuffer(data)
+                    }
+                }
+            }
+
+            override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj =
+                ObjBuffer( decoder.decodeCached {
+                    decoder.decompress().asUByteArray()
+                })
+
+        }.apply {
+            addClassFn("decodeBase64") {
+                ObjBuffer(requireOnlyArg<Obj>().toString().decodeBase64Url().asUByteArray())
+            }
+            addClassFn("decodeHex") {
+                ObjBuffer(requireOnlyArg<Obj>().toString().decodeHex().asUByteArray())
+            }
+            createField("size",
+                statement {
+                    (thisObj as ObjBuffer).byteArray.size.toObj()
+                }
+            )
+            createField("hex",
+                statement {
+                    thisAs<ObjBuffer>().hex.toObj()
+                }
+            )
+            createField("base64",
+                statement {
+                    thisAs<ObjBuffer>().base64.toObj()
+                }
+            )
+            addFn("decodeUtf8") {
+                ObjString(
+                    thisAs<ObjBuffer>().byteArray.toByteArray().decodeToString()
+                )
+            }
+            addFn("toMutable") {
+                requireNoArgs()
+                ObjMutableBuffer(thisAs<ObjBuffer>().byteArray.copyOf())
+            }
+            addFn("toDump") {
+                requireNoArgs()
+                ObjString(
+                    thisAs<ObjBuffer>().byteArray.toByteArray().toDump()
+                )
+            }
+            addFn("toBitInput") {
+                ObjBitBuffer(BitArray(thisAs<ObjBuffer>().byteArray, 8))
+            }
+        }
+    }
+}

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

@@ -0,0 +1,51 @@
+/*
+ * 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.
+ *
+ */
+
+package net.sergeych.lyng.obj
+
+import net.sergeych.lyng.Scope
+
+class ObjChar(val value: Char): Obj() {
+
+    override val objClass: ObjClass = type
+
+    override suspend fun compareTo(scope: Scope, other: Obj): Int =
+        (other as? ObjChar)?.let { value.compareTo(it.value) } ?: -1
+
+    override fun toString(): String = value.toString()
+
+    override suspend fun inspect(scope: Scope): String = "'$value'"
+
+    override fun hashCode(): Int {
+        return value.hashCode()
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || this::class != other::class) return false
+
+        other as ObjChar
+
+        return value == other.value
+    }
+
+    companion object {
+        val type = ObjClass("Char").apply {
+            addFn("code") { ObjInt(thisAs<ObjChar>().value.code.toLong()) }
+        }
+    }
+}

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

@@ -0,0 +1,160 @@
+/*
+ * 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.
+ *
+ */
+
+package net.sergeych.lyng.obj
+
+import net.sergeych.lyng.*
+import net.sergeych.lynon.LynonDecoder
+import net.sergeych.lynon.LynonType
+
+val ObjClassType by lazy { ObjClass("Class") }
+
+open class ObjClass(
+    val className: String,
+    vararg parents: ObjClass,
+) : Obj() {
+
+    val classNameObj by lazy { ObjString(className) }
+
+    var constructorMeta: ArgsDeclaration? = null
+    var instanceConstructor: Statement? = null
+
+    /**
+     * the scope for class methods, initialize class vars, etc.
+     *
+     * Important notice. When create a user class, e.g. from Lyng source, it should
+     * be set to a scope by compiler, so it could access local closure, etc. Otherwise,
+     * it will be initialized to default scope on first necessity, e.g. when used in
+     * external, kotlin classes with [addClassConst] and [addClassFn], etc.
+     */
+    var classScope: Scope? = null
+
+    val allParentsSet: Set<ObjClass> =
+        parents.flatMap {
+            listOf(it) + it.allParentsSet
+        }.toMutableSet()
+
+    override val objClass: ObjClass by lazy { ObjClassType }
+
+    /**
+     * members: fields most often. These are called with [ObjInstance] withs ths [ObjInstance.objClass]
+     */
+    internal val members = mutableMapOf<String, ObjRecord>()
+
+    override fun toString(): String = className
+
+    override suspend fun compareTo(scope: Scope, other: Obj): Int = if (other === this) 0 else -1
+
+    override suspend fun callOn(scope: Scope): Obj {
+        val instance = ObjInstance(this)
+        instance.instanceScope = scope.createChildScope(newThisObj = instance, args = scope.args)
+        if (instanceConstructor != null) {
+            instanceConstructor!!.execute(instance.instanceScope)
+        }
+        return instance
+    }
+
+    suspend fun callWithArgs(scope: Scope, vararg plainArgs: Obj): Obj {
+        return callOn(scope.createChildScope(Arguments(*plainArgs)))
+    }
+
+
+    fun createField(
+        name: String,
+        initialValue: Obj,
+        isMutable: Boolean = false,
+        visibility: Visibility = Visibility.Public,
+        pos: Pos = Pos.builtIn
+    ) {
+        val existing = members[name] ?: allParentsSet.firstNotNullOfOrNull { it.members[name] }
+        if (existing?.isMutable == false)
+            throw ScriptError(pos, "$name is already defined in $objClass or one of its supertypes")
+        members[name] = ObjRecord(initialValue, isMutable, visibility)
+    }
+
+    private fun initClassScope(): Scope {
+        if (classScope == null) classScope = Scope()
+        return classScope!!
+    }
+
+    fun createClassField(
+        name: String,
+        initialValue: Obj,
+        isMutable: Boolean = false,
+        visibility: Visibility = Visibility.Public,
+        pos: Pos = Pos.builtIn
+    ) {
+        initClassScope()
+        val existing = classScope!!.objects[name]
+        if (existing != null)
+            throw ScriptError(pos, "$name is already defined in $objClass or one of its supertypes")
+        classScope!!.addItem(name, isMutable, initialValue, visibility)
+    }
+
+    fun addFn(name: String, isOpen: Boolean = false, code: suspend Scope.() -> Obj) {
+        createField(name, statement { code() }, isOpen)
+    }
+
+    fun addConst(name: String, value: Obj) = createField(name, value, isMutable = false)
+    fun addClassConst(name: String, value: Obj) = createClassField(name, value)
+    fun addClassFn(name: String, isOpen: Boolean = false, code: suspend Scope.() -> Obj) {
+        createClassField(name, statement { code() }, isOpen)
+    }
+
+
+    /**
+     * Get instance member traversing the hierarchy if needed. Its meaning is different for different objects.
+     */
+    fun getInstanceMemberOrNull(name: String): ObjRecord? {
+        members[name]?.let { return it }
+        allParentsSet.forEach { parent -> parent.getInstanceMemberOrNull(name)?.let { return it } }
+        return rootObjectType.members[name]
+    }
+
+    fun getInstanceMember(atPos: Pos, name: String): ObjRecord =
+        getInstanceMemberOrNull(name)
+            ?: throw ScriptError(atPos, "symbol doesn't exist: $name")
+
+    override suspend fun readField(scope: Scope, name: String): ObjRecord {
+        classScope?.objects?.get(name)?.let {
+            if (it.visibility.isPublic) return it
+        }
+        return super.readField(scope, name)
+    }
+
+    override suspend fun writeField(scope: Scope, name: String, newValue: Obj) {
+        initClassScope().objects[name]?.let {
+            if (it.isMutable) it.value = newValue
+            else scope.raiseIllegalAssignment("can't assign $name is not mutable")
+        }
+            ?: super.writeField(scope, name, newValue)
+    }
+
+    override suspend fun invokeInstanceMethod(
+        scope: Scope, name: String, args: Arguments,
+        onNotFoundResult: (() -> Obj?)?
+    ): Obj {
+        return classScope?.objects?.get(name)?.value?.invoke(scope, this, args)
+            ?: super.invokeInstanceMethod(scope, name, args, onNotFoundResult)
+    }
+
+    open suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj =
+        scope.raiseNotImplemented()
+
+}
+
+

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

@@ -0,0 +1,25 @@
+/*
+ * 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.
+ *
+ */
+
+package net.sergeych.lyng.obj
+
+/**
+ * Collection is an iterator with `size`
+ */
+val ObjCollection = ObjClass("Collection", ObjIterable).apply {
+}
+

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

@@ -0,0 +1,39 @@
+/*
+ * 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.
+ *
+ */
+
+package net.sergeych.lyng.obj
+
+import kotlinx.coroutines.CompletableDeferred
+import net.sergeych.lyng.Scope
+
+class ObjCompletableDeferred(val completableDeferred: CompletableDeferred<Obj>): ObjDeferred(completableDeferred) {
+
+    override val objClass = type
+
+    companion object {
+        val type = object: ObjClass("CompletableDeferred", ObjDeferred.type){
+            override suspend fun callOn(scope: Scope): Obj {
+                return ObjCompletableDeferred(CompletableDeferred())
+            }
+        }.apply {
+            addFn("complete") {
+                thisAs<ObjCompletableDeferred>().completableDeferred.complete(args.firstAndOnly())
+                ObjVoid
+            }
+        }
+    }
+}

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

@@ -0,0 +1,49 @@
+/*
+ * 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.
+ *
+ */
+
+package net.sergeych.lyng.obj
+
+import kotlinx.coroutines.Deferred
+import net.sergeych.lyng.Scope
+
+open class ObjDeferred(val deferred: Deferred<Obj>): Obj() {
+
+    override val objClass = type
+
+    companion object {
+        val type = object: ObjClass("Deferred"){
+            override suspend fun callOn(scope: Scope): Obj {
+                scope.raiseError("Deferred constructor is not directly callable")
+            }
+        }.apply {
+            addFn("await") {
+                thisAs<ObjDeferred>().deferred.await()
+            }
+            addFn("isCompleted") {
+                thisAs<ObjDeferred>().deferred.isCompleted.toObj()
+            }
+            addFn("isActive") {
+                thisAs<ObjDeferred>().deferred.isActive.toObj()
+            }
+            addFn("isCancelled") {
+                thisAs<ObjDeferred>().deferred.isCancelled.toObj()
+            }
+
+        }
+    }
+}
+

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

@@ -0,0 +1,42 @@
+/*
+ * 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.
+ *
+ */
+
+package net.sergeych.lyng.obj
+
+//class ObjDelegateContext()
+//
+//class ObjDelegate(
+//                  val getter: Statement,
+//                  val setter: Statement = statement { raiseNotImplemented("setter is not implemented") }
+//): Obj() {
+//
+//    override suspend fun assign(scope: Scope, other: Obj): Obj? {
+//        setter.execute(scope.copy(Arguments(other)))
+//        return other
+//    }
+//
+//    companion object {
+//        val type = object: ObjClass("Delegate") {
+//            override suspend fun callOn(scope: Scope): Obj {
+//                scope.raiseError("Delegate should not be constructed directly")
+//            }
+//        }.apply {
+//
+//        }
+//    }
+//
+//}

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

@@ -0,0 +1,171 @@
+/*
+ * 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.
+ *
+ */
+
+package net.sergeych.lyng.obj
+
+import net.sergeych.lyng.Scope
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.days
+import kotlin.time.Duration.Companion.hours
+import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.Duration.Companion.minutes
+import kotlin.time.Duration.Companion.seconds
+import kotlin.time.DurationUnit
+
+class ObjDuration(val duration: Duration) : Obj() {
+    override val objClass: ObjClass = type
+
+    override fun toString(): String {
+        return duration.toString()
+    }
+
+    override suspend fun compareTo(scope: Scope, other: Obj): Int {
+        return if( other is ObjDuration)
+            duration.compareTo(other.duration)
+        else -1
+    }
+
+    override fun hashCode(): Int {
+        return duration.hashCode()
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || this::class != other::class) return false
+
+        other as ObjDuration
+
+        return duration == other.duration
+    }
+
+    companion object {
+        val type = object : ObjClass("Duration") {
+            override suspend fun callOn(scope: Scope): Obj {
+                val args = scope.args
+                if( args.list.size > 1 )
+                    scope.raiseIllegalArgument("can't construct Duration(${args.inspect(scope)})")
+                val a0 = args.list.getOrNull(0)
+
+                return ObjDuration(
+                    when (a0) {
+                        null -> Duration.ZERO
+                        is ObjInt -> a0.value.seconds
+                        is ObjReal -> a0.value.seconds
+                        else -> {
+                            scope.raiseIllegalArgument("can't construct Instant(${args.inspect(scope)})")
+                        }
+                    }
+                )
+            }
+        }.apply {
+            addFn("days") {
+                thisAs<ObjDuration>().duration.toDouble(DurationUnit.DAYS).toObj()
+            }
+            addFn("hours") {
+                thisAs<ObjDuration>().duration.toDouble(DurationUnit.HOURS).toObj()
+            }
+            addFn("minutes") {
+                thisAs<ObjDuration>().duration.toDouble(DurationUnit.MINUTES).toObj()
+            }
+            addFn("seconds") {
+                thisAs<ObjDuration>().duration.toDouble(DurationUnit.SECONDS).toObj()
+            }
+            addFn("milliseconds") {
+                thisAs<ObjDuration>().duration.toDouble(DurationUnit.MILLISECONDS).toObj()
+            }
+            addFn("microseconds") {
+                thisAs<ObjDuration>().duration.toDouble(DurationUnit.MICROSECONDS).toObj()
+            }
+            // extensions
+
+            ObjInt.type.addFn("seconds") {
+                ObjDuration(thisAs<ObjInt>().value.seconds)
+            }
+
+            ObjInt.type.addFn("second") {
+                ObjDuration(thisAs<ObjInt>().value.seconds)
+            }
+            ObjInt.type.addFn("milliseconds") {
+                ObjDuration(thisAs<ObjInt>().value.milliseconds)
+            }
+
+            ObjInt.type.addFn("millisecond") {
+                ObjDuration(thisAs<ObjInt>().value.milliseconds)
+            }
+            ObjReal.type.addFn("seconds") {
+                ObjDuration(thisAs<ObjReal>().value.seconds)
+            }
+
+            ObjReal.type.addFn("second") {
+                ObjDuration(thisAs<ObjReal>().value.seconds)
+            }
+
+            ObjReal.type.addFn("milliseconds") {
+                ObjDuration(thisAs<ObjReal>().value.milliseconds)
+            }
+            ObjReal.type.addFn("millisecond") {
+                ObjDuration(thisAs<ObjReal>().value.milliseconds)
+            }
+
+            ObjInt.type.addFn("minutes") {
+                ObjDuration(thisAs<ObjInt>().value.minutes)
+            }
+            ObjReal.type.addFn("minutes") {
+                ObjDuration(thisAs<ObjReal>().value.minutes)
+            }
+            ObjInt.type.addFn("minute") {
+                ObjDuration(thisAs<ObjInt>().value.minutes)
+            }
+            ObjReal.type.addFn("minute") {
+                ObjDuration(thisAs<ObjReal>().value.minutes)
+            }
+            ObjInt.type.addFn("hours") {
+                ObjDuration(thisAs<ObjInt>().value.hours)
+            }
+            ObjReal.type.addFn("hours") {
+                ObjDuration(thisAs<ObjReal>().value.hours)
+            }
+            ObjInt.type.addFn("hour") {
+                ObjDuration(thisAs<ObjInt>().value.hours)
+            }
+            ObjReal.type.addFn("hour") {
+                ObjDuration(thisAs<ObjReal>().value.hours)
+            }
+            ObjInt.type.addFn("days") {
+                ObjDuration(thisAs<ObjInt>().value.days)
+            }
+            ObjReal.type.addFn("days") {
+                ObjDuration(thisAs<ObjReal>().value.days)
+            }
+            ObjInt.type.addFn("day") {
+                ObjDuration(thisAs<ObjInt>().value.days)
+            }
+            ObjReal.type.addFn("day") {
+                ObjDuration(thisAs<ObjReal>().value.days)
+            }
+
+
+//            addFn("epochSeconds") {
+//                val instant = thisAs<ObjInstant>().instant
+//                ObjReal(instant.epochSeconds + instant.nanosecondsOfSecond * 1e-9)
+//            }
+//            addFn("epochMilliseconds") {
+//                ObjInt(instant.toEpochMilliseconds())
+//            }
+        }
+    }
+}

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

@@ -0,0 +1,121 @@
+/*
+ * 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.
+ *
+ */
+
+package net.sergeych.lyng.obj
+
+import net.sergeych.lyng.Arguments
+import net.sergeych.lyng.Scope
+import net.sergeych.lyng.Statement
+
+class ObjDynamicContext(val delegate: ObjDynamic) : Obj() {
+    override val objClass: ObjClass = type
+
+    companion object {
+        val type = ObjClass("DelegateContext").apply {
+            addFn("get") {
+                val d = thisAs<ObjDynamicContext>().delegate
+                if (d.readCallback != null)
+                    raiseIllegalState("get already defined")
+                d.readCallback = requireOnlyArg()
+                ObjVoid
+            }
+
+            addFn("set") {
+                val d = thisAs<ObjDynamicContext>().delegate
+                if (d.writeCallback != null)
+                    raiseIllegalState("set already defined")
+                d.writeCallback = requireOnlyArg()
+                ObjVoid
+            }
+
+        }
+
+    }
+}
+
+/**
+ * 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() {
+
+    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.createChildScope(Arguments(ObjString(name))))?.let {
+            if (writeCallback != null)
+                it.asMutable
+            else
+                it.asReadonly
+        }
+            ?: 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.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.createChildScope(newThisObj = context))
+            return delegate
+        }
+
+        val type = object : ObjClass("Delegate") {}.apply {
+//            addClassConst("IndexGetName", operatorGetName)
+        }
+    }
+
+}

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

@@ -0,0 +1,79 @@
+/*
+ * 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.
+ *
+ */
+
+import net.sergeych.lyng.Scope
+import net.sergeych.lyng.obj.*
+import net.sergeych.lynon.LynonDecoder
+import net.sergeych.lynon.LynonEncoder
+import net.sergeych.lynon.LynonType
+
+open class ObjEnumEntry(enumClass: ObjEnumClass, val name: ObjString, val ordinal: ObjInt) : Obj() {
+    override val objClass = enumClass
+
+    override fun toString(): String {
+        return "$objClass.$name"
+    }
+
+    override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
+        encoder.encodeUnsigned(ordinal.value.toULong())
+    }
+
+    override suspend fun compareTo(scope: Scope, other: Obj): Int {
+        if( other !is ObjEnumEntry) return -2
+        if( other.objClass != objClass ) return -2
+        return ordinal.compareTo(scope, other.ordinal)
+    }
+
+}
+
+object EnumBase : ObjClass("Enum") {
+
+}
+
+class ObjEnumClass(val name: String) : ObjClass(name, EnumBase) {
+    val objEntries = ObjList()
+    val byName by lazy { objEntries.list.associateBy { (it as ObjEnumEntry).name } }
+
+    init {
+        addClassConst("entries", objEntries )
+        addClassFn("valueOf") {
+            val name = requireOnlyArg<ObjString>()
+            byName[name] ?: raiseSymbolNotFound("does not exists: enum ${className}.$name")
+        }
+        addFn("name") { thisAs<ObjEnumEntry>().name }
+        addFn("ordinal") { thisAs<ObjEnumEntry>().ordinal }
+
+    }
+
+    override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj {
+        val index = decoder.unpackUnsigned().toInt()
+        return objEntries.list[index]
+    }
+
+    companion object {
+        fun createSimpleEnum(enumName: String, names: List<String>): ObjEnumClass {
+            val klass = ObjEnumClass(enumName)
+            names.forEachIndexed { index, name ->
+                val entry = ObjEnumEntry(klass, ObjString(name), ObjInt(index.toLong(), isConst = true))
+                klass.objEntries.list += entry
+                klass.addClassConst(name, entry)
+            }
+            return klass
+        }
+    }
+
+}

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

@@ -0,0 +1,221 @@
+/*
+ * 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.
+ *
+ */
+
+package net.sergeych.lyng.obj
+
+import net.sergeych.bintools.encodeToHex
+import net.sergeych.lyng.*
+import net.sergeych.lynon.LynonDecoder
+import net.sergeych.lynon.LynonEncoder
+import net.sergeych.lynon.LynonType
+import net.sergeych.mptools.CachedExpression
+import net.sergeych.synctools.ProtectedOp
+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 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(
+    val exceptionClass: ExceptionClass,
+    val scope: Scope,
+    val message: ObjString,
+    @Suppress("unused") val extraData: Obj = ObjNull,
+    val useStackTrace: ObjList? = null
+) : Obj() {
+    constructor(name: String, scope: Scope, message: String) : this(
+        getOrCreateExceptionClass(name),
+        scope,
+        ObjString(message)
+    )
+
+    private val cachedStackTrace = CachedExpression(initialValue = useStackTrace)
+
+    suspend fun getStackTrace(): ObjList {
+        return cachedStackTrace.get {
+            val result = ObjList()
+            val cls = scope.get("StackTraceEntry")!!.value as ObjClass
+            var s: Scope? = scope
+            var lastPos: Pos? = null
+            while (s != null) {
+                val pos = s.pos
+                if (pos != lastPos && !pos.currentLine.isEmpty()) {
+                    result.list += cls.callWithArgs(
+                        scope,
+                        pos.source.objSourceName,
+                        ObjInt(pos.line.toLong()),
+                        ObjInt(pos.column.toLong()),
+                        ObjString(pos.currentLine)
+                    )
+                }
+                s = s.parent
+                lastPos = pos
+            }
+            result
+        }
+    }
+
+    constructor(scope: Scope, message: String) : this(Root, scope, ObjString(message))
+
+    fun raise(): Nothing {
+        throw ExecutionError(this)
+    }
+
+    override val objClass: ObjClass = exceptionClass
+
+    override suspend fun toString(scope: Scope, calledFromLyng: Boolean): ObjString {
+        val at = getStackTrace().list.firstOrNull()?.toString(scope)
+            ?: ObjString("(unknown)")
+        return ObjString("${objClass.className}: $message at $at")
+    }
+
+    override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
+        encoder.encodeAny(scope, exceptionClass.classNameObj)
+        encoder.encodeAny(scope, message)
+        encoder.encodeAny(scope, extraData)
+        encoder.encodeAny(scope, getStackTrace())
+    }
+
+
+    companion object {
+
+        class ExceptionClass(val name: String, vararg parents: ObjClass) : ObjClass(name, *parents) {
+            override suspend fun callOn(scope: Scope): Obj {
+                val message = scope.args.getOrNull(0)?.toString(scope) ?: ObjString(name)
+                return ObjException(this, scope, message)
+            }
+
+            override fun toString(): String = "ExceptionClass[$name]@${hashCode().encodeToHex()}"
+
+            override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj {
+                return try {
+                    val lyngClass = decoder.decodeAnyAs<ObjString>(scope).value.let {
+                        ((scope[it] ?: scope.raiseIllegalArgument("Unknown exception class: $it"))
+                            .value as? ExceptionClass)
+                            ?: scope.raiseIllegalArgument("Not an exception class: $it")
+                    }
+                    ObjException(
+                        lyngClass,
+                        scope,
+                        decoder.decodeAnyAs<ObjString>(scope),
+                        decoder.decodeAny(scope),
+                        decoder.decodeAnyAs<ObjList>(scope)
+                    )
+                } catch (e: ScriptError) {
+                    throw e
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                    scope.raiseIllegalArgument("Failed to deserialize exception: ${e.message}")
+                }
+            }
+        }
+
+        val Root = ExceptionClass("Exception").apply {
+            addConst("message", statement {
+                (thisObj as ObjException).message.toObj()
+            })
+            addFn("stackTrace") {
+                (thisObj as ObjException).getStackTrace()
+            }
+        }
+
+        private val op = ProtectedOp()
+        private val existingErrorClasses = mutableMapOf<String, ExceptionClass>()
+
+
+        @OptIn(ExperimentalContracts::class)
+        protected fun getOrCreateExceptionClass(name: String): ExceptionClass {
+            return op.withLock {
+                existingErrorClasses.getOrPut(name) {
+                    ExceptionClass(name, Root)
+                }
+            }
+        }
+
+        /**
+         * Get [ObjClass] for error class by name if exists.
+         */
+        @OptIn(ExperimentalContracts::class)
+        fun getErrorClass(name: String): ObjClass? = op.withLock {
+            existingErrorClasses[name]
+        }
+
+        fun addExceptionsToContext(scope: Scope) {
+            scope.addConst("Exception", Root)
+            existingErrorClasses["Exception"] = Root
+            for (name in listOf(
+                "NullReferenceException",
+                "AssertionFailedException",
+                "ClassCastException",
+                "IndexOutOfBoundsException",
+                "IllegalArgumentException",
+                "NoSuchElementException",
+                "IllegalAssignmentException",
+                "SymbolNotDefinedException",
+                "IterationEndException",
+                "AccessException",
+                "UnknownException",
+                "NotFoundException"
+            )) {
+                scope.addConst(name, getOrCreateExceptionClass(name))
+            }
+        }
+    }
+}
+
+class ObjNullReferenceException(scope: Scope) : ObjException("NullReferenceException", scope, "object is null")
+
+class ObjAssertionFailedException(scope: Scope, message: String) :
+    ObjException("AssertionFailedException", scope, message)
+
+class ObjClassCastException(scope: Scope, message: String) : ObjException("ClassCastException", scope, message)
+class ObjIndexOutOfBoundsException(scope: Scope, message: String = "index out of bounds") :
+    ObjException("IndexOutOfBoundsException", scope, message)
+
+class ObjIllegalArgumentException(scope: Scope, message: String = "illegal argument") :
+    ObjException("IllegalArgumentException", scope, message)
+
+class ObjIllegalStateException(scope: Scope, message: String = "illegal state") :
+    ObjException("IllegalStateException", scope, message)
+
+@Suppress("unused")
+class ObjNoSuchElementException(scope: Scope, message: String = "no such element") :
+    ObjException("IllegalArgumentException", scope, message)
+
+class ObjIllegalAssignmentException(scope: Scope, message: String = "illegal assignment") :
+    ObjException("NoSuchElementException", scope, message)
+
+class ObjSymbolNotDefinedException(scope: Scope, message: String = "symbol is not defined") :
+    ObjException("SymbolNotDefinedException", scope, message)
+
+class ObjIterationFinishedException(scope: Scope) :
+    ObjException("IterationEndException", scope, "iteration finished")
+
+class ObjAccessException(scope: Scope, message: String = "access not allowed error") :
+    ObjException("AccessException", scope, message)
+
+class ObjUnknownException(scope: Scope, message: String = "access not allowed error") :
+    ObjException("UnknownException", scope, message)
+
+class ObjIllegalOperationException(scope: Scope, message: String = "Operation is illegal") :
+    ObjException("IllegalOperationException", scope, message)
+
+class ObjNotFoundException(scope: Scope, message: String = "not found") :
+    ObjException("NotFoundException", scope, message)