fix #49 regular expressions, operator match and docs

+List.binarySearch

.gitignore

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

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

@@ -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.
+  ~
+  -->
+
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Tests in 'lyng.lynglib.jvmTest'" type="GradleRunConfiguration" factoryName="Gradle">
+    <ExternalSystemSettings>
+      <option name="executionName" />
+      <option name="externalProjectPath" value="$PROJECT_DIR$" />
+      <option name="externalSystemIdString" value="GRADLE" />
+      <option name="scriptParameters" value="" />
+      <option name="taskDescriptions">
+        <list />
+      </option>
+      <option name="taskNames">
+        <list>
+          <option value=":lynglib:cleanJvmTest" />
+          <option value=":lynglib:jvmTest" />
+        </list>
+      </option>
+      <option name="vmOptions" />
+    </ExternalSystemSettings>
+    <ExternalSystemDebugServerProcess>false</ExternalSystemDebugServerProcess>
+    <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
+    <DebugAllEnabled>false</DebugAllEnabled>
+    <RunAsTest>true</RunAsTest>
+    <method v="2" />
+  </configuration>
+</component>

NOTICE

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

README.md

@@ -2,74 +2,118 @@
 
 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) {
    fun dist() { sqrt(x*x + y*y) } 
 }
 Point(3,4).dist() //< 5
+
+fun swapEnds(first, args..., last, f) {
+    f( last, ...args, first)
+} 
 ```
 
-- 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
 
-### Add library
+### Add dependency to your project
 
-TBD
+```kotlin
+// update to current please:
+val lyngVersion = "0.6.1-SNAPSHOT"
+
+repositories {
+    // ...
+    maven("https://gitea.sergeych.net/api/packages/SergeychWorks/maven")
+}
+```
+
+And add dependency to the proper place in your project, it could look like:
+
+```kotlin
+comminMain by getting {
+    dependencies {
+        // ...
+        implementation("net.sergeych:lynglib:$lyngVersion")
+    }
+}
+```
+
+Now you can import lyng and use it:
 
 ### Execute script:
 
 ```kotlin
-assertEquals("hello, world", eval(""" 
-    "hello, " + "world" 
-    """).toString())
+import net.sergeyh.lyng.*
+
+// we need a coroutine to start, as Lyng
+// is a coroutine based language, async topdown
+runBlocking {
+    assert(5 == eval(""" 3*3 - 4 """).toInt())
+    eval(""" println("Hello, Lyng!") """)
+}
 ```
 
 ### 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 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? 
 
@@ -83,22 +127,75 @@ Designed to add scripting to kotlin multiplatform application in easy and effici
 
 # Language 
 
-- dynamic 
-- async
-- multithreaded (coroutines could be dispatched using threads on appropriate platforms, automatically)
+- Javascript, WasmJS, native, JVM, android - batteries included.
+- dynamic types in most elegant and concise way
+- async, 100% coroutines, supports multiple cores where platform supports thread
+- good for functional an object-oriented style
 
-## By-stage
+# Language Roadmap
 
-Here are plans to develop it:
+```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
+    
+```
 
-### First stage
+## v1.0.0 "Make it happen"
 
-Interpreted, precompiled into threaded code, actually. Dynamic types.
+Planned autumn 2025. Complete dynamic language with sufficient standard library:
 
-### Second stage
+Ready features:
 
-Will add:
+- [x] Language platform and independent command-line launcher
+- [x] Integral types and user classes, variables and constants, functions
+- [x] lambdas and closures, coroutines for all callables
+- [x] while-else, do-while-else, for-else loops with break-continue returning values and labels support
+- [x] ranges, lists, strings, interfaces: Iterable, Iterator, Collection, Array
+- [x] when(value), if-then-else
+- [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
 
-- optimizations
-- p-code serialization
-- static typing
+###  Under way: 
+
+- [ ] regular exceptions + extended `when`
+- [ ] multiple inheritance for user classes
+- [ ] site with integrated interpreter to give a try
+- [ ] kotlin part public API good docs, integration focused
+
+## 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
+- [ ] metadata first class access from lyng
+
+## After 1.5 "Ideal scripting"
+
+Estimated winter 2027
+
+- [ ] client with GUI support based on compose multiplatform somehow
+- [ ] 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

bin/lyng_test

@@ -0,0 +1,3 @@
+#!/usr/bin/env lyng
+
+println("Hello from lyng!")

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

@@ -0,0 +1,19 @@
+# Collection
+
+Is a [Iterable] with known `size`, a finite [Iterable]:
+
+    class Collection : 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
+[List]: List.md
+[Set]: Set.md

docs/Iterable.md

@@ -1,37 +1,141 @@
 # Iterable interface
 
-The inteface which requires iterator to be implemented:
+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.
 
-    fun iterator(): Iterator
+`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 {
+        abstract fun iterator()
+    }
+
+Note that each call of `iterator()` must provide an independent iterator.
 
 Iterator itself is a simple interface that should provide only to method:
 
-    interface Iterable {
-        fun hasNext(): Bool
+    class Iterator {
+        abstract fun hasNext(): Bool
         fun next(): Obj
     }
 
 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
 
-## Abstract 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
+    fun Iterable.indexOf(element): Int
+    fun Iterable.contains(element): Bool
+    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:
 
     fun iterator(): Iterator
 
-## Instance methods
-
-### toList()
-
 Creates a list by iterating to the end. So, the Iterator should be finite to be used with it.
 
 ## Included in interfaces:
 
-- Collection, Array, [List]
+- [Collection], Array, [List]
 
 ## 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

@@ -20,11 +20,11 @@ indexing is zero-based, as in C/C++/Java/Kotlin, etc.
     list[1]
     >>> 20
 
-Using negative indexes has a special meaning: _offset from the end of the list_:
+There is a shortcut for the last:
 
     val list = [10, 20, 30]
-    list[-1]
-    >>> 30
+    [list.last, list.lastIndex]
+    >>> [30,2]
 
 __Important__ negative indexes works wherever indexes are used, e.g. in insertion and removal methods too.
 
@@ -38,7 +38,8 @@ You can concatenate lists or iterable objects:
 
 ## Appending
 
-To append to lists, use `+=` with elements, lists and any [Iterable] instances, but beware it will concatenate [Iterable] objects instead of appending them. To append [Iterable] instance itself, use `list.add`:
+To append to lists, use `+=` with elements, lists and any [Iterable] instances, but beware it will
+concatenate [Iterable] objects instead of appending them. To append [Iterable] instance itself, use `list.add`:
 
     var list = [1, 2]
     val other = [3, 4]
@@ -57,7 +58,28 @@ To append to lists, use `+=` with elements, lists and any [Iterable] instances,
 
     >>> void
 
+## Removing elements
 
+List is mutable, so it is possible to remove its contents. To remove a single element
+by index use:
+
+    assertEquals( [1,2,3].removeAt(1), [1,3] )
+    assertEquals( [1,2,3].removeAt(0), [2,3] )
+    assertEquals( [1,2,3].removeLast(), [1,2] )
+    >>> void
+
+There is a way to remove a range (see [Range] for more on ranges):
+
+    assertEquals( [1, 4], [1,2,3,4].removeRange(1..2))
+    assertEquals( [1, 4], [1,2,3,4].removeRange(1..<3))
+    >>> void
+
+Open end ranges remove head and tail elements:
+
+    assertEquals( [3, 4, 5], [1,2,3,4,5].removeRange(..1))
+    assertEquals( [3, 4, 5], [1,2,3,4,5].removeRange(..<2))
+    assertEquals( [1, 2], [1,2,3,4,5].removeRange( (2..) ))
+    >>> void
 
 ## Comparisons
 
@@ -70,21 +92,79 @@ To append to lists, use `+=` with elements, lists and any [Iterable] instances,
     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      |
-| `addAt(index,elements...)`        | insert elements at position         | Int, Any |
-| `removeAt(index)`                 | remove element at position          | Int      |
-| `removeRangeInclusive(start,end)` | remove range, inclusive (1)         | Int, Int |
-|                                   |                                     |          |
+| 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)
-: end-inclisiveness allows to use negative indexes to, for exampe, remove several last elements, like `list.removeRangeInclusive(-2, -1)` will remove two last elements.
+: optimized implementation that override `Array` one
+
+(2)
+: `+=` 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.
+
+(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
+
+| name             | meaning                        | type  |
+|------------------|--------------------------------|-------|
+| `last`           | last element (throws if empty) |       |
+| `lastOrNull`     | last element or null           |       |
+| `lastIndex`      |                                | Int   |
+| `indices`        | range of indexes               | Range |
+| `contains(item)` | test that item is in the list  |       |
+
+(1)
+: end-inclisiveness allows to use negative indexes to, for exampe, remove several last elements, like
+`list.removeRangeInclusive(-2, -1)` will remove two last elements.
 
 
-# Notes
+[Range]: Range.md
 
-Could be rewritten using array as a class but List as the interface
+[Iterable]: Iterable.md

docs/Map.md

@@ -0,0 +1,113 @@
+# Map
+
+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" )
+    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" )
+    assertEquals( null, map["nonexisting"])
+    assert( map.getOrNull(101) == null )
+    assert( map.getOrPut(911) { "nine-eleven" } == "nine-eleven" )
+    // now 91 entry is set:
+    assert( map[911] == "nine-eleven" )
+    map["foo"] = -1
+    assert( map["foo"] == -1)
+    >>> void
+
+To remove item from the collection. use `remove`. It returns last removed item or null. Be careful if you 
+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"] )
+    assertEquals( 1, map.remove("foo") )
+    assert( map.getOrNull("foo") == null)
+    assert( map.size == 2 )
+    map.clear()
+    assert( map.size == 0 )
+    >>> void
+
+Map implements [contains] method that checks _the presence of the key_ in the map:
+
+    val map = Map( ["foo", 1], ["bar", "buzz"], [42, "answer"] )
+    assert( "foo" in map )
+    assert( "answer" !in map )
+    >>> void
+
+To iterate maps it is convenient to use `keys` method that returns [Set] of keys (keys are unique:
+
+    val map = Map( ["foo", 1], ["bar", "buzz"], [42, "answer"] )
+    for( k in map.keys ) println(map[k])
+    >>> 1
+    >>> buzz
+    >>> answer
+    >>> void
+
+Or iterate its key-value pairs that are instances of [MapEntry] class:
+
+    val map = Map( ["foo", 1], ["bar", "buzz"], [42, "answer"] )
+    for( entry in map ) {
+        println("map[%s] = %s"(entry.key, entry.value))
+    }
+    void
+    >>> map[foo] = 1
+    >>> map[bar] = buzz
+    >>> map[42] = answer
+    >>> void
+
+There is a shortcut to use `MapEntry` to create maps: operator `=>` which creates `MapEntry`:
+
+    val entry = "answer" => 42
+    assert( entry is MapEntry )
+    >>> void
+
+And you can use it to construct maps:
+
+    val map = Map( "foo" => 1, "bar" => 22)
+    assertEquals(1, map["foo"])
+    assertEquals(22, map["bar"])
+    >>> void
+
+Or use `.toMap` on anything that implements [Iterable] and which elements implements [Array] with 2 elements size, for example, `MapEntry`:
+
+    val map = ["foo" => 1, "bar" => 22].toMap()
+    assert( map is Map )
+    assertEquals(1, map["foo"])
+    assertEquals(22, map["bar"])
+    >>> void
+
+
+It is possible also to get values as [List] (values are not unique):
+
+    val map = Map( ["foo", 1], ["bar", "buzz"], [42, "answer"] )
+    assertEquals(map.values, [1, "buzz", "answer"] )
+    >>> void
+
+Map could be tested to be equal: when all it key-value pairs are equal, the map
+is equal.
+
+    val m1 = Map(["foo", 1])
+    val m2 = Map(["foo", 1])
+    val m3 = Map(["foo", 2])
+    assert( m1 == m2 )
+    // but the references are different:
+    assert( m1 !== m2 )
+    // different maps:
+    assert( m1 != m3 )
+    >>> void
+
+[Collection](Collection.md)

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,138 @@ 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" -> setValueForBar 
+
+                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"
+    }
+
+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.
+
 # Theory
 
 ## Basic principles:
@@ -216,11 +348,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/Set.md

@@ -0,0 +1,94 @@
+# List built-in class
+
+Mutable set of any objects: a group of different objects, no repetitions.
+Sets are not ordered, order of appearance does not matter.
+
+    val set = Set(1,2,3, "foo")
+    assert( 1 in set )
+    assert( "foo" in set)
+    assert( "bar" !in set)
+    >>> void
+
+## Set is collection and therefore [Iterable]:
+
+    assert( Set(1,2) is Set)
+    assert( Set(1,2) is Iterable)
+    assert( Set(1,2) is Collection)
+    >>> void
+
+So it supports all methods from [Iterable]; set is not, though, an [Array] and has
+no indexing. Use [set.toList] as needed.
+
+## Set operations
+
+    // Union
+    assertEquals( Set(1,2,3,4), Set(3, 1) + Set(2, 4))
+
+    // intersection
+    assertEquals( Set(1,4), Set(3, 1, 4).intersect(Set(2, 4, 1)) )
+    // or simple
+    assertEquals( Set(1,4), Set(3, 1, 4) * Set(2, 4, 1) )
+
+    // To find collection elements not present in another collection, use the 
+    // subtract() or `-`:
+    assertEquals( Set( 1, 2), Set(1, 2, 4, 3) - Set(3, 4))
+
+    >>> void
+
+## Adding elements
+
+    var s = Set()
+    s += 1
+    assertEquals( Set(1), s)
+    
+    s += [3, 3, 4]
+    assertEquals( Set(3, 4, 1), s)
+    >>> void
+
+## Removing elements
+
+List is mutable, so it is possible to remove its contents. To remove a single element
+by index use:
+
+    var s = Set(1,2,3)
+    s.remove(2)
+    assertEquals( s, Set(1,3) )
+
+    s = Set(1,2,3)
+    s.remove(2,1)
+    assertEquals( s, Set(3) )
+    >>> void
+
+Note that `remove` returns true if at least one element was actually removed and false
+if the set has not been changed.
+
+## Comparisons and inclusion
+
+Sets are only equal when contains exactly same elements, order, as was said, is not significant:
+
+    assert( Set(1, 2) == Set(2, 1) )
+    assert( Set(1, 2, 2) == Set(2, 1) )
+    assert( Set(1, 3) != Set(2, 1) )
+    assert( 1 in Set(5,1))
+    assert( 10 !in Set(5,1))
+    >>> void
+
+## Members
+
+| name                | meaning                              | type  |
+|---------------------|--------------------------------------|-------|
+| `size`              | current size                         | Int   |
+| `+=`                | add one or more elements             | Any   |
+| `+`, `union`         | union sets                           | Any   |
+| `-`, `subtract`     | subtract sets                        | Any   |
+| `*`, `intersect`    | subtract sets                        | Any   |
+| `remove(items...)`  | remove one or more items             | Range |
+| `contains(element)` | check the element is in the list (1) |       |
+
+(1)
+: optimized implementation that override `Iterable` one
+
+Also, it inherits methods from [Iterable].
+
+
+[Range]: Range.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
@@ -86,4 +88,73 @@ Lambda functions remember their scopes, so it will work the same as previous:
     val c = createLambda()
     println(c)
     >> 1
-    >> void
+    >> void
+
+# Elements of functional programming
+
+With ellipsis and splats you can create partial functions, manipulate
+arguments list in almost arbitrary ways. For example:
+
+    // Swap first and last arguments for call
+
+    fun swap_args(first, others..., last, f) { 
+        f(last, ...others, first) 
+    }
+
+    fun glue(args...) {
+        var result = ""
+        for( a in args ) result += a
+    }
+
+    assertEquals( 
+        "4231", 
+        swap_args( 1, 2, 3, 4, glue)
+    )
+    >>> 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/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

@@ -0,0 +1,171 @@
+# Exceptions handling
+
+Exceptions are widely used in modern programming languages, so
+they are implemented also in Lyng and in the most complete way.
+
+# Exception classes
+
+Exceptions are throwing instances of some class that inherits `Exception`
+across the code. Below is the list of built-in exceptions. Note that
+only objects that inherit `Exception` can be thrown. For example:
+
+    assert( IllegalArgumentException() is Exception)
+    >>> void
+
+# Try statement: catching exceptions
+
+There general pattern is:
+
+```
+try_statement = try_clause, [catch_clause, ...], [finally_clause] 
+
+try_clause = "try", "{", statements, "}"
+
+catch_clause = "catch", [(full_catch | shorter_catch)], "{", statements "}"
+
+full_catch = "(", catch_var, ":", exception_class [, excetpion_class...], ")
+
+shorter_catch = "(", catch_var, ")"
+
+finally_clause = "{", statements, "}"
+```
+
+Let's in details.
+
+## Full catch block:
+
+    val result = try {
+        throw IllegalArgumentException("the test")
+    }
+    catch( x: IndexOutOfBoundsException, IllegalArgumentException) {
+        x.message
+    }
+    catch(x: Exception) {
+        "bad"
+    }
+    assertEquals(result, "the test")
+    >>> void
+
+Because our exception is listed in a first catch block, it is processed there.
+
+The full form allow a single catch block to process exceptions with specified classes and bind actual caught object to
+the given variable. This is most common and well known form, implemented like this or similar in many other languages,
+like Kotlin, Java or C++.
+
+## Shorter form
+
+When you want to catch _all_ the exceptions, you should write `catch(e: Exception)`,
+but it is somewhat redundant, so there is simpler variant:
+
+    val sample2 = try {
+        throw IllegalArgumentException("sample 2")
+    }
+    catch(x) {
+        x.message
+    }
+    assertEquals( sample2, "sample 2" )
+    >>> void
+
+But well most likely you will find default variable `it`, like in Kotlin, more than enough
+to catch all exceptions to, then you can write it even shorter:
+
+    val sample2 = try {
+        throw IllegalArgumentException("sample 3")
+    }
+    catch {
+        it.message
+    }
+    assertEquals( sample2, "sample 3" )
+    >>> void
+
+You can even check the type of the `it` and create more convenient and sophisticated processing logic. Such approach is
+used, for example, in Scala.
+
+## finally block
+
+If `finally` block present, it will be executed after body (until first exception)
+and catch block, if any will match. finally statement is executed even if the
+exception will be thrown and not caught locally. It does not alter try/catch block result:
+
+    try {
+    }
+    finally {
+        println("called finally")
+    }
+    >>> called finally
+    >>> void
+
+- and yes, there could be try-finally block, no catching, but perform some guaranteed cleanup.
+
+# Conveying data with exceptions
+
+The simplest way is to provide exception string and `Exception` class:
+
+    try {
+        throw Exception("this is my exception")
+    }
+    catch {
+        it.message
+    }
+    >>> "this is my exception"
+
+This way, in turn, can also be shortened, as it is overly popular:
+
+    try {
+        throw "this is my exception"
+    }
+    catch {
+        it.message
+    }
+    >>> "this is my exception"
+
+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_
+
+# Standard exception classes
+
+| class                      | notes                                                 |
+|----------------------------|-------------------------------------------------------|
+| Exception                  | root of al throwable objects                          |
+| NullReferenceException     |                                                       |
+| AssertionFailedException   |                                                       | 
+| ClassCastException         |                                                       |
+| IndexOutOfBoundsException  |                                                       |
+| IllegalArgumentException   |                                                       | 
+| IllegalAssignmentException | assigning to val, etc.                                |
+| SymbolNotDefinedException  |                                                       |
+| IterationEndException      | attempt to read iterator past end, `hasNext == false` |
+| AccessException            | attempt to access private members or like             |
+| UnknownException           | unexpected kotlin exception caught                    |
+|                            |                                                       |
+

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.01)
+//}

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

@@ -12,10 +12,14 @@ In other word, the code usually works as expected when you see it. So, nothing u
 __Other documents to read__ maybe after this one:
 
 - [Advanced topics](advanced_topics.md), [declaring arguments](declaring_arguments.md)
-- [OOP notes](OOP.md)
+- [OOP notes](OOP.md), [exception handling](exceptions_handling.md)
 - [math in Lyng](math.md)
-- Some class references: [List], [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
 
@@ -118,6 +122,123 @@ These operators return rvalue, unmodifiable.
 
 ## Assignment return r-value!
 
+Naturally, assignment returns its value:
+
+    var x
+    x = 11
+    >>> 11
+
+rvalue means you cant assign the result if the assignment
+
+    var x
+    assertThrows { (x = 11) = 5 }
+    void
+    >>> void
+
+This also prevents chain assignments so use parentheses:
+
+    var x
+    var y
+    x = (y = 1)
+    >>> 1
+
+## Nullability
+
+When the value is `null`, it might throws `NullReferenceException`, the name is somewhat a tradition. To avoid it
+one can check it against null or use _null coalescing_. The null coalescing means, if the operand (left) is null,
+the operation won't be performed and the result will be null. Here is the difference:
+
+    val ref = null
+    assertThrows {  ref.field }
+    assertThrows {  ref.method() }
+    assertThrows {  ref.array[1] }
+    assertThrows {  ref[1] }
+    assertThrows {  ref() }
+    
+    assert( ref?.field == null )
+    assert( ref?.method() == null )
+    assert( ref?.array?[1] == null )
+    assert( ref?[1] == null )
+    assert( ref?() == null )
+    >>> void
+
+There is also "elvis operator", null-coalesce infix operator '?:' that returns rvalue if lvalue is `null`:
+
+    null ?: "nothing"
+    >>> "nothing"
+
+## Utility functions
+
+The following functions simplify nullable values processing and
+allow to improve code look and readability. There are borrowed from Kotlin:
+
+### 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
+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
+    class GlobalState(nullableParam)
+    
+    val state = GlobalState(null)
+
+    fun sample() {
+        state.nullableParam?.let { "it's not null: "+it} ?: "it's null"
+    }
+    assertEquals(sample(), "it's null")
+    state.nullableParam = 5
+    assertEquals(sample(), "it's not null: 5")
+    >>> void
+
+This is the same as:
+
+    fun sample() {
+        val it = state.nullableParam
+        if( it != null )  "it's not null: "+it else "it's null"
+    }
+
+The important is that nullableParam got a local copy that can't be changed from any
+parallel thread/coroutine. Remember: Lyng _is __not__ a single-threaded language_.
+
+## Also
+
+Much like let, but it does not alter returned value:
+
+    assert( "test".also { println( it + "!") } == "test" )
+    >>> test!
+    >>> void
+
+While it is not altering return value, the source object could be changed:
+
+    class Point(x,y)
+    val p = Point(1,2).also { it.x++ }
+    assertEquals(p.x, 2)
+    >>> void
+
+## apply
+
+It works much like `also`, but is executed in the context of the source object:
+
+    class Point(x,y)
+    // see the difference: apply changes this to newly created Point:
+    val p = Point(1,2).apply { x++; y++ }
+    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:
@@ -154,6 +275,8 @@ Logical operation could be used the same
 |   ===    |     | Any               | (2)      |
 |   !==    |     | Any               | (2)      |
 |    !=    |     | Any               | (1)      |
+|    =~    |     |                   | (3)      |
+|    !~    |     |                   | (3)      |
 | ++a, a++ |     | Int               |          |
 | --a, a-- |     | Int               |          |
 
@@ -165,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
@@ -361,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:
@@ -369,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:
 
@@ -386,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:
 
@@ -427,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]
@@ -458,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]
@@ -469,40 +596,40 @@ To add elements to the list:
     assert( x == [1, 2, 3, "the", "end"])
     >>> void
 
-Self-modifying concatenation by `+=` also works:
+Self-modifying concatenation by `+=` also works (also with single elements):
 
     val x = [1, 2]
     x += [3, 4]
-    assert( x == [1, 2, 3, 4])
+    x += 5
+    assert( x == [1, 2, 3, 4, 5])
     >>> void
 
-You can insert elements at any position using `addAt`:
+You can insert elements at any position using `insertAt`:
 
     val x = [1,2,3]
-    x.addAt(1, "foo", "bar")
+    x.insertAt(1, "foo", "bar")
     assert( x == [1, "foo", "bar", 2, 3])
     >>> void
 
 Using splat arguments can simplify inserting list in list:
 
     val x = [1, 2, 3]
-    x.addAt( 1, ...[0,100,0])
+    x.insertAt( 1, ...[0,100,0])
     x
-    >>> [1, 0, 100, 0, 2, 3]
-
-Using negative indexes can insert elements as offset from the end, for example:
-
-    val x = [1,2,3]
-    x.addAt(-1, 10)
-    x
-    >>> [1, 2, 10, 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.addAt(3, 10)
+    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]
 
 ## Removing list items
 
@@ -510,23 +637,59 @@ Note that to add to the end you still need to use `add` or positive index of the
     x.removeAt(2)
     assert( x == [1, 2, 4, 5])
     // or remove range (start inclusive, end exclusive):
-    x.removeRangeInclusive(1,2)    
+    x.removeRange(1..2)    
     assert( x == [1, 5])
     >>> void
 
-Again, you can use negative indexes. For example, removing last elements like:
+There is a shortcut to remove the last elements:
 
     val x = [1, 2, 3, 4, 5]
 
     // remove last:
-    x.removeAt(-1)
+    x.removeLast()
     assert( x == [1, 2, 3, 4])
     
     // remove 2 last:
-    x.removeRangeInclusive(-2,-1)
-    assert( x == [1, 2])
+    x.removeLast(2)
+    assertEquals( [1, 2], x)
     >>> void
 
+You can get ranges to extract a portion from a list:
+
+    val list = [1, 2, 3, 4, 5]
+    assertEquals( [1,2,3], list[..2])
+    assertEquals( [1,2,], list[..<2])
+    assertEquals( [4,5], list[3..])
+    assertEquals( [2,3], list[1..2])
+    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.
+
+    assertEquals( Set(3, 2, 1), Set( 1, 2, 3))
+    assert( 5 !in Set(1, 2, 6) )
+    >>> void
+
+Please see [Set] for detailed description.
+
+# Maps
+
+Maps are unordered collection of key-value pairs, where keys are unique. See [Map] for details. Map also
+are [Iterable]:
+
+    val m = Map( "foo" => 77, "bar" => "buzz" )
+    assertEquals( m["foo"], 77 )
+    >>> void
+
+Please see [Map] reference for detailed description on using Maps.
+
 # Flow control operators
 
 ## if-then-else
@@ -552,6 +715,99 @@ Or, more neat:
     >>> just 3
     >>> void
 
+## When
+
+It is very much like the kotlin's:
+
+    fun type(x) {
+        when(x) {
+            in 'a'..'z', in 'A'..'Z' -> "letter"
+            in '0'..'9' -> "digit"
+            '$' -> "dollar"
+            "EUR" -> "crap"
+            in ['@', '#', '^'] -> "punctuation1"
+            in "*&.," -> "punctuation2"
+            else -> "unknown"
+        }
+    }
+    assertEquals("digit", type('3'))
+    assertEquals("dollar", type('$'))
+    assertEquals("crap", type("EUR"))
+    >>> void
+
+Notice, several conditions can be grouped with a comma.
+Also, you can check the type too:
+
+    fun type(x) {
+        when(x) {
+            "42", 42 -> "answer to the great question"
+            is Real, is Int -> "number"
+            is String -> {
+                for( d in x ) {
+                    if( d !in '0'..'9' ) 
+                        break "unknown"
+                }
+                else "number"
+            }
+        }
+    }
+    assertEquals("number", type(5))
+    assertEquals("number", type("153"))
+    assertEquals("number", type(π/2))
+    assertEquals("unknown", type("12%"))
+    assertEquals("answer to the great question", type(42))
+    assertEquals("answer to the great question", type("42"))
+    >>> void
+
+### supported when conditions:
+
+#### 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.
+
+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 (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:
+
+    assert( "more" in "a".."z") // string range ok
+    assert( 'x' !in "a".."z") // char in string range: probably error
+    assert( 'x' in 'a'..'z') // character range: ok
+    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:
+
+    "foo" in "foobar"
+    >>> true
+
+and also character inclusion:
+
+    'o' in "foobar"
+    >>> true
+
 ## while
 
 Regular pre-condition while loop, as expression, loop returns the last expression as everything else:
@@ -617,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
@@ -663,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.
@@ -701,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 {
@@ -712,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
@@ -753,6 +1011,62 @@ We can use labels too:
     assert( search(["hello", "world"], 'z') == null)
     >>> void
 
+# 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:
+
+    var error = "not caught"
+    var finallyCaught = false
+    val result = try {
+        throw IllegalArgumentException()
+        "invalid"
+    }
+    catch(nd: SymbolNotDefinedException) {
+        error = "bad catch"
+    }
+    catch(x: IllegalArgumentException) {
+        error = "no error"
+        "OK"
+    }
+    finally {
+        // finally does not affect returned value
+        "too bad"
+    }
+    assertEquals( "no error", error)
+    assertEquals( "OK", result)
+    >>> void
+
+There is shorter form of catch block when you want to catch any exception:
+
+    var caught = null
+    try {
+        throw IllegalArgumentException()
+    }
+    catch(t) { // same as catch(t: Exception), but simpler
+        caught = t
+    }
+    assert( caught is IllegalArgumentException )
+    >>> void
+
+And even shortest, for the Lying lang tradition, missing var is `it`:
+
+    var caught = null
+    try {
+        throw IllegalArgumentException()
+    }
+    catch { // same as catch(it: Exception), but simpler
+        caught = it
+    }
+    assert( caught is IllegalArgumentException )
+    >>> void
+
+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:
@@ -817,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
@@ -843,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:
@@ -850,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      |
@@ -864,38 +1235,115 @@ Are the same as in string literals with little difference:
 | code   | Int  | Unicode code for the character |
 |        |      |                                |
 
-
 ## String details
 
-Strings are much like Kotlin ones:
+Strings are arrays of Unicode characters. It can be indexed, and indexing will
+return a valid Unicode character at position. No utf hassle:
 
-    "Hello".length
+    "Парашют"[5]
+    >>> 'ю'
+
+Its length is, of course, in characters:
+
+    "разум".length
     >>> 5
+
 And supports growing set of kotlin-borrowed operations, see below, for example:
 
     assertEquals("Hell", "Hello".dropLast(1))
     >>> void
 
+To format a string use sprintf-style modifiers like:
+
+    val a = "hello"
+    val b = 11
+    assertEquals( "hello:11", "%s:%d"(a, b) )
+    assertEquals( " hello:    11", "%6s:%6d"(a, b) )
+    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.
+
+This list will be extended.
+
+To get the substring use:
+
+    assertEquals("pult", "catapult".takeLast(4))
+    assertEquals("cat", "catapult".take(3))
+    assertEquals("cat", "catapult".dropLast(5))
+    assertEquals("pult", "catapult".drop(4))
+    >>> void
+
+And to get a portion you can slice it with range as the index:
+
+    assertEquals( "tap", "catapult"[ 2 .. 4 ])
+    assertEquals( "tap", "catapult"[ 2 ..< 5 ])
+    >>> void
+
+Open-ended ranges could be used to get start and end too:
+
+    assertEquals( "cat", "catapult"[ ..< 3 ])
+    assertEquals( "cat", "catapult"[ .. 2 ])
+    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:
 
-| fun/prop         | description / notes                                        |
-|------------------|------------------------------------------------------------|
-| lower()          | change case to unicode upper                               |
-| upper()          | change case to unicode lower                               |
+| fun/prop           | description / notes                                        |
+|--------------------|------------------------------------------------------------|
+| 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                               |
-| take(n)          | get a new string from up to n first characters             |
-| takeLast(n)      | get a new string from up to n last characters              |
-| drop(n)          | get a new string dropping n first chars, or empty string   |
-| dropLast(n)      | get a new string dropping n last chars, or empty string    |
-| size             | size in characters like `length` because String is [Array] |
-
+| endsWith(prefix)   | true if ends with a prefix                                 |
+| take(n)            | get a new string from up to n first characters             |
+| takeLast(n)        | get a new string from up to n last characters              |
+| drop(n)            | get a new string dropping n first chars, or empty string   |
+| dropLast(n)        | get a new string dropping n last chars, or empty string    |
+| 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 (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
 
@@ -904,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
 
@@ -923,9 +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 formatting]: https://github.com/sergeych/mp_stools?tab=readme-ov-file#sprintf-syntax-summary
+
+[Set]: Set.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

@@ -4,10 +4,11 @@ clikt = "5.0.3"
 kotlin = "2.1.21"
 android-minSdk = "24"
 android-compileSdk = "34"
-kotlinx-coroutines = "1.10.1"
+kotlinx-coroutines = "1.9.0"
 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.
 #
+#
 
 ##############################################################################
 #

happy.py

@@ -1,11 +0,0 @@
-count = 0
-for n1 in range(10):
-    for n2 in range(10):
-        for n3 in range(10):
-            for n4 in range(10):
-                for n5 in range(10):
-                    for n6 in range(10):
-                        if n1 + n2 + n3 == n4 + n5 + n6:
-                            count += 1
-
-print(count)

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

@@ -1,8 +0,0 @@
-package net.sergeych.lyng
-
-enum class AccessType(val isMutable: Boolean) {
-    Val(false), Var(true),
-
-    @Suppress("unused")
-    Initialization(false)
-}

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

@@ -1,41 +0,0 @@
-package net.sergeych.lyng
-
-data class ParsedArgument(val value: Statement, val pos: Pos, val isSplat: Boolean = false)
-
-suspend fun Collection<ParsedArgument>.toArguments(context: Context,tailBlockMode: Boolean): Arguments {
-    val list = mutableListOf<Obj>()
-
-    for (x in this) {
-        val value = x.value.execute(context)
-        if (x.isSplat) {
-            when {
-                value is ObjList -> {
-                    for (subitem in value.list) list.add(subitem)
-                }
-
-                value.isInstanceOf(ObjIterable) -> {
-                    val i = (value.invokeInstanceMethod(context, "toList") as ObjList).list
-                    i.forEach { list.add(it) }
-                }
-
-                else -> context.raiseClassCastError("expected list of objects for splat argument")
-            }
-        } else
-            list.add(value)
-    }
-    return Arguments(list,tailBlockMode)
-}
-
-data class Arguments(val list: List<Obj>,val tailBlockMode: Boolean = false) : List<Obj> by list {
-
-    fun firstAndOnly(pos: Pos = Pos.UNKNOWN): Obj {
-        if (list.size != 1) throw ScriptError(pos, "expected one argument, got ${list.size}")
-        return list.first()
-    }
-
-    companion object {
-        val EMPTY = Arguments(emptyList())
-        fun from(values: Collection<Obj>) = Arguments(values.toList())
-    }
-}
-

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

@@ -1,19 +0,0 @@
-package net.sergeych.lyng
-
-//fun buildDoubleFromParts(
-//    integerPart: Long,
-//    decimalPart: Long,
-//    exponent: Int
-//): Double {
-//    // Handle zero decimal case efficiently
-//    val numDecimalDigits = if (decimalPart == 0L) 0 else decimalPart.toString().length
-//
-//    // Calculate decimal multiplier (10^-digits)
-//    val decimalMultiplier = 10.0.pow(-numDecimalDigits)
-//
-//    // Combine integer and decimal parts
-//    val baseValue = integerPart.toDouble() + decimalPart.toDouble() * decimalMultiplier
-//
-//    // Apply exponent
-//    return baseValue * 10.0.pow(exponent)
-//}

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

@@ -1,152 +0,0 @@
-package net.sergeych.lyng
-
-internal 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
-        val result = f()
-        return Pair(breakFound, result).also {
-            --loopLevel
-        }
-    }
-
-    var currentIndex = 0
-
-    fun hasNext() = currentIndex < tokens.size
-    fun hasPrevious() = currentIndex > 0
-    fun next() = tokens.getOrElse(currentIndex) { throw IllegalStateException("No next token") }.also { currentIndex++ }
-    fun previous() = if (!hasPrevious()) throw IllegalStateException("No previous token") else tokens[--currentIndex]
-
-    fun savePos() = currentIndex
-    fun restorePos(pos: Int) {
-        currentIndex = pos
-    }
-
-    fun ensureLabelIsValid(pos: Pos, label: String) {
-        if (label !in labels)
-            throw ScriptError(pos, "Undefined label '$label'")
-    }
-
-    @Suppress("unused")
-    fun requireId() = requireToken(Token.Type.ID, "identifier is required")
-
-    fun requireToken(type: Token.Type, message: String = "required ${type.name}"): Token =
-        next().also {
-            if (type != it.type) throw ScriptError(it.pos, message)
-        }
-
-    @Suppress("unused")
-    fun syntaxError(at: Pos, message: String = "Syntax error"): Nothing {
-        throw ScriptError(at, message)
-    }
-
-    fun currentPos() =
-        if (hasNext()) next().pos.also { previous() }
-        else previous().pos.also { next() }
-
-    /**
-     * Skips next token if its type is `tokenType`, returns `true` if so.
-     * @param errorMessage message to throw if next token is not `tokenType`
-     * @param isOptional if `true` and token is not of `tokenType`, just return `false` and does not skip it
-     * @return `true` if the token was skipped
-     * @throws ScriptError if [isOptional] is `false` and next token is not of [tokenType]
-     */
-    fun skipTokenOfType(
-        tokenType: Token.Type,
-        errorMessage: String = "expected ${tokenType.name}",
-        isOptional: Boolean = false
-    ): Boolean {
-        val t = next()
-        return if (t.type != tokenType) {
-            if (!isOptional) {
-                println("unexpected: $t (needed $tokenType)")
-                throw ScriptError(t.pos, errorMessage)
-            } else {
-                previous()
-                false
-            }
-        } else true
-    }
-
-    @Suppress("unused")
-    fun skipTokens(vararg tokenTypes: Token.Type) {
-        while (next().type in tokenTypes) { /**/
-        }
-        previous()
-    }
-
-
-    fun ifNextIs(typeId: Token.Type, f: (Token) -> Unit): Boolean {
-        val t = next()
-        return if (t.type == typeId) {
-            f(t)
-            true
-        } else {
-            previous()
-            false
-        }
-    }
-
-    inline fun addBreak() {
-        breakFound = true
-    }
-
-    /**
-     * Return value of the next token if it is an identifier, null otherwise.
-     * Does not change position.
-     */
-    fun nextIdValue(): String? {
-        return if (hasNext()) {
-            val nt = tokens[currentIndex]
-            if (nt.type == Token.Type.ID)
-                nt.value
-            else null
-        } else null
-    }
-
-    @Suppress("unused")
-    fun current(): Token = tokens[currentIndex]
-
-    /**
-     * If the token at current position plus offset (could be negative) exists, returns it, otherwise returns null.
-     */
-    fun atOffset(offset: Int): Token? =
-        if (currentIndex + offset in tokens.indices) tokens[currentIndex + offset] else null
-
-    /**
-     * Scan backwards as deep as specified looking for visibility token. Does not change position.
-     */
-    fun getVisibility(default: Visibility = Visibility.Public, depths: Int = 2): Visibility {
-        for( i in -depths .. -1) {
-            when( atOffset(i)?.type) {
-                Token.Type.PROTECTED -> return Visibility.Protected
-                Token.Type.PRIVATE -> return Visibility.Private
-                else -> {}
-            }
-        }
-        return default
-    }
-
-//    fun expectKeyword(vararg keyword: String): String {
-//        val t = next()
-//        if (t.type != Token.Type.ID && t.value !in keyword) {
-//            throw ScriptError(t.pos, "expected one of ${keyword.joinToString()}")
-//
-//    }
-
-//    data class ReturnScope(val needCatch: Boolean = false)
-
-//    private val
-
-//    fun startReturnScope(): ReturnScope {
-//        return ReturnScope()
-//    }
-
-}

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

@@ -1,123 +0,0 @@
-package net.sergeych.lyng
-
-class Context(
-    val parent: Context?,
-    val args: Arguments = Arguments.EMPTY,
-    var pos: Pos = Pos.builtIn,
-    val thisObj: Obj = ObjVoid,
-    var skipContextCreation: Boolean = false,
-) {
-    constructor(
-        args: Arguments = Arguments.EMPTY,
-        pos: Pos = Pos.builtIn,
-    )
-            : this(Script.defaultContext, args, pos)
-
-    fun raiseNotImplemented(what: String = "operation"): Nothing = raiseError("$what is not implemented")
-
-    @Suppress("unused")
-    fun raiseNPE(): Nothing = raiseError(ObjNullPointerError(this))
-
-    @Suppress("unused")
-    fun raiseIndexOutOfBounds(message: String = "Index out of bounds"): Nothing =
-        raiseError(ObjIndexOutOfBoundsError(this, message))
-
-    @Suppress("unused")
-    fun raiseArgumentError(message: String = "Illegal argument error"): Nothing =
-        raiseError(ObjIllegalArgumentError(this, message))
-
-    fun raiseClassCastError(msg: String): Nothing = raiseError(ObjClassCastError(this, msg))
-
-    @Suppress("unused")
-    fun raiseSymbolNotFound(name: String): Nothing =
-        raiseError(ObjSymbolNotDefinedError(this, "symbol is not defined: $name"))
-
-    fun raiseError(message: String): Nothing {
-        throw ExecutionError(ObjError(this, message))
-    }
-
-    fun raiseError(obj: ObjError): 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 val objects = mutableMapOf<String, ObjRecord>()
-
-    operator fun get(name: String): ObjRecord? =
-        objects[name]
-            ?: parent?.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
-
-
-}

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

@@ -1,7 +0,0 @@
-package net.sergeych.lyng
-
-sealed class ListEntry {
-    data class Element(val accessor: Accessor) : ListEntry()
-
-    data class Spread(val accessor: Accessor) : ListEntry()
-}

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

@@ -1,7 +0,0 @@
-package net.sergeych.lyng
-
-class LoopBreakContinueException(
-    val doContinue: Boolean,
-    val result: Obj = ObjVoid,
-    val label: String? = null
-) : RuntimeException()

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

@@ -1,347 +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.synctools.ProtectedOp
-
-/**
- * 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 {
-    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
-
-    fun isInstanceOf(someClass: Obj) = someClass === objClass || objClass.allParentsSet.contains(someClass)
-
-    suspend fun invokeInstanceMethod(context: Context, name: String, vararg args: Obj): Obj =
-        invokeInstanceMethod(context, name, Arguments(args.toList()))
-
-    inline suspend 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 {
-        context.raiseNotImplemented()
-    }
-
-    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 by lazy {
-        ObjClass("Obj").apply {
-            addFn("toString") {
-                thisObj.asStr
-            }
-            addFn("contains") {
-                ObjBool(thisObj.contains(this, args.firstAndOnly()))
-            }
-        }
-    }
-
-    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()
-    }
-
-    fun willMutate(context: Context) {
-        if (isFrozen) context.raiseError("attempt to mutate frozen object")
-    }
-
-    suspend fun <T> sync(block: () -> T): T = monitor.withLock { block() }
-
-    suspend open fun readField(context: Context, name: String): ObjRecord {
-        // could be property or class field:
-        val obj = objClass.getInstanceMemberOrNull(name) ?: context.raiseError("no such field: $name")
-        val value = obj.value
-        return when (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: Int): 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 {
-        inline fun <reified T> from(obj: T): Obj {
-            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)
-                Unit -> ObjVoid
-                null -> ObjNull
-                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 fun toString(): String = "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 ObjError(val context: Context, val message: String) : Obj() {
-    override val asStr: ObjString by lazy { ObjString("Error: $message") }
-
-    fun raise(): Nothing {
-        throw ExecutionError(this)
-    }
-}
-
-class ObjNullPointerError(context: Context) : ObjError(context, "object is null")
-
-class ObjAssertionError(context: Context, message: String) : ObjError(context, message)
-class ObjClassCastError(context: Context, message: String) : ObjError(context, message)
-class ObjIndexOutOfBoundsError(context: Context, message: String = "index out of bounds") : ObjError(context, message)
-class ObjIllegalArgumentError(context: Context, message: String = "illegal argument") : ObjError(context, message)
-class ObjIllegalAssignmentError(context: Context, message: String = "illegal assignment") : ObjError(context, message)
-class ObjSymbolNotDefinedError(context: Context, message: String = "symbol is not defined") : ObjError(context, message)
-class ObjIterationFinishedError(context: Context) : ObjError(context, "iteration finished")
-class ObjAccessError(context: Context, message: String = "access not allowed error") : ObjError(context, message)

library/src/commonMain/kotlin/net/sergeych/lyng/ObjBool.kt

@@ -1,27 +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())
-
-    companion object {
-        val type = ObjClass("Bool")
-    }
-}
-
-val ObjTrue = ObjBool(true)
-val ObjFalse = ObjBool(false)

library/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()) }
-        }
-    }
-}

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

@@ -1,151 +0,0 @@
-package net.sergeych.lyng
-
-val ObjClassType by lazy { ObjClass("Class") }
-
-class ObjClass(
-    val className: String,
-    vararg val parents: ObjClass,
-) : Obj() {
-
-    var instanceConstructor: Statement? = null
-
-    val allParentsSet: Set<ObjClass> = parents.flatMap {
-        listOf(it) + it.allParentsSet
-    }.toSet()
-
-    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
-    ) {
-        if (name in members || allParentsSet.any { name in it.members })
-            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 null
-    }
-
-    fun getInstanceMember(atPos: Pos, name: String): ObjRecord =
-        getInstanceMemberOrNull(name)
-            ?: throw ScriptError(atPos, "symbol doesn't exist: $name")
-}
-
-/**
- * Abstract class that must provide `iterator` method that returns [ObjIterator] instance.
- */
-val ObjIterable by lazy {
-    ObjClass("Iterable").apply {
-
-        addFn("toList") {
-            val result = mutableListOf<Obj>()
-            val iterator = thisObj.invokeInstanceMethod(this, "iterator")
-
-            while (iterator.invokeInstanceMethod(this, "hasNext").toBool())
-                result += iterator.invokeInstanceMethod(this, "next")
-
-
-//        val next = iterator.getMemberOrNull("next")!!
-//        val hasNext = iterator.getMemberOrNull("hasNext")!!
-//        while( hasNext.invoke(this, iterator).toBool() )
-//            result += next.invoke(this, iterator)
-            ObjList(result)
-        }
-
-    }
-}
-
-/**
- * Collection is an iterator with `size`]
- */
-val ObjCollection by lazy {
-    val i: ObjClass = ObjIterable
-    ObjClass("Collection", i)
-}
-
-val ObjIterator by lazy { ObjClass("Iterator") }
-
-class ObjArrayIterator(val array: Obj) : Obj() {
-
-    override val objClass: ObjClass by lazy { type }
-
-    private var nextIndex = 0
-    private var lastIndex = 0
-
-    suspend fun init(context: Context) {
-        nextIndex = 0
-        lastIndex = array.invokeInstanceMethod(context, "size").toInt()
-        ObjVoid
-    }
-
-    companion object {
-        val type by lazy {
-            ObjClass("ArrayIterator", ObjIterator).apply {
-                addFn("next") {
-                    val self = thisAs<ObjArrayIterator>()
-                    if (self.nextIndex < self.lastIndex) {
-                        self.array.invokeInstanceMethod(this, "getAt", (self.nextIndex++).toObj())
-                    } else raiseError(ObjIterationFinishedError(this))
-                }
-                addFn("hasNext") {
-                    val self = thisAs<ObjArrayIterator>()
-                    if (self.nextIndex < self.lastIndex) ObjTrue else ObjFalse
-                }
-            }
-        }
-    }
-}
-
-
-val ObjArray by lazy {
-
-    /**
-     * Array abstract class is a [ObjCollection] with `getAt` method.
-     */
-    ObjClass("Array", ObjCollection).apply {
-        // we can create iterators using size/getat:
-
-        addFn("iterator") {
-            ObjArrayIterator(thisObj).also { it.init(this) }
-        }
-        addFn("isample") { "ok".toObj() }
-    }
-}
-

library/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(ObjAccessError(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)
-                ObjIllegalAssignmentError(context, "can't assign to non-public field $name")
-            if (!f.isMutable) ObjIllegalAssignmentError(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(ObjAccessError(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
-    }
-}

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

@@ -1,80 +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 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
-    }
-
-    companion object {
-        val type = ObjClass("Int")
-    }
-}
-
-fun Int.toObj() = ObjInt(this.toLong())

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

@@ -1,137 +0,0 @@
-package net.sergeych.lyng
-
-class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
-
-    init {
-        for (p in objClass.parents)
-            parentInstances.add(p.defaultInstance())
-    }
-
-    override fun toString(): String = "[${
-        list.joinToString(separator = ", ") { it.inspect() }
-    }]"
-
-    fun normalize(context: Context, index: Int, allowisEndInclusive: Boolean = false): Int {
-        val i = if (index < 0) list.size + index else index
-        if (allowisEndInclusive && i == list.size) return i
-        if (i !in list.indices) context.raiseError("index $index out of bounds for size ${list.size}")
-        return i
-    }
-
-    override suspend fun getAt(context: Context, index: Int): Obj {
-        val i = normalize(context, index)
-        return list[i]
-    }
-
-    override suspend fun putAt(context: Context, index: Int, newValue: Obj) {
-        val i = normalize(context, index)
-        list[i] = newValue
-    }
-
-    override suspend fun compareTo(context: Context, other: Obj): Int {
-        if (other !is ObjList) return -2
-        val mySize = list.size
-        val otherSize = other.list.size
-        val commonSize = minOf(mySize, otherSize)
-        for (i in 0..<commonSize) {
-            if (list[i].compareTo(context, other.list[i]) != 0) {
-                return list[i].compareTo(context, other.list[i])
-            }
-        }
-        // equal so far, longer is greater:
-        return when {
-            mySize < otherSize -> -1
-            mySize > otherSize -> 1
-            else -> 0
-        }
-    }
-
-    override suspend fun plus(context: Context, other: Obj): Obj =
-        when {
-            other is ObjList ->
-                ObjList((list + other.list).toMutableList())
-
-            other.isInstanceOf(ObjIterable) -> {
-                val l = other.callMethod<ObjList>(context, "toList")
-                ObjList((list + l.list).toMutableList())
-            }
-
-            else ->
-                context.raiseError("'+': can't concatenate $this with $other")
-        }
-
-
-    override suspend fun plusAssign(context: Context, other: Obj): Obj {
-        // optimization
-        if (other is ObjList) {
-            list += other.list
-            return this
-        }
-        if (other.isInstanceOf(ObjIterable)) {
-            val otherList = other.invokeInstanceMethod(context, "toList") as ObjList
-            list += otherList.list
-        } else
-            list += other
-        return this
-    }
-
-    override val objClass: ObjClass
-        get() = type
-
-    companion object {
-        val type = ObjClass("List", ObjArray).apply {
-
-            createField("size",
-                statement {
-                    (thisObj as ObjList).list.size.toObj()
-                }
-            )
-            addFn("getAt") {
-                requireExactCount(1)
-                thisAs<ObjList>().getAt(this, requiredArg<ObjInt>(0).value.toInt())
-            }
-            addFn("putAt") {
-                requireExactCount(2)
-                val newValue = args[1]
-                thisAs<ObjList>().putAt(this, requiredArg<ObjInt>(0).value.toInt(), newValue)
-                newValue
-            }
-            createField("add",
-                statement {
-                    val l = thisAs<ObjList>().list
-                    for (a in args) l.add(a)
-                    ObjVoid
-                }
-            )
-            createField("addAt",
-                statement {
-                    if (args.size < 2) raiseError("addAt takes 2+ arguments")
-                    val l = thisAs<ObjList>()
-                    var index = l.normalize(
-                        this, requiredArg<ObjInt>(0).value.toInt(),
-                        allowisEndInclusive = true
-                    )
-                    for (i in 1..<args.size) l.list.add(index++, args[i])
-                    ObjVoid
-                }
-            )
-            addFn("removeAt") {
-                val self = thisAs<ObjList>()
-                val start = self.normalize(this, requiredArg<ObjInt>(0).value.toInt())
-                if (args.size == 2) {
-                    val end = requireOnlyArg<ObjInt>().value.toInt()
-                    self.list.subList(start, self.normalize(this, end)).clear()
-                } else
-                    self.list.removeAt(start)
-                self
-            }
-            addFn("removeRangeInclusive") {
-                val self = thisAs<ObjList>()
-                val start = self.normalize(this, requiredArg<ObjInt>(0).value.toInt())
-                val end = self.normalize(this, requiredArg<ObjInt>(1).value.toInt()) + 1
-                self.list.subList(start, end).clear()
-                self
-            }
-        }
-    }
-}

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

@@ -1,101 +0,0 @@
-package net.sergeych.lyng
-
-class ObjRange(val start: Obj?, val end: Obj?, val isEndInclusive: Boolean) : Obj() {
-
-    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() }
-            }
-        }
-    }
-}
-

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

@@ -1,49 +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 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 val objClass: ObjClass = type
-
-    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())
-
-    companion object {
-        val type: ObjClass = ObjClass("Real").apply {
-            createField(
-                "roundToInt",
-                statement(Pos.builtIn) {
-                    (it.thisObj as ObjReal).value.roundToLong().toObj()
-                },
-            )
-        }
-    }
-}

library/src/commonMain/kotlin/net/sergeych/lyng/ObjString.kt

@@ -1,72 +0,0 @@
-package net.sergeych.lyng
-
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
-
-@Serializable
-@SerialName("string")
-data class ObjString(val value: String) : Obj() {
-
-    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: Int): Obj {
-        return ObjChar(value[index])
-    }
-
-    companion object {
-        val type = ObjClass("String").apply {
-            addConst("startsWith",
-                statement {
-                    ObjBool(thisAs<ObjString>().value.startsWith(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()) }
-        }
-    }
-}

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

@@ -1,170 +0,0 @@
-package net.sergeych.lyng
-
-import kotlinx.coroutines.delay
-import kotlin.math.*
-
-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 {
-        var lastResult: Obj = ObjVoid
-        for (s in statements) {
-            lastResult = s.execute(context)
-        }
-        return lastResult
-    }
-
-    suspend fun execute() = execute(defaultContext.copy(pos = pos))
-
-    companion object {
-        val defaultContext: Context = Context().apply {
-            addFn("println") {
-                for ((i, a) in args.withIndex()) {
-                    if (i > 0) print(' ' + a.asStr.value)
-                    else print(a.asStr.value)
-                }
-                println()
-                ObjVoid
-            }
-            addFn("floor") {
-                val x = args.firstAndOnly()
-                (if (x is ObjInt) x
-                else ObjReal(floor(x.toDouble())))
-            }
-            addFn("ceil") {
-                val x = args.firstAndOnly()
-                (if (x is ObjInt) x
-                else ObjReal(ceil(x.toDouble())))
-            }
-            addFn("round") {
-                val x = args.firstAndOnly()
-                (if (x is ObjInt) x
-                else ObjReal(round(x.toDouble())))
-            }
-
-            addFn("sin") {
-                ObjReal(sin(args.firstAndOnly().toDouble()))
-            }
-            addFn("cos") {
-                ObjReal(cos(args.firstAndOnly().toDouble()))
-            }
-            addFn("tan") {
-                ObjReal(tan(args.firstAndOnly().toDouble()))
-            }
-            addFn("asin") {
-                ObjReal(asin(args.firstAndOnly().toDouble()))
-            }
-            addFn("acos") {
-                ObjReal(acos(args.firstAndOnly().toDouble()))
-            }
-            addFn("atan") {
-                ObjReal(atan(args.firstAndOnly().toDouble()))
-            }
-
-            addFn("sinh") {
-                ObjReal(sinh(args.firstAndOnly().toDouble()))
-            }
-            addFn("cosh") {
-                ObjReal(cosh(args.firstAndOnly().toDouble()))
-            }
-            addFn("tanh") {
-                ObjReal(tanh(args.firstAndOnly().toDouble()))
-            }
-            addFn("asinh") {
-                ObjReal(asinh(args.firstAndOnly().toDouble()))
-            }
-            addFn("acosh") {
-                ObjReal(acosh(args.firstAndOnly().toDouble()))
-            }
-            addFn("atanh") {
-                ObjReal(atanh(args.firstAndOnly().toDouble()))
-            }
-
-            addFn("exp") {
-                ObjReal(exp(args.firstAndOnly().toDouble()))
-            }
-            addFn("ln") {
-                ObjReal(ln(args.firstAndOnly().toDouble()))
-            }
-
-            addFn("log10") {
-                ObjReal(log10(args.firstAndOnly().toDouble()))
-            }
-
-            addFn("log2") {
-                ObjReal(log2(args.firstAndOnly().toDouble()))
-            }
-
-            addFn("pow") {
-                requireExactCount(2)
-                ObjReal(
-                    (args[0].toDouble()).pow(args[1].toDouble())
-                )
-            }
-            addFn("sqrt") {
-                ObjReal(
-                    sqrt(args.firstAndOnly().toDouble())
-                )
-            }
-            addFn( "abs" ) {
-                val x = args.firstAndOnly()
-                if( x is ObjInt ) ObjInt( x.value.absoluteValue ) else ObjReal( x.toDouble().absoluteValue )
-            }
-
-            addVoidFn("assert") {
-                val cond = requiredArg<ObjBool>(0)
-                if( !cond.value == true )
-                    raiseError(ObjAssertionError(this,"Assertion failed"))
-            }
-
-            addVoidFn("assertEquals") {
-                val a = requiredArg<Obj>(0)
-                val b = requiredArg<Obj>(1)
-                if( a.compareTo(this, b) != 0 )
-                    raiseError(ObjAssertionError(this,"Assertion failed: ${a.inspect()} == ${b.inspect()}"))
-            }
-            addFn("assertThrows") {
-                val code = requireOnlyArg<Statement>()
-                val result =try {
-                    code.execute(this)
-                    null
-                }
-                catch( e: ExecutionError ) {
-                    e.errorObject
-                }
-                catch (e: ScriptError) {
-                    ObjNull
-                }
-                result ?: raiseError(ObjAssertionError(this,"Expected exception but nothing was thrown"))
-            }
-
-            addVoidFn("delay") {
-                delay((this.args.firstAndOnly().toDouble()/1000.0).roundToLong())
-            }
-
-            addConst("Real", ObjReal.type)
-            addConst("String", ObjString.type)
-            addConst("Int", ObjInt.type)
-            addConst("Bool", ObjBool.type)
-            addConst("Char", ObjChar.type)
-            addConst("List", ObjList.type)
-            addConst("Range", ObjRange.type)
-            @Suppress("RemoveRedundantQualifierName")
-            addConst("Callable", Statement.type)
-            // interfaces
-            addConst("Iterable", ObjIterable)
-            addConst("Array", ObjArray)
-            addConst("Class", ObjClassType)
-            addConst("Object", Obj().objClass)
-
-            val pi = ObjReal(PI)
-            addConst("π", pi)
-            getOrCreateNamespace("Math").apply {
-                addConst("PI", pi)
-            }
-        }
-    }
-}

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

@@ -1,15 +0,0 @@
-@file:Suppress("CanBeParameter")
-
-package net.sergeych.lyng
-
-open class ScriptError(val pos: Pos, val errorMessage: String,cause: Throwable?=null) : Exception(
-    """
-        $pos: Error: $errorMessage
-        
-        ${pos.currentLine}
-        ${"-".repeat(pos.column)}^
-    """.trimIndent(),
-    cause
-)
-
-class ExecutionError(val errorObject: ObjError) : ScriptError(errorObject.context.pos, errorObject.message)

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

@@ -1,15 +0,0 @@
-package net.sergeych.lyng
-
-class Source(val fileName: String, text: String) {
-
-    val lines = text.lines().map { it.trimEnd() }
-
-    companion object {
-        val builtIn: Source by lazy { Source("built-in", "") }
-        val UNKNOWN: Source by lazy { Source("UNKNOWN", "") }
-    }
-
-    val startPos: Pos = Pos(this, 0, 0)
-
-    fun posAt(line: Int, column: Int): Pos = Pos(this, line, column)
-}

library/src/commonMain/kotlin/net/sergeych/lyng/SymbolSpace.kt

@@ -1,13 +0,0 @@
-package net.sergeych.lyng
-
-
-
-class Symbols(
-    unitType: UnitType,
-    val name: String,
-    val x: TypeDecl
-) {
-    enum class UnitType {
-        Module, Function, Lambda
-    }
-}

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

@@ -1,30 +0,0 @@
-package net.sergeych.lyng
-
-data class Token(val value: String, val pos: Pos, val type: Type) {
-    val isComment: Boolean by lazy { type == Type.SINLGE_LINE_COMMENT || type == Type.MULTILINE_COMMENT }
-
-    @Suppress("unused")
-    enum class Type {
-        ID, INT, REAL, HEX, STRING, 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,
-        SHUTTLE,
-        AND, BITAND, OR, BITOR, NOT, BITNOT, DOT, ARROW, QUESTION, COLONCOLON,
-        SINLGE_LINE_COMMENT, MULTILINE_COMMENT,
-        LABEL, ATLABEL, // label@ at@label
-        PRIVATE, PROTECTED,
-        //PUBLIC, PROTECTED, INTERNAL, EXPORT, OPEN, INLINE, OVERRIDE, ABSTRACT, SEALED, EXTERNAL, VAL, VAR, CONST, TYPE, FUN, CLASS, INTERFACE, ENUM, OBJECT, TRAIT, THIS,
-        ELLIPSIS, DOTDOT, DOTDOTLT,
-        NEWLINE,
-        EOF,
-    }
-
-    companion object {
-//        fun eof(parser: Parser) = Token("", parser.currentPos, Type.EOF)
-    }
-}

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

@@ -1,21 +0,0 @@
-package net.sergeych.lyng
-
-sealed class TypeDecl {
-    // ??
-    data class Fn(val argTypes: List<ArgsDeclaration.Item>, val retType: TypeDecl) : TypeDecl()
-    object Obj : TypeDecl()
-}
-
-/*
-To use in the compiler, we need symbol information when:
-
-- declaring a class: the only way to export its public/protected symbols is to know it in compiler time
-- importing a module: actually,  we cam try to do it in a more efficient way.
-
-Importing module:
-
-The moudule is efficiently a statement, that initializes it with all its symbols modifying some context.
-
-The thing is, we need only
-
- */

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

@@ -1,8 +0,0 @@
-package net.sergeych.lyng
-
-enum class Visibility {
-    Public, Private, Protected;//, Internal
-    val isPublic by lazy { this == Public }
-    @Suppress("unused")
-    val isProtected by lazy { this == Protected }
-}

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

@@ -1,4 +0,0 @@
-package net.sergeych.lyng
-
-
-val LyngVersion = BuildKonfig.version

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

@@ -1,60 +0,0 @@
-package net.sergeych.lyng
-
-fun String.toSource(name: String = "eval"): Source = Source(name, this)
-
-sealed class ObjType {
-    object Any : ObjType()
-    object Int : ObjType()
-}
-
-
-@Suppress("unused")
-abstract class Statement(
-    val isStaticConst: Boolean = false,
-    val isConst: Boolean = false,
-    val returnType: ObjType = ObjType.Any
-) : Obj() {
-
-    override val objClass: ObjClass = type
-
-    abstract val pos: Pos
-    abstract suspend fun execute(context: Context): Obj
-
-    override suspend fun compareTo(context: Context,other: Obj): Int {
-        throw UnsupportedOperationException("not comparable")
-    }
-
-    override suspend fun callOn(context: Context): Obj {
-        return execute(context)
-    }
-
-    override fun toString(): String = "Callable@${this.hashCode()}"
-
-    companion object {
-        val type = ObjClass("Callable")
-    }
-
-}
-
-fun Statement.raise(text: String): Nothing {
-    throw ScriptError(pos, text)
-}
-
-@Suppress("unused")
-fun Statement.require(cond: Boolean, message: () -> String) {
-    if (!cond) raise(message())
-}
-
-fun statement(pos: Pos, isStaticConst: Boolean = false, isConst: Boolean = false, f: suspend (Context) -> Obj): Statement =
-    object : Statement(isStaticConst, isConst) {
-        override val pos: Pos = pos
-        override suspend fun execute(context: Context): Obj = f(context)
-    }
-
-fun statement(isStaticConst: Boolean = false, isConst: Boolean = false, f: suspend Context.() -> Obj): Statement =
-    object : Statement(isStaticConst, isConst) {
-        override val pos: Pos = Pos.builtIn
-        override suspend fun execute(context: Context): Obj = f(context)
-    }
-
-

lyng/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 {
     kotlin("multiplatform") version "2.1.21"
 }
@@ -29,11 +46,11 @@ kotlin {
     sourceSets {
         val commonMain by getting {
             dependencies {
-                implementation(project(":library"))
+                implementation(kotlin("stdlib-common"))
+                implementation(project(":lynglib"))
                 implementation(libs.okio)
-
                 implementation(libs.clikt)
-
+                implementation(kotlin("stdlib-common"))
                 // optional support for rendering markdown in help messages
 //                implementation(libs.clikt.markdown)
             }
@@ -42,9 +59,15 @@ kotlin {
             dependencies {
                 implementation(kotlin("test-common"))
                 implementation(kotlin("test-annotations-common"))
+                implementation(libs.kotlinx.coroutines.core)
                 implementation(libs.okio.fakefilesystem)
             }
         }
+//        val nativeMain by getting {
+//            dependencies {
+//                implementation(kotlin("stdlib-common"))
+//            }
+//        }
         val linuxX64Main by getting {
 
         }

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
@@ -17,14 +42,46 @@ import okio.use
 
 expect fun exit(code: Int)
 
-val baseContext = Context().apply {
-    addFn("exit") {
-        exit(requireOnlyArg<ObjInt>().toInt())
-        ObjVoid
+expect class ShellCommandExecutor {
+    fun executeCommand(command: String): CommandResult
+
+    companion object {
+        fun create(): ShellCommandExecutor
     }
 }
 
-class Lyng(val launcher: (suspend () -> Unit) -> Unit) : CliktCommand() {
+data class CommandResult(
+    val exitCode: Int,
+    val output: String,
+    val error: String
+)
+
+val baseScopeDefer = globalDefer {
+    Script.newScope().apply {
+        addFn("exit") {
+            exit(requireOnlyArg<ObjInt>().toInt())
+            ObjVoid
+        }
+    }
+}
+
+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
 
@@ -38,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.
             
@@ -48,55 +105,70 @@ 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) {
-    val text = FileSystem.SYSTEM.source(fileName.toPath()).use { fileSource ->
+    var text = FileSystem.SYSTEM.source(fileName.toPath()).use { fileSource ->
         fileSource.buffer().use { bs ->
             bs.readUtf8()
         }
     }
+    if( text.startsWith("#!") ) {
+        // skip shebang
+        val pos = text.indexOf('\n')
+        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

@@ -0,0 +1,40 @@
+/*
+ * 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
+
+// Alternative implementation for native targets
+actual class ShellCommandExecutor() {
+    actual fun executeCommand(command: String): CommandResult {
+        val process = ProcessBuilder("/bin/sh", "-c", command).start()
+        val exitCode = process.waitFor()
+        val output = process.inputStream.bufferedReader().readText()
+        val error = process.errorStream.bufferedReader().readText()
+
+        return CommandResult(
+            exitCode = exitCode,
+            output = output.trim(),
+            error = error.trim()
+        )
+    }
+
+    actual companion object {
+        actual fun create(): ShellCommandExecutor = ShellCommandExecutor()
+    }
+}

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,7 +1,67 @@
+/*
+ * 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
 
+import kotlinx.cinterop.*
+import platform.posix.fgets
+import platform.posix.pclose
+import platform.posix.popen
 import kotlin.system.exitProcess
 
+actual class ShellCommandExecutor() {
+    actual fun executeCommand(command: String): CommandResult {
+        val outputBuilder = StringBuilder()
+        val errorBuilder = StringBuilder()
+
+        val fp = popen(command, "r") ?: return CommandResult(
+            exitCode = -1,
+            output = "",
+            error = "Failed to execute command"
+        )
+
+        val buffer = ByteArray(4096)
+        while (true) {
+            val bytesRead = buffer.usePinned { pinned ->
+                fgets(pinned.addressOf(0), buffer.size.convert(), fp)
+            }
+            if (bytesRead == null) break
+            outputBuilder.append(bytesRead.toKString())
+        }
+
+        val status = pclose(fp)
+        val exitCode = if (status == 0) 0 else 1
+
+        return CommandResult(
+            exitCode = exitCode,
+            output = outputBuilder.toString().trim(),
+            error = errorBuilder.toString().trim()
+        )
+    }
+
+    actual companion object {
+        actual fun create(): ShellCommandExecutor = ShellCommandExecutor()
+    }
+}
+
 actual fun exit(code: Int) {
     exitProcess(code)
 }

lynglib/build.gradle.kts

@@ -1,11 +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 com.vanniktech.maven.publish.SonatypeHost
 import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
 import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
 import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
 group = "net.sergeych"
-version = "0.4.0-SNAPSHOT"
+version = "0.9.0-SNAPSHOT"
 
 buildscript {
     repositories {
@@ -20,9 +36,10 @@ buildscript {
 plugins {
     alias(libs.plugins.kotlinMultiplatform)
     alias(libs.plugins.androidLibrary)
-    alias(libs.plugins.vanniktech.mavenPublish)
-    kotlin("plugin.serialization") version "2.1.20"
+//    alias(libs.plugins.vanniktech.mavenPublish)
+    kotlin("plugin.serialization") version "2.2.0"
     id("com.codingfeline.buildkonfig") version "0.17.1"
+    `maven-publish`
 }
 
 buildkonfig {
@@ -62,8 +79,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("kotlinx.coroutines.flow.DelicateCoroutinesApi")
         }
 
         val commonMain by getting {
@@ -98,75 +117,58 @@ android {
 }
 dependencies {
     implementation(libs.firebase.crashlytics.buildtools)
+    implementation(libs.compiler)
 }
 
-mavenPublishing {
-    publishToMavenCentral(SonatypeHost.CENTRAL_PORTAL)
-
-    signAllPublications()
-
-    coordinates(group.toString(), "library", version.toString())
-
-    pom {
-        name = "Lyng language"
-        description = "Kotlin-bound scripting loanguage"
-        inceptionYear = "2025"
-//        url = "https://sergeych.net"
-        licenses {
-            license {
-                name = "XXX"
-                url = "YYY"
-                distribution = "ZZZ"
+publishing {
+    val mavenToken by lazy {
+        File("${System.getProperty("user.home")}/.gitea_token").readText()
+    }
+    repositories {
+        maven {
+            credentials(HttpHeaderCredentials::class) {
+                name = "Authorization"
+                value = mavenToken
             }
-        }
-        developers {
-            developer {
-                id = "XXX"
-                name = "YYY"
-                url = "ZZZ"
+            url = uri("https://gitea.sergeych.net/api/packages/SergeychWorks/maven")
+            authentication {
+                create("Authorization", HttpHeaderAuthentication::class)
             }
         }
-        scm {
-            url = "XXX"
-            connection = "YYY"
-            developerConnection = "ZZZ"
-        }
     }
 }
+
+
+//mavenPublishing {
+//    publishToMavenCentral(SonatypeHost.CENTRAL_PORTAL)
 //
-//val projectVersion  by project.extra(provider {
-//    // Compute value lazily
-//    (version as String)
-//})
+//    signAllPublications()
 //
-//val generateBuildConfig by tasks.registering {
-//    // Declare outputs safely
-//    val outputDir = layout.buildDirectory.dir("generated/buildConfig/commonMain/kotlin")
-//    outputs.dir(outputDir)
+//    coordinates(group.toString(), "library", version.toString())
 //
-//    val version = projectVersion.get()
-//
-//    // Inputs: Version is tracked as an input
-//    inputs.property("version", version)
-//
-//    doLast {
-//        val packageName = "net.sergeych.lyng.buildconfig"
-//        val packagePath = packageName.replace('.', '/')
-//        val buildConfigFile = outputDir.get().file("$packagePath/BuildConfig.kt").asFile
-//
-//        buildConfigFile.parentFile?.mkdirs()
-//        buildConfigFile.writeText(
-//            """
-//            |package $packageName
-//            |
-//            |object BuildConfig {
-//            |    const val VERSION = "$version"
-//            |}
-//            """.trimMargin()
-//        )
+//    pom {
+//        name = "Lyng language"
+//        description = "Kotlin-bound scripting loanguage"
+//        inceptionYear = "2025"
+////        url = "https://sergeych.net"
+//        licenses {
+//            license {
+//                name = "XXX"
+//                url = "YYY"
+//                distribution = "ZZZ"
+//            }
+//        }
+//        developers {
+//            developer {
+//                id = "XXX"
+//                name = "YYY"
+//                url = "ZZZ"
+//            }
+//        }
+//        scm {
+//            url = "XXX"
+//            connection = "YYY"
+//            developerConnection = "ZZZ"
+//        }
 //    }
 //}
-//
-//tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile>().configureEach {
-//    dependsOn(generateBuildConfig)
-//}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/AccessType.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
+
+enum class AccessType(val isMutable: Boolean) {
+    Val(false), Var(true),
+
+    @Suppress("unused")
+    Initialization(false)
+}

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.raiseArgumentError("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.raiseArgumentError("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.raiseArgumentError("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

@@ -0,0 +1,73 @@
+/*
+ * 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(scope: Scope, tailBlockMode: Boolean): Arguments {
+    val list = mutableListOf<Obj>()
+
+    for (x in this) {
+        val value = x.value.execute(scope)
+        if (x.isSplat) {
+            when {
+                value is ObjList -> {
+                    for (subitem in value.list) list.add(subitem)
+                }
+
+                value.isInstanceOf(ObjIterable) -> {
+                    val i = (value.invokeInstanceMethod(scope, "toList") as ObjList).list
+                    i.forEach { list.add(it) }
+                }
+
+                else -> scope.raiseClassCastError("expected list of objects for splat argument")
+            }
+        } else
+            list.add(value)
+    }
+    return Arguments(list,tailBlockMode)
+}
+
+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().byValueCopy()
+    }
+
+    /**
+     * Convert to list of kotlin objects, see [Obj.toKotlin].
+     */
+    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

@@ -0,0 +1,36 @@
+/*
+ * 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(
+//    integerPart: Long,
+//    decimalPart: Long,
+//    exponent: Int
+//): Double {
+//    // Handle zero decimal case efficiently
+//    val numDecimalDigits = if (decimalPart == 0L) 0 else decimalPart.toString().length
+//
+//    // Calculate decimal multiplier (10^-digits)
+//    val decimalMultiplier = 10.0.pow(-numDecimalDigits)
+//
+//    // Combine integer and decimal parts
+//    val baseValue = integerPart.toDouble() + decimalPart.toDouble() * decimalMultiplier
+//
+//    // Apply exponent
+//    return baseValue * 10.0.pow(exponent)
+//}

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

@@ -0,0 +1,237 @@
+/*
+ * 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
+
+class CompilerContext(val tokens: List<Token>) {
+    val labels = mutableSetOf<String>()
+
+    var breakFound = false
+
+    var loopLevel = 0
+
+    inline fun <T> parseLoop(f: () -> T): Pair<Boolean, T> {
+        if (++loopLevel == 0) breakFound = false
+        val result = f()
+        return Pair(breakFound, result).also {
+            --loopLevel
+        }
+    }
+
+    var currentIndex = 0
+
+    fun hasNext() = currentIndex < tokens.size
+    fun hasPrevious() = currentIndex > 0
+    fun next() =
+        if (currentIndex < tokens.size) tokens[currentIndex++]
+        else Token("", tokens.last().pos, Token.Type.EOF)
+
+    fun previous() = if (!hasPrevious()) throw IllegalStateException("No previous token") else tokens[--currentIndex]
+
+    fun savePos() = currentIndex
+    fun restorePos(pos: Int) {
+        currentIndex = pos
+    }
+
+    fun ensureLabelIsValid(pos: Pos, label: String) {
+        if (label !in labels)
+            throw ScriptError(pos, "Undefined label '$label'")
+    }
+
+    @Suppress("unused")
+    fun requireId() = requireToken(Token.Type.ID, "identifier is required")
+
+    fun requireToken(type: Token.Type, message: String = "required ${type.name}"): Token =
+        next().also {
+            if (type != it.type) throw ScriptError(it.pos, message)
+        }
+
+    @Suppress("unused")
+    fun syntaxError(at: Pos, message: String = "Syntax error"): Nothing {
+        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`
+     * @param isOptional if `true` and token is not of `tokenType`, just return `false` and does not skip it
+     * @return `true` if the token was skipped
+     * @throws ScriptError if [isOptional] is `false` and next token is not of [tokenType]
+     */
+    fun skipTokenOfType(
+        tokenType: Token.Type,
+        errorMessage: String = "expected ${tokenType.name}",
+        isOptional: Boolean = false
+    ): Boolean {
+        val t = next()
+        return if (t.type != tokenType) {
+            if (!isOptional) {
+                println("unexpected: $t (needed $tokenType)")
+                throw ScriptError(t.pos, errorMessage)
+            } else {
+                previous()
+                false
+            }
+        } 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) { /**/
+        }
+        previous()
+    }
+
+    fun nextNonWhitespace(): Token {
+        while (true) {
+            val t = next()
+            if (t.type !in wstokens) return t
+        }
+    }
+
+    /**
+     * 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)
+            true
+        } else {
+            previous()
+            false
+        }
+    }
+
+    inline fun addBreak() {
+        breakFound = true
+    }
+
+    /**
+     * Return value of the next token if it is an identifier, null otherwise.
+     * Does not change position.
+     */
+    @Suppress("unused")
+    fun nextIdValue(): String? {
+        return if (hasNext()) {
+            val nt = tokens[currentIndex]
+            if (nt.type == Token.Type.ID)
+                nt.value
+            else null
+        } else null
+    }
+
+    @Suppress("unused")
+    fun current(): Token = tokens[currentIndex]
+
+    /**
+     * If the token at current position plus offset (could be negative) exists, returns it, otherwise returns null.
+     */
+    @Suppress("unused")
+    fun atOffset(offset: Int): Token? =
+        if (currentIndex + offset in tokens.indices) tokens[currentIndex + offset] else null
+
+    fun matchQualifiers(keyword: String, vararg qualifiers: String): Boolean {
+        val pos = savePos()
+        var count = 0
+        while (count < qualifiers.size) {
+            val t = next()
+            when (t.type) {
+                Token.Type.ID -> {
+                    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
+                }
+            }
+        }
+        val t = next()
+        if (t.type == Token.Type.ID && t.value == keyword) {
+            return true
+        } else {
+            restorePos(pos)
+            return false
+        }
+    }
+
+    /**
+     * Skip newlines and comments. Returns (and reads) first non-whitespace token.
+     * Note that [Token.Type.EOF] is not considered a whitespace token.
+     */
+    fun skipWsTokens(): Token {
+        while (current().type in wstokens) {
+            next()
+        }
+        return current()
+    }
+
+    companion object {
+        val wstokens = setOf(Token.Type.NEWLINE, Token.Type.MULTILINE_COMMENT, Token.Type.SINLGE_LINE_COMMENT)
+    }
+}

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

@@ -0,0 +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.Accessor
+
+sealed class ListEntry {
+    data class Element(val accessor: Accessor) : ListEntry()
+
+    data class Spread(val accessor: Accessor) : ListEntry()
+}

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

@@ -0,0 +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.
+ *
+ */
+
+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,
+    val label: String? = null
+) : RuntimeException()

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/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)
@@ -45,11 +62,20 @@ private class Parser(fromPos: Pos) {
             '=' -> {
                 if (pos.currentChar == '=') {
                     pos.advance()
-                    if (currentChar == '=') {
-                        pos.advance()
-                        Token("===", from, Token.Type.REF_EQ)
-                    } else
-                        Token("==", from, Token.Type.EQ)
+                    when (currentChar) {
+                        '=' -> {
+                            pos.advance()
+                            Token("===", from, Token.Type.REF_EQ)
+                        }
+
+                        else -> Token("==", from, Token.Type.EQ)
+                    }
+                } else if (currentChar == '>') {
+                    pos.advance()
+                    Token("=>", from, Token.Type.EQARROW)
+                } else if (currentChar == '~') {
+                    pos.advance()
+                    Token("=~", from, Token.Type.MATCH)
                 } else
                     Token("=", from, Token.Type.ASSIGN)
             }
@@ -103,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)
                 }
 
                 '*' -> {
@@ -137,14 +163,20 @@ private class Parser(fromPos: Pos) {
                 if (currentChar == '.') {
                     pos.advance()
                     // .. already parsed:
-                    if (currentChar == '.') {
-                        pos.advance()
-                        Token("...", from, Token.Type.ELLIPSIS)
-                    } else if (currentChar == '<') {
-                        pos.advance()
-                        Token("..<", from, Token.Type.DOTDOTLT)
-                    } else {
-                        Token("..", from, Token.Type.DOTDOT)
+                    when (currentChar) {
+                        '.' -> {
+                            pos.advance()
+                            Token("...", from, Token.Type.ELLIPSIS)
+                        }
+
+                        '<' -> {
+                            pos.advance()
+                            Token("..<", from, Token.Type.DOTDOTLT)
+                        }
+
+                        else -> {
+                            Token("..", from, Token.Type.DOTDOT)
+                        }
                     }
                 } else
                     Token(".", from, Token.Type.DOT)
@@ -153,11 +185,10 @@ private class Parser(fromPos: Pos) {
             '<' -> {
                 if (currentChar == '=') {
                     pos.advance()
-                    if( currentChar == '>' ) {
+                    if (currentChar == '>') {
                         pos.advance()
                         Token("<=>", from, Token.Type.SHUTTLE)
-                    }
-                    else {
+                    } else {
                         Token("<=", from, Token.Type.LTE)
                     }
                 } else
@@ -199,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)
             }
@@ -236,9 +270,10 @@ private class Parser(fromPos: Pos) {
             }
 
             '"' -> loadStringToken()
+
             in digitsSet -> {
                 pos.back()
-                decodeNumber(loadChars(digits), from)
+                decodeNumber(loadChars { it in digitsSet || it == '_' }, from)
             }
 
             '\'' -> {
@@ -261,12 +296,27 @@ private class Parser(fromPos: Pos) {
                 Token(value.toString(), start, Token.Type.CHAR)
             }
 
+            '?' -> {
+                when (currentChar.also { pos.advance() }) {
+                    ':' -> Token("??", from, Token.Type.ELVIS)
+                    '?' -> Token("??", from, Token.Type.ELVIS)
+                    '.' -> Token("?.", from, Token.Type.NULL_COALESCE)
+                    '[' -> Token("?(", from, Token.Type.NULL_COALESCE_INDEX)
+                    '(' -> Token("?(", from, Token.Type.NULL_COALESCE_INVOKE)
+                    '{' -> Token("?{", from, Token.Type.NULL_COALESCE_BLOCKINVOKE)
+                    else -> {
+                        pos.back()
+                        Token("?", from, Token.Type.QUESTION)
+                    }
+                }
+            }
+
             else -> {
                 // text infix operators:
                 // 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()
@@ -280,8 +330,6 @@ private class Parser(fromPos: Pos) {
                         when (text) {
                             "in" -> Token("in", from, Token.Type.IN)
                             "is" -> Token("is", from, Token.Type.IS)
-                            "protected" -> Token("protected", from, Token.Type.PROTECTED)
-                            "private" -> Token("private", from, Token.Type.PRIVATE)
                             else -> Token(text, from, Token.Type.ID)
                         }
                 } else
@@ -293,7 +341,7 @@ private class Parser(fromPos: Pos) {
     private fun decodeNumber(p1: String, start: Pos): Token =
         if (pos.end)
             Token(p1, start, Token.Type.INT)
-        else if( currentChar == 'e' || currentChar == 'E' ) {
+        else if (currentChar == 'e' || currentChar == 'E') {
             pos.advance()
             var negative = false
             if (currentChar == '+')
@@ -338,7 +386,7 @@ private class Parser(fromPos: Pos) {
             // could be integer, also hex:
             if (currentChar == 'x' && p1 == "0") {
                 pos.advance()
-                Token(loadChars({ it in hexDigits }), start, Token.Type.HEX).also {
+                Token(loadChars { it in hexDigits }, start, Token.Type.HEX).also {
                     if (currentChar.isLetter())
                         raise("invalid hex literal")
                 }
@@ -350,27 +398,79 @@ private class Parser(fromPos: Pos) {
 
     private val currentChar: Char get() = pos.currentChar
 
-    private fun loadStringToken(): Token {
-        var start = currentPos
+    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()
 
-        if (currentChar == '"') pos.advance()
-        else start = start.back()
+        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
+
+//        if (currentChar == '"') pos.advance()
+//        else start = start.back()
+//        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()
@@ -378,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)
     }
 
     /**
@@ -419,7 +522,7 @@ private class Parser(fromPos: Pos) {
         }
     }
 
-    private fun loadToEnd(): String {
+    private fun loadToEndOfLine(): String {
         val result = StringBuilder()
         val l = pos.line
         do {
@@ -453,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) {
@@ -5,6 +22,7 @@ data class Pos(val source: Source, val line: Int, val column: Int) {
         return "${source.fileName}:${line+1}:${column}"
     }
 
+    @Suppress("unused")
     fun back(): Pos =
         if( column > 0) Pos(source, line, column-1)
         else if( line > 0) Pos(source, line-1, source.lines[line-1].length - 1)

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

@@ -0,0 +1,254 @@
+/*
+ * 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)
+                    )
+        }
+
+    fun copy(pos: Pos, args: Arguments = Arguments.EMPTY, newThisObj: Obj? = null): Scope =
+        Scope(this, args, pos, newThisObj ?: thisObj)
+
+    fun copy(args: Arguments = Arguments.EMPTY, newThisObj: Obj? = null): Scope =
+        Scope(this, args, pos, newThisObj ?: thisObj)
+
+    fun copy() = 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("--------------------")
+        ObjVoid
+
+    }
+
+    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

@@ -0,0 +1,302 @@
+/*
+ * 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.*
+
+class Script(
+    override val pos: Pos,
+    private val statements: List<Statement> = emptyList(),
+//    private val catchReturn: Boolean = false,
+) : Statement() {
+
+    override suspend fun execute(scope: Scope): Obj {
+        var lastResult: Obj = ObjVoid
+        for (s in statements) {
+            lastResult = s.execute(scope)
+        }
+        return lastResult
+    }
+
+    suspend fun execute() = execute(
+        defaultImportManager.newStdScope()
+    )
+
+    companion object {
+
+        /**
+         * 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.toString(this).value)
+                    else print(a.toString(this).value)
+                }
+                println()
+                ObjVoid
+            }
+            addFn("floor") {
+                val x = args.firstAndOnly()
+                (if (x is ObjInt) x
+                else ObjReal(floor(x.toDouble())))
+            }
+            addFn("ceil") {
+                val x = args.firstAndOnly()
+                (if (x is ObjInt) x
+                else ObjReal(ceil(x.toDouble())))
+            }
+            addFn("round") {
+                val x = args.firstAndOnly()
+                (if (x is ObjInt) x
+                else ObjReal(round(x.toDouble())))
+            }
+
+            addFn("sin") {
+                ObjReal(sin(args.firstAndOnly().toDouble()))
+            }
+            addFn("cos") {
+                ObjReal(cos(args.firstAndOnly().toDouble()))
+            }
+            addFn("tan") {
+                ObjReal(tan(args.firstAndOnly().toDouble()))
+            }
+            addFn("asin") {
+                ObjReal(asin(args.firstAndOnly().toDouble()))
+            }
+            addFn("acos") {
+                ObjReal(acos(args.firstAndOnly().toDouble()))
+            }
+            addFn("atan") {
+                ObjReal(atan(args.firstAndOnly().toDouble()))
+            }
+
+            addFn("sinh") {
+                ObjReal(sinh(args.firstAndOnly().toDouble()))
+            }
+            addFn("cosh") {
+                ObjReal(cosh(args.firstAndOnly().toDouble()))
+            }
+            addFn("tanh") {
+                ObjReal(tanh(args.firstAndOnly().toDouble()))
+            }
+            addFn("asinh") {
+                ObjReal(asinh(args.firstAndOnly().toDouble()))
+            }
+            addFn("acosh") {
+                ObjReal(acosh(args.firstAndOnly().toDouble()))
+            }
+            addFn("atanh") {
+                ObjReal(atanh(args.firstAndOnly().toDouble()))
+            }
+
+            addFn("exp") {
+                ObjReal(exp(args.firstAndOnly().toDouble()))
+            }
+            addFn("ln") {
+                ObjReal(ln(args.firstAndOnly().toDouble()))
+            }
+
+            addFn("log10") {
+                ObjReal(log10(args.firstAndOnly().toDouble()))
+            }
+
+            addFn("log2") {
+                ObjReal(log2(args.firstAndOnly().toDouble()))
+            }
+
+            addFn("pow") {
+                requireExactCount(2)
+                ObjReal(
+                    (args[0].toDouble()).pow(args[1].toDouble())
+                )
+            }
+            addFn("sqrt") {
+                ObjReal(
+                    sqrt(args.firstAndOnly().toDouble())
+                )
+            }
+            addFn( "abs" ) {
+                val x = args.firstAndOnly()
+                if( x is ObjInt) ObjInt( x.value.absoluteValue ) else ObjReal( x.toDouble().absoluteValue )
+            }
+
+            addVoidFn("assert") {
+                val cond = requiredArg<ObjBool>(0)
+                if( !cond.value == true )
+                    raiseError(ObjAssertionFailedException(this,"Assertion failed"))
+            }
+
+            addVoidFn("assertEquals") {
+                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)}"))
+            }
+            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>()
+                val result =try {
+                    code.execute(this)
+                    null
+                }
+                catch( e: ExecutionError ) {
+                    e.errorObject
+                }
+                catch (e: 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())
+            }
+
+            addConst("Object", rootObjectType)
+            addConst("Real", ObjReal.type)
+            addConst("String", ObjString.type)
+            addConst("Int", ObjInt.type)
+            addConst("Bool", ObjBool.type)
+            addConst("Char", ObjChar.type)
+            addConst("List", ObjList.type)
+            addConst("Set", ObjSet.type)
+            addConst("Range", ObjRange.type)
+            addConst("Map", ObjMap.type)
+            addConst("MapEntry", ObjMapEntry.type)
+            @Suppress("RemoveRedundantQualifierName")
+            addConst("Callable", Statement.type)
+            // interfaces
+            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

@@ -0,0 +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
+
+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)}^
+    """.trimIndent(),
+    cause
+)
+
+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

@@ -0,0 +1,47 @@
+/*
+ * 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", "") }
+    }
+
+    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

@@ -0,0 +1,59 @@
+/*
+ * 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,
+        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, MATCH, NOTMATCH,
+        SHUTTLE,
+        AND, BITAND, OR, BITOR, NOT, BITNOT, DOT, ARROW, EQARROW, QUESTION, COLONCOLON,
+        SINLGE_LINE_COMMENT, MULTILINE_COMMENT,
+        LABEL, ATLABEL, // label@ at@label
+        //PUBLIC, PROTECTED, INTERNAL, EXPORT, OPEN, INLINE, OVERRIDE, ABSTRACT, SEALED, EXTERNAL, VAL, VAR, CONST, TYPE, FUN, CLASS, INTERFACE, ENUM, OBJECT, TRAIT, THIS,
+        ELLIPSIS, DOTDOT, DOTDOTLT,
+        NEWLINE,
+        EOF,
+        NULL_COALESCE,
+        ELVIS,
+        NULL_COALESCE_INDEX,
+        NULL_COALESCE_INVOKE,
+        NULL_COALESCE_BLOCKINVOKE,
+    }
+
+    companion object {
+//        fun eof(parser: Parser) = Token("", parser.currentPos, Type.EOF)
+    }
+}

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

@@ -0,0 +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(val isNullable:Boolean = false) {
+    // ??
+//    data class Fn(val argTypes: List<ArgsDeclaration.Item>, val retType: TypeDecl) : 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

@@ -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
+
+enum class Visibility {
+    Public, Private, Protected;//, Internal
+    val isPublic by lazy { this == Public }
+    @Suppress("unused")
+    val isProtected by lazy { this == Protected }
+}

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

@@ -0,0 +1,21 @@
+/*
+ * 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 LyngVersion = BuildKonfig.version

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,519 @@
+/*
+ * 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.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import net.sergeych.lyng.*
+import net.sergeych.lynon.LynonDecoder
+import net.sergeych.lynon.LynonEncoder
+import net.sergeych.lynon.LynonType
+import net.sergeych.synctools.ProtectedOp
+
+open class Obj {
+
+    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.copy(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.copy(scope.pos, args = args, newThisObj = thisObj))
+
+    suspend fun invoke(scope: Scope, thisObj: Obj, vararg args: Obj): Obj =
+        callOn(
+            scope.copy(
+                scope.pos,
+                args = Arguments(args.toList()),
+                newThisObj = thisObj
+            )
+        )
+
+    suspend fun invoke(scope: Scope, thisObj: Obj): Obj =
+        callOn(
+            scope.copy(
+                scope.pos,
+                args = Arguments.EMPTY,
+                newThisObj = thisObj
+            )
+        )
+
+    suspend fun invoke(scope: Scope, atPos: Pos, thisObj: Obj, args: Arguments): Obj =
+        callOn(scope.copy(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.copy(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(copy(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(copy(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
+            }
+
+        }
+
+
+        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

@@ -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 ObjArrayIterator(val array: Obj) : Obj() {
+
+    override val objClass: ObjClass by lazy { type }
+
+    private var nextIndex = 0
+    private var lastIndex = 0
+
+    suspend fun init(scope: Scope) {
+        nextIndex = 0
+        lastIndex = array.invokeInstanceMethod(scope, "size").toInt()
+        ObjVoid
+    }
+
+    companion object {
+        val type by lazy {
+            ObjClass("ArrayIterator", ObjIterator).apply {
+                addFn("next") {
+                    val self = thisAs<ObjArrayIterator>()
+                    if (self.nextIndex < self.lastIndex) {
+                        self.array.invokeInstanceMethod(this, "getAt", (self.nextIndex++).toObj())
+                    } else raiseError(ObjIterationFinishedException(this))
+                }
+                addFn("hasNext") {
+                    val self = thisAs<ObjArrayIterator>()
+                    if (self.nextIndex < self.lastIndex) ObjTrue else ObjFalse
+                }
+            }
+        }
+    }
+}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/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)
+            }
+        }
+    }
+}