version bump

added clean import scope Scope.new()

.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,25 @@
+<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>

README.md

@@ -2,7 +2,7 @@
 
 A KMP library and a standalone interpreter
 
-- simple, compact, intuitive and elegant modern code style:
+- simple, compact, intuitive and elegant modern code:
 
 ```
 class Point(x,y) {
@@ -15,23 +15,31 @@ fun swapEnds(first, args..., last, f) {
 } 
 ```
 
-- extremely simple Kotlin integration on any platform
+- extremely simple Kotlin integration on any platform (JVM, JS, WasmJS, Lunux, MacOS, iOS, Windows)
 - 100% secure: no access to any API you didn't explicitly provide
-- 100% coroutines! Every function/script is a coroutine, it does not block the thread, no async/await/suspend keyword garbage:
+- 100% coroutines! Every function/script is a coroutine, it does not block the thread, no async/await/suspend keyword garbage, see [parallelism]
 
 ```
+  val deferred = launch {
     delay(1.5) // coroutine is delayed for 1.5s, thread is not blocked!
+    "done"
+  }
+  // ...
+  // suspend current coroutine, no thread is blocked again,
+  // and wait for deferred to return something:
+  assertEquals("donw", deferred.await())
 ```
 and it is multithreaded on platforms supporting it (automatically, no code changes required, just
-`launch` more coroutines and they will be executed concurrently if possible)/
+`launch` more coroutines and they will be executed concurrently if possible). See [parallelism]
 
 - functional style and OOP together, multiple inheritance, implementing interfaces for existing classes, writing extensions.
-- Any unicode letters can be used as identifiers: `assert( sin(π/2) == 1 )`.
+- Any Unicode letters can be used as identifiers: `assert( sin(π/2) == 1 )`.
 
  ## Resources: 
 
 - [introduction and tutorial](docs/tutorial.md) - start here please
 - [Samples directory](docs/samples)
+- [Books directory](docs)
 
 ## Integration in Kotlin multiplatform
 
@@ -84,8 +92,8 @@ import com.sun.source.tree.Scope
 import new.sergeych.lyng.*
 
 // simple function
-val scope = Scope().apply {
-    addFn("addArgs") {
+val scope = Script.newScope().apply {
+    addFn("sumOf") {
         var sum = 0.0
         for (a in args) sum += a.toDouble()
         ObjReal(sum)
@@ -96,12 +104,14 @@ val scope = Scope().apply {
     // 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:
-scope.eval("addArgs(1,2,3)") // <- 6
+scope.eval("sumOf(1,2,3)") // <- 6
 ```
 Note that the scope stores all changes in it so you can make calls on a single scope to preserve state between calls.
 
@@ -119,7 +129,7 @@ Designed to add scripting to kotlin multiplatform application in easy and effici
 
 - Javascript, WasmJS, native, JVM, android - batteries included.
 - dynamic types in most elegant and concise way
-- async, 100% coroutines, supports multiple cores where platofrm supports thread
+- async, 100% coroutines, supports multiple cores where platform supports thread
 - good for functional an object-oriented style
 
 # Language Roadmap
@@ -139,15 +149,19 @@ Ready features:
 - [x] exception handling: throw, try-catch-finally, exception classes.
 - [x] multiplatform maven publication
 - [x] documentation for the current state
+- [x] maps, sets and sequences (flows?)
+- [x] modules
+- [x] string formatting and tools
+- [x] launch, deferred, CompletableDeferred, Mutex, etc.
+- [x] multiline strings
+- [x] typesafe bit-effective serialization
+- [x] compression/decompression (integrated in serialization)
+- [x] dynamic fields
 
-Under way: 
+###  Under way: 
 
-- [ ] maps, sets and sequences (flows?)
 - [ ] regular exceptions
-- [ ] modules
-- [ ] string interpolation and more string tools
 - [ ] multiple inheritance for user classes
-- [ ] launch, deferred, coroutineScope, mutex, etc.
 - [ ] site with integrated interpreter to give a try
 - [ ] kotlin part public API good docs, integration focused
 - [ ] better stack reporting
@@ -158,10 +172,12 @@ Planned features.
 
 - [ ] type specifications
 - [ ] source docs and maybe lyng.md to a standard
-- [ ] moacro-style kotlin integration or something else to simplify it
+- [ ] metadata first class access from lyng
 
 Further
 
 - [ ] client with GUI support based on compose multiplatform somehow
-- [ ] notebook - style workbooks with graphs, formulaes, etc.
+- [ ] notebook - style workbooks with graphs, formulae, etc.
 - [ ] language server or compose-based lyng-aware editor
+
+[parallelism]: docs/parallelism.md

bin/local_jrelease

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+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

docs/Buffer.md

@@ -0,0 +1,121 @@
+# 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
+
+## Members
+
+| name          | meaning                            | type          |
+|---------------|------------------------------------|---------------|
+| `size`        | size                               | Int           |
+| `decodeUtf8`  | decodee to String using UTF8 rules | Any           |
+| `+`           | buffer concatenation               | Any           |
+| `toMutable()` | create a mutable copy              | MutableBuffer |
+
+(1)
+: optimized implementation that override `Iterable` one
+
+Also, it inherits methods from [Iterable] and [Array].
+
+
+[Range]: Range.md
+[Iterable]: Iterable.md

docs/Iterable.md

@@ -1,5 +1,11 @@
 # Iterable interface
 
+The interface for anything that can be iterated, e.g. finite or infinite ordered set of data that can be accessed sequentially. Almost any data container in `Lyng` implements it: `List`, `Set`, `Buffer`, `RingBuffer`, `BitBuffer`, `Range` and many others are `Iterable`, also `Collection` and `Array` interfaces inherit it.
+
+`Map` and `String` have `Iterable` members to access its contents too.
+
+## Definition:
+
 Iterable is a class that provides function that creates _the iterator_:
 
     class Iterable {
@@ -17,9 +23,16 @@ Iterator itself is a simple interface that should provide only to method:
 
 Just remember at this stage typed declarations are not yet supported.
 
-Having `Iterable` in base classes allows to use it in for loop. Also, each `Iterable` has some utility functions available:
+Having `Iterable` in base classes allows to use it in for loop. Also, each `Iterable` has some utility functions available, for example
 
-## Instance methods
+    val r = 1..10  // Range is Iterable!  
+    assertEquals( [9,10] r.takeLast(2) )
+    assertEquals( [1,2,3] r.take(3) )
+    assertEquals( [9,10] r.drop(8) )
+    assertEquals( [1,2] r.dropLast(8) )
+    >>> void
+
+## Instance methods:
 
 | fun/method      | description                                                                     |
 |-----------------|---------------------------------------------------------------------------------|
@@ -33,7 +46,15 @@ Having `Iterable` in base classes allows to use it in for loop. Also, each `Iter
 | 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                                   |
 
+(1)
+: throws `NoSuchElementException` if there is no such element 
 
     fun Iterable.toList(): List
     fun Iterable.toSet(): Set
@@ -45,7 +66,7 @@ Having `Iterable` in base classes allows to use it in for loop. Also, each `Iter
     fun Iterable.associateBy( keyMaker: (Any?)->Any): Map
     
 
-## Abstract methods
+## Abstract methods:
 
     fun iterator(): Iterator
 
@@ -57,7 +78,9 @@ Creates a list by iterating to the end. So, the Iterator should be finite to be
 
 ## Implemented in classes:
 
-- [List], [Range]
+- [List], [Range], [Buffer](Buffer.md), [BitBuffer], [Buffer], [Set], [RingBuffer]
 
 [List]: List.md
 [Range]: Range.md
+[Set]: Set.md
+[RingBuffer]: RingBuffer.md

docs/Map.md

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

docs/OOP.md

@@ -147,7 +147,7 @@ In many cases it is necessary to implement custom comparison and `toString`, sti
 each class is provided with default implementations:
 
 - default toString outputs class name and its _public_ fields.
-- default comparison compares compares all public fields in order of appearance.
+- default comparison compares all fields in order of appearance.
 
 For example, for our class Point:
 
@@ -160,6 +160,47 @@ 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
@@ -194,6 +235,63 @@ 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:
@@ -250,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/RingBuffer.md

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

docs/advanced_topics.md

@@ -1,5 +1,7 @@
 # Advanced topics
 
+__See also:__ [parallelism].
+
 ## Closures/scopes isolation
 
 Each block has own scope, in which it can safely use closures and override
@@ -111,3 +113,5 @@ arguments list in almost arbitrary ways. For example:
     >>> void
 
 ,
+
+[parallelism]: parallelism.md

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/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/time.md

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

docs/tutorial.md

@@ -14,8 +14,11 @@ __Other documents to read__ maybe after this one:
 - [Advanced topics](advanced_topics.md), [declaring arguments](declaring_arguments.md)
 - [OOP notes](OOP.md), [exception handling](exceptions_handling.md)
 - [math in Lyng](math.md)
-- Some class references: [List], [Set], [Map], [Real], [Range], [Iterable], [Iterator]
-- Some samples: [combinatorics](samples/combinatorics.lyng.md), national vars and loops: [сумма ряда](samples/сумма_ряда.lyng.md). More at [samples folder](samples)
+- [time](time.md) and [parallelism](parallelism.md)
+- [parallelism] - multithreaded code, coroutines, etc.
+- Some class references: [List], [Set], [Map], [Real], [Range], [Iterable], [Iterator], [time manipulation](time.md), [RingBuffer], [Buffer].
+- Some samples: [combinatorics](samples/combinatorics.lyng.md), national vars and
+  loops: [сумма ряда](samples/сумма_ряда.lyng.md). More at [samples folder](samples)
 
 # Expressions
 
@@ -170,7 +173,8 @@ 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
+`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
@@ -464,7 +468,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:
@@ -530,10 +533,12 @@ The simplest way to concatenate lists is using `+` and `+=`:
     list += [2, 1]      
     // or you can append a single element:
     list += "end"
-    assert( list == [1, 2, 2, 1, "end"])
+    assertEquals( list, [1, 2, 2, 1, "end"])
+    void
     >>> void
 
-***Important note***: the pitfall of using `+=` is that you can't append in [Iterable] instance as an object: it will always add all its contents. Use `list.add` to add a single iterable instance:
+***Important note***: the pitfall of using `+=` is that you can't append in [Iterable] instance as an object: it will
+always add all its contents. Use `list.add` to add a single iterable instance:
 
     var list = [1, 2]
     val other = [3, 4]
@@ -561,7 +566,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]
@@ -594,7 +598,6 @@ Using splat arguments can simplify inserting list in list:
     x
     >>> [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]
@@ -641,6 +644,11 @@ You can get ranges to extract a portion from a list:
     assertEquals( [2,3], list[1..<3])
     >>> void
 
+# Buffers
+
+[Buffer] is a special implementation of an [Array] of unsigned bytes, in the
+[separate file](Buffer.md).
+
 # Sets
 
 Set are unordered collection of unique elements, see [Set]. Sets are [Iterable] but have no indexing access.
@@ -662,7 +670,6 @@ are [Iterable]:
 
 Please see [Map] reference for detailed description on using Maps.
 
-
 # Flow control operators
 
 ## if-then-else
@@ -736,23 +743,26 @@ Also, you can check the type too:
 
 #### Contains:
 
-You can thest that _when expression_ is _contained_, or not contained, in some object using `in container` and `!in container`. The container is any object that provides `contains` method, otherwise the runtime exception will be thrown.
+You can thest that _when expression_ is _contained_, or not contained, in some object using `in container` and
+`!in container`. The container is any object that provides `contains` method, otherwise the runtime exception will be
+thrown.
 
 Typical builtin types that are containers (e.g. support `conain`):
 
-| class      | notes                                      |
-|------------|--------------------------------------------|
-| Collection | contains an element (1)                    |
-| Array      | faster maybe that Collection's             |
-| List       | faster than Array's                        |
-| String     | character in string or substring in string |
-| Range      | object is included in the range (2)        |
+| class      | notes                                          |
+|------------|------------------------------------------------|
+| Collection | contains an element (1)                        |
+| Array      | faster maybe that Collection's                 |
+| List       | faster than Array's                            |
+| String     | character in string or substring in string (3) |
+| Range      | object is included in the range (2)            |
 
 (1)
 : Iterable is not the container as it can be infinite
 
 (2)
-: Depending on the inclusivity and open/closed range parameters. BE careful here: String range is allowed, but it is usually not what you expect of it:
+: Depending on the inclusivity and open/closed range parameters. BE careful here: String range is allowed, but it is
+usually not what you expect of it:
 
     assert( "more" in "a".."z") // string range ok
     assert( 'x' !in "a".."z") // char in string range: probably error
@@ -760,6 +770,11 @@ Typical builtin types that are containers (e.g. support `conain`):
     assert( "x" !in 'a'..'z') // string in character range: could be error
     >>> void
 
+(3)
+: `String` also can provide array of characters directly with `str.characters()`, which is [Iterable] and [Array].
+String itself is not iterable as otherwise it will interfere when adding strigns to lists (it will add _characters_ it
+it would be iterable).
+
 So we recommend not to mix characters and string ranges; use `ch in str` that works
 as expected:
 
@@ -836,7 +851,8 @@ We can skip the rest of the loop and restart it, as usual, with `continue` opera
     "found even numbers: " + countEven
     >>> "found even numbers: 5"
 
-`continue` can't "return" anything: it just restarts the loop. It can use labeled loops to restart outer ones (we intentionally avoid using for loops here):
+`continue` can't "return" anything: it just restarts the loop. It can use labeled loops to restart outer ones (we
+intentionally avoid using for loops here):
 
     var count = 0
     var total = 0
@@ -882,21 +898,22 @@ test function (remember function return it's last expression result):
 ```mermaid
 flowchart TD
     S((start)) --> Cond{check}
-    Cond--false, no else--->V((void))
-    Cond--true-->E(["last = loop_body()" ])
-    E--break value---->BV((value))
-    E--> Check2{check}
-    E--break---->V
-    Check2 --false-->E
-    Check2 --true, no else--->L((last))
-    Check2 --true, else-->Else(["else_clause()"])
-    Cond--false, else--->Else
+    Cond -- false, no else ---> V((void))
+    Cond -- true --> E(["last = loop_body()"])
+    E -- break value ----> BV((value))
+    E --> Check2{check}
+    E -- break ----> V
+    Check2 -- false --> E
+    Check2 -- true, no else ---> L((last))
+    Check2 -- true, else --> Else(["else_clause()"])
+    Cond -- false, else ---> Else
     Else --> Ele4$nr((else))
 ```
 
 So the returned value, as seen from diagram could be one of:
 
-- `void`, if the loop was not executed, e.g. `condition` was initially false, and there was no `else` clause, or if the empty break was executed.
+- `void`, if the loop was not executed, e.g. `condition` was initially false, and there was no `else` clause, or if the
+  empty break was executed.
 - value returned from `break value' statement
 - value returned from the `else` clause, of the loop was not broken
 - value returned from the last execution of loop body, if there was no `break` and no `else` clause.
@@ -920,7 +937,8 @@ available in the condition:
     } while( continueLoop )
     >>> "OK"
 
-This is sometimes convenient when condition is complex and has to be calculated inside the loop body. Notice the value returning by the loop:
+This is sometimes convenient when condition is complex and has to be calculated inside the loop body. Notice the value
+returning by the loop:
 
     fun readLine() { "done: result" }
     val result = do {
@@ -931,7 +949,6 @@ This is sometimes convenient when condition is complex and has to be calculated
 
 Suppose readLine() here reads some stream of lines.
 
-
 ## For loops
 
 For loop are intended to traverse collections, and all other objects that supports
@@ -974,7 +991,8 @@ We can use labels too:
 
 # Exception handling
 
-Very much like in Kotlin. Try block returns its body block result, if no exception was cauht, or the result from the catch block that caught the exception:
+Very much like in Kotlin. Try block returns its body block result, if no exception was cauht, or the result from the
+catch block that caught the exception:
 
     var error = "not caught"
     var finallyCaught = false
@@ -1027,7 +1045,6 @@ many more.
 
 - see [exception handling](exceptions_handling.md) for detailed exceptions tutorial and reference.
 
-
 # Self-assignments in expression
 
 There are auto-increments and auto-decrements:
@@ -1092,6 +1109,17 @@ 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)
+
 # Comments
 
     // single line comment
@@ -1139,7 +1167,6 @@ Are the same as in string literals with little difference:
 | code   | Int  | Unicode code for the character |
 |        |      |                                |
 
-
 ## String details
 
 Strings are arrays of Unicode characters. It can be indexed, and indexing will
@@ -1167,7 +1194,10 @@ To format a string use sprintf-style modifiers like:
     assertEquals( "hello :11    ", "%-6s:%-6d"(a, b) )
     >>> void
 
-List of format specifiers closely resembles C sprintf() one. See [format specifiers](https://github.com/sergeych/mp_stools?tab=readme-ov-file#sprintf-syntax-summary), this is doe using [mp_stools kotlin multiplatform library](https://github.com/sergeych/mp_stools). Currently supported Lyng types are `String`, `Int`, `Real`, `Bool`, the rest are displayed using their `toString()` representation.
+List of format specifiers closely resembles C sprintf() one.
+See [format specifiers](https://github.com/sergeych/mp_stools?tab=readme-ov-file#sprintf-syntax-summary), this is doe
+using [mp_stools kotlin multiplatform library](https://github.com/sergeych/mp_stools). Currently supported Lyng types
+are `String`, `Int`, `Real`, `Bool`, the rest are displayed using their `toString()` representation.
 
 This list will be extended.
 
@@ -1216,12 +1246,11 @@ Typical set of String functions includes:
 | 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           |
 
+(1)
+: List is mutable therefore a new copy is created on each call.
 
 ### Literals
 
@@ -1230,16 +1259,36 @@ 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]                                         |
 
 # Built-in constants
 
@@ -1249,11 +1298,25 @@ 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

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

lyng/src/commonMain/kotlin/Common.kt

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

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

@@ -1,9 +1,7 @@
 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,5 @@
-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)
 }

lynglib/build.gradle.kts

@@ -4,7 +4,7 @@ import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
 import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
 group = "net.sergeych"
-version = "0.7.0-SNAPSHOT"
+version = "0.8.6-SNAPSHOT"
 
 buildscript {
     repositories {
@@ -20,7 +20,7 @@ plugins {
     alias(libs.plugins.kotlinMultiplatform)
     alias(libs.plugins.androidLibrary)
 //    alias(libs.plugins.vanniktech.mavenPublish)
-    kotlin("plugin.serialization") version "2.1.20"
+    kotlin("plugin.serialization") version "2.2.0"
     id("com.codingfeline.buildkonfig") version "0.17.1"
     `maven-publish`
 }
@@ -65,6 +65,7 @@ kotlin {
             languageSettings.optIn("kotlin.contracts.ExperimentalContracts")
             languageSettings.optIn("kotlin.ExperimentalUnsignedTypes")
             languageSettings.optIn("kotlin.coroutines.DelicateCoroutinesApi")
+            languageSettings.optIn("kotlinx.coroutines.flow.DelicateCoroutinesApi")
         }
 
         val commonMain by getting {
@@ -99,6 +100,7 @@ android {
 }
 dependencies {
     implementation(libs.firebase.crashlytics.buildtools)
+    implementation(libs.compiler)
 }
 
 publishing {

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

@@ -1,17 +0,0 @@
-package net.sergeych.lyng
-
-/**
- * Special version of the [Scope] used to `apply` new this object to
- * _parent context property.
- *
- * @param _parent context to apply to
- * @param args arguments for the new context
- * @param appliedScope the new context to apply, it will have lower priority except for `this` which
- *      will be reset by appliedContext's `this`.
- */
-class AppliedScope(_parent: Scope, args: Arguments, val appliedScope: Scope)
-    : Scope(_parent, args, appliedScope.pos, appliedScope.thisObj) {
-    override fun get(name: String): ObjRecord? =
-        if (name == "this") thisObj.asReadonly
-        else super.get(name) ?: appliedScope[name]
-}

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

@@ -1,5 +1,9 @@
 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 +23,21 @@ 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(
         scope: Scope,
         arguments: Arguments = scope.args,
         defaultAccessType: AccessType = AccessType.Var,
-        defaultVisibility: Visibility = Visibility.Public
+        defaultVisibility: Visibility = Visibility.Public,
+        defaultRecordType: ObjRecord.Type = ObjRecord.Type.ConstructorField
     ) {
         fun assign(a: Item, value: Obj) {
-            scope.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 = defaultRecordType)
         }
 
         // will be used with last lambda arg fix
@@ -54,8 +62,8 @@ data class ArgsDeclaration(val params: List<Item>, val endTokenType: Token.Type)
                     i < callArgs.size -> callArgs[i]
                     a.defaultValue != null -> a.defaultValue.execute(scope)
                     else -> {
-                        println("callArgs: ${callArgs.joinToString()}")
-                        println("tailBlockMode: ${arguments.tailBlockMode}")
+//                        println("callArgs: ${callArgs.joinToString()}")
+//                        println("tailBlockMode: ${arguments.tailBlockMode}")
                         scope.raiseIllegalArgument("too few arguments for the call")
                     }
                 }

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

@@ -1,5 +1,9 @@
 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 {
@@ -26,13 +30,13 @@ suspend fun Collection<ParsedArgument>.toArguments(scope: Scope, tailBlockMode:
     return Arguments(list,tailBlockMode)
 }
 
-data class Arguments(val list: List<Obj>,val tailBlockMode: Boolean = false) : List<Obj> by list {
+data class Arguments(val list: List<Obj>, val tailBlockMode: Boolean = false) : List<Obj> by list {
 
     constructor(vararg values: Obj) : this(values.toList())
 
     fun firstAndOnly(pos: Pos = Pos.UNKNOWN): Obj {
         if (list.size != 1) throw ScriptError(pos, "expected one argument, got ${list.size}")
-        return list.first()
+        return list.first().byValueCopy()
     }
 
     /**
@@ -42,6 +46,8 @@ data class Arguments(val list: List<Obj>,val tailBlockMode: Boolean = false) : L
         return list.map { it.toKotlin(scope) }
     }
 
+    fun inspect(): String = list.joinToString(", ") { it.inspect() }
+
     companion object {
         val EMPTY = Arguments(emptyList())
         fun from(values: Collection<Obj>) = Arguments(values.toList())

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

@@ -0,0 +1,16 @@
+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? {
+        // closure should be treated below callScope
+        return super.get(name) ?: closureScope.get(name)
+    }
+}

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

@@ -1,18 +1,32 @@
 package net.sergeych.lyng
 
+import net.sergeych.lyng.obj.*
+import net.sergeych.lyng.pacman.ImportProvider
+
 /**
  * The LYNG compiler.
  */
 class Compiler(
     val cc: CompilerContext,
-    val pacman: Pacman = Pacman.emptyAllowAll,
+    val importManager: ImportProvider,
     @Suppress("UNUSED_PARAMETER")
     settings: Settings = Settings()
 ) {
+
     var packageName: String? = null
 
     class Settings
 
+    private val initStack = mutableListOf<MutableList<Statement>>()
+
+    val currentInitScope: MutableList<Statement>
+        get() =
+            initStack.lastOrNull() ?: cc.syntaxError("no initialization scope exists here")
+
+    private fun pushInitScope(): MutableList<Statement> = mutableListOf<Statement>().also { initStack.add(it) }
+
+    private fun popInitScope(): MutableList<Statement> = initStack.removeLast()
+
     private suspend fun parseScript(): Script {
         val statements = mutableListOf<Statement>()
         val start = cc.currentPos()
@@ -20,6 +34,10 @@ class Compiler(
         // package level declarations
         do {
             val t = cc.current()
+            if (t.type == Token.Type.NEWLINE || t.type == Token.Type.SINLGE_LINE_COMMENT || t.type == Token.Type.MULTILINE_COMMENT) {
+                cc.next()
+                continue
+            }
             if (t.type == Token.Type.ID) {
                 when (t.value) {
                     "package" -> {
@@ -33,21 +51,31 @@ class Compiler(
                         packageName = name
                         continue
                     }
+
                     "import" -> {
                         cc.next()
                         val pos = cc.currentPos()
                         val name = loadQualifiedName()
-                        pacman.prepareImport(pos, name, null)
+                        val module = importManager.prepareImport(pos, name, null)
                         statements += statement {
-                            pacman.performImport(this,name,null)
+                            module.importInto(this, null)
                             ObjVoid
                         }
+                        continue
                     }
                 }
             }
-            parseStatement(braceMeansLambda = true)?.also {
+            val s = parseStatement(braceMeansLambda = true)?.also {
                 statements += it
-            } ?: break
+            }
+            if (s == null) {
+                when( t.type ) {
+                    Token.Type.RBRACE, Token.Type.EOF, Token.Type.SEMICOLON -> {}
+                    else ->
+                        throw ScriptError(t.pos, "unexpeced `${t.value}` here")
+                }
+                break
+            }
 
         } while (true)
         return Script(start, statements)//returnScope.needCatch)
@@ -64,6 +92,7 @@ class Compiler(
                 t = cc.next()
             }
         }
+        cc.previous()
         return result.toString()
     }
 
@@ -266,9 +295,7 @@ class Compiler(
                             if (x == ObjNull && isOptional) ObjNull.asReadonly
                             else x.getAt(cxt, i).asMutable
                         }) { cxt, newValue ->
-                            val i = (index.execute(cxt) as? ObjInt)?.value?.toInt()
-                                ?: cxt.raiseError("index must be integer")
-                            left.getter(cxt).value.putAt(cxt, i, newValue)
+                            left.getter(cxt).value.putAt(cxt, index.execute(cxt), newValue)
                         }
                     } ?: run {
                         // array literal
@@ -338,17 +365,26 @@ class Compiler(
                         left.setter(startPos)
                         operand = Accessor { cxt ->
                             val x = left.getter(cxt)
-                            if (x.isMutable)
-                                x.value.getAndIncrement(cxt).asReadonly
-                            else cxt.raiseError("Cannot increment immutable value")
+                            if (x.isMutable) {
+                                if (x.value.isConst) {
+                                    x.value.plus(cxt, ObjInt.One).also {
+                                        left.setter(startPos)(cxt, it)
+                                    }.asReadonly
+                                } else
+                                    x.value.getAndIncrement(cxt).asReadonly
+                            } else cxt.raiseError("Cannot increment immutable value")
                         }
                     } ?: run {
                         // no lvalue means pre-increment, expression to increment follows
-                        val next = parseAccessor() ?: throw ScriptError(t.pos, "Expecting expression")
+                        val next = parseTerm() ?: throw ScriptError(t.pos, "Expecting expression")
                         operand = Accessor { ctx ->
-                            next.getter(ctx).also {
+                            val x = next.getter(ctx).also {
                                 if (!it.isMutable) ctx.raiseError("Cannot increment immutable value")
-                            }.value.incrementAndGet(ctx).asReadonly
+                            }.value
+                            if (x.isConst) {
+                                next.setter(startPos)(ctx, x.plus(ctx, ObjInt.One))
+                                x.asReadonly
+                            } else x.incrementAndGet(ctx).asReadonly
                         }
                     }
                 }
@@ -358,18 +394,28 @@ class Compiler(
                     operand?.let { left ->
                         // post decrement
                         left.setter(startPos)
-                        operand = Accessor { ctx ->
-                            left.getter(ctx).also {
-                                if (!it.isMutable) ctx.raiseError("Cannot decrement immutable value")
-                            }.value.getAndDecrement(ctx).asReadonly
+                        operand = Accessor { cxt ->
+                            val x = left.getter(cxt)
+                            if (!x.isMutable) cxt.raiseError("Cannot decrement immutable value")
+                            if (x.value.isConst) {
+                                x.value.minus(cxt, ObjInt.One).also {
+                                    left.setter(startPos)(cxt, it)
+                                }.asReadonly
+                            } else
+                                x.value.getAndDecrement(cxt).asReadonly
                         }
                     } ?: run {
                         // no lvalue means pre-decrement, expression to decrement follows
-                        val next = parseAccessor() ?: throw ScriptError(t.pos, "Expecting expression")
-                        operand = Accessor { ctx ->
-                            next.getter(ctx).also {
-                                if (!it.isMutable) ctx.raiseError("Cannot decrement immutable value")
-                            }.value.decrementAndGet(ctx).asReadonly
+                        val next = parseTerm() ?: throw ScriptError(t.pos, "Expecting expression")
+                        operand = Accessor { cxt ->
+                            val x = next.getter(cxt)
+                            if (!x.isMutable) cxt.raiseError("Cannot decrement immutable value")
+                            if (x.value.isConst) {
+                                x.value.minus(cxt, ObjInt.One).also {
+                                    next.setter(startPos)(cxt, it)
+                                }.asReadonly
+                            } else
+                                x.value.decrementAndGet(cxt).asReadonly
                         }
                     }
                 }
@@ -432,7 +478,7 @@ class Compiler(
 
         val callStatement = statement {
             // and the source closure of the lambda which might have other thisObj.
-            val context = AppliedScope(closure!!, args, this)
+            val context = ClosureScope(this, closure!!) //AppliedScope(closure!!, args, this)
             if (argsDeclaration == null) {
                 // no args: automatic var 'it'
                 val l = args.list
@@ -687,7 +733,7 @@ class Compiler(
         }
     }
 
-    private fun parseAccessor(): Accessor? {
+    private suspend fun parseAccessor(): Accessor? {
         // could be: literal
         val t = cc.next()
         return when (t.type) {
@@ -709,8 +755,14 @@ class Compiler(
             }
 
             Token.Type.MINUS -> {
-                val n = parseNumber(false)
-                Accessor { n.asReadonly }
+                parseNumberOrNull(false)?.let { n ->
+                    Accessor { n.asReadonly }
+                } ?: run {
+                    val n = parseTerm() ?: throw ScriptError(t.pos, "Expecting expression after unary minus")
+                    Accessor {
+                        n.getter.invoke(it).value.negate(it).asReadonly
+                    }
+                }
             }
 
             Token.Type.ID -> {
@@ -741,11 +793,12 @@ class Compiler(
         }
     }
 
-    private fun parseNumber(isPlus: Boolean): Obj {
+    private fun parseNumberOrNull(isPlus: Boolean): Obj? {
+        val pos = cc.savePos()
         val t = cc.next()
         return when (t.type) {
             Token.Type.INT, Token.Type.HEX -> {
-                val n = t.value.toLong(if (t.type == Token.Type.HEX) 16 else 10)
+                val n = t.value.replace("_", "").toLong(if (t.type == Token.Type.HEX) 16 else 10)
                 if (isPlus) ObjInt(n) else ObjInt(-n)
             }
 
@@ -755,11 +808,16 @@ class Compiler(
             }
 
             else -> {
-                throw ScriptError(t.pos, "expected number")
+                cc.restorePos(pos)
+                null
             }
         }
     }
 
+    private fun parseNumber(isPlus: Boolean): Obj {
+        return parseNumberOrNull(isPlus) ?: throw ScriptError(cc.currentPos(), "Expecting number")
+    }
+
     /**
      * Parse keyword-starting statement.
      * @return parsed statement or null if, for example. [id] is not among keywords
@@ -783,6 +841,18 @@ class Compiler(
             val isExtern = cc.skipId("extern")
             when {
                 cc.matchQualifiers("fun", "private") -> parseFunctionDeclaration(Visibility.Private, isExtern)
+                cc.matchQualifiers("fun", "private", "static") -> parseFunctionDeclaration(
+                    Visibility.Private,
+                    isExtern,
+                    isStatic = true
+                )
+
+                cc.matchQualifiers("fun", "static") -> parseFunctionDeclaration(
+                    Visibility.Public,
+                    isExtern,
+                    isStatic = true
+                )
+
                 cc.matchQualifiers("fn", "private") -> parseFunctionDeclaration(Visibility.Private, isExtern)
                 cc.matchQualifiers("fun", "open") -> parseFunctionDeclaration(isOpen = true, isExtern = isExtern)
                 cc.matchQualifiers("fn", "open") -> parseFunctionDeclaration(isOpen = true, isExtern = isExtern)
@@ -790,7 +860,21 @@ class Compiler(
                 cc.matchQualifiers("fun") -> parseFunctionDeclaration(isOpen = false, isExtern = isExtern)
                 cc.matchQualifiers("fn") -> parseFunctionDeclaration(isOpen = false, isExtern = isExtern)
 
+                cc.matchQualifiers("val", "private", "static") -> parseVarDeclaration(
+                    false,
+                    Visibility.Private,
+                    isStatic = true
+                )
+
+                cc.matchQualifiers("val", "static") -> parseVarDeclaration(false, Visibility.Public, isStatic = true)
                 cc.matchQualifiers("val", "private") -> parseVarDeclaration(false, Visibility.Private)
+                cc.matchQualifiers("var", "static") -> parseVarDeclaration(true, Visibility.Public, isStatic = true)
+                cc.matchQualifiers("var", "static", "private") -> parseVarDeclaration(
+                    true,
+                    Visibility.Private,
+                    isStatic = true
+                )
+
                 cc.matchQualifiers("var", "private") -> parseVarDeclaration(true, Visibility.Private)
                 cc.matchQualifiers("val", "open") -> parseVarDeclaration(false, Visibility.Private, true)
                 cc.matchQualifiers("var", "open") -> parseVarDeclaration(true, Visibility.Private, true)
@@ -1050,6 +1134,8 @@ class Compiler(
         cc.skipTokenOfType(Token.Type.NEWLINE, isOptional = true)
         val t = cc.next()
 
+        pushInitScope()
+
         val bodyInit: Statement? = if (t.type == Token.Type.LBRACE) {
             // parse body
             parseScript().also {
@@ -1060,6 +1146,8 @@ class Compiler(
             null
         }
 
+        val initScope = popInitScope()
+
         // create class
         val className = nameToken.value
 
@@ -1082,14 +1170,22 @@ class Compiler(
             thisObj
         }
         // inheritance must alter this code:
-        val newClass = ObjClass(className).apply {
+        val newClass = ObjInstanceClass(className).apply {
             instanceConstructor = constructorCode
+            constructorMeta = constructorArgsDeclaration
         }
 
         return statement {
             // the main statement should create custom ObjClass instance with field
             // accessors, constructor registration, etc.
             addItem(className, false, newClass)
+            if (initScope.isNotEmpty()) {
+                val classScope = copy(newThisObj = newClass)
+                newClass.classScope = classScope
+                for (s in initScope)
+                    s.execute(classScope)
+                        .also { println("executed, ${classScope.objects}") }
+            }
             newClass
         }
     }
@@ -1462,10 +1558,12 @@ class Compiler(
         }
     }
 
-    private suspend fun parseFunctionDeclaration(
+    private suspend fun
+            parseFunctionDeclaration(
         visibility: Visibility = Visibility.Public,
         @Suppress("UNUSED_PARAMETER") isOpen: Boolean = false,
-        isExtern: Boolean = false
+        isExtern: Boolean = false,
+        isStatic: Boolean = false,
     ): Statement {
         var t = cc.next()
         val start = t.pos
@@ -1507,9 +1605,11 @@ class Compiler(
 
         val fnBody = statement(t.pos) { callerContext ->
             callerContext.pos = start
+
             // restore closure where the function was defined, and making a copy of it
             // for local space (otherwise it will write local stuff to closure!)
-            val context = closure?.copy() ?: callerContext.raiseError("bug: closure not set")
+            val context = closure?.let { ClosureScope(callerContext, it) }
+                ?: callerContext.raiseError("bug: closure not set")
 
             // load params from caller context
             argsDeclaration.assignToContext(context, callerContext.args, defaultAccessType = AccessType.Val)
@@ -1518,7 +1618,7 @@ class Compiler(
             }
             fnStatements.execute(context)
         }
-        return statement(start) { context ->
+        val fnCreateStatement = statement(start) { context ->
             // we added fn in the context. now we must save closure
             // for the function
             closure = context
@@ -1527,7 +1627,12 @@ class Compiler(
                 val type = context[typeName]?.value ?: context.raiseSymbolNotFound("class $typeName not found")
                 if (type !is ObjClass) context.raiseClassCastError("$typeName is not the class instance")
                 type.addFn(name, isOpen = true) {
-                    fnBody.execute(this)
+                    // ObjInstance has a fixed instance scope, so we need to build a closure
+                    (thisObj as? ObjInstance)?.let { i ->
+                        fnBody.execute(ClosureScope(this, i.instanceScope))
+                    }
+                    // other classes can create one-time scope for this rare case:
+                        ?: fnBody.execute(thisObj.autoInstanceScope(this))
                 }
             }
             // regular function/method
@@ -1536,6 +1641,11 @@ class Compiler(
             // saved the proper context in the closure
             fnBody
         }
+        return if (isStatic) {
+            currentInitScope += fnCreateStatement
+            NopStatement
+        } else
+            fnCreateStatement
     }
 
     private suspend fun parseBlock(skipLeadingBrace: Boolean = false): Statement {
@@ -1559,7 +1669,8 @@ class Compiler(
     private suspend fun parseVarDeclaration(
         isMutable: Boolean,
         visibility: Visibility,
-        @Suppress("UNUSED_PARAMETER") isOpen: Boolean = false
+        @Suppress("UNUSED_PARAMETER") isOpen: Boolean = false,
+        isStatic: Boolean = false
     ): Statement {
         val nameToken = cc.next()
         val start = nameToken.pos
@@ -1581,6 +1692,21 @@ class Compiler(
         val initialExpression = if (setNull) null else parseStatement(true)
             ?: throw ScriptError(eqToken.pos, "Expected initializer expression")
 
+        if (isStatic) {
+            // find objclass instance: this is tricky: this code executes in object initializer,
+            // when creating instance, but we need to execute it in the class initializer which
+            // is missing as for now. Add it to the compiler context?
+            // add there
+            // return
+            currentInitScope += statement {
+                val initValue = initialExpression?.execute(this)?.byValueCopy() ?: ObjNull
+                (thisObj as ObjClass).createClassField(name, initValue, isMutable, visibility, pos)
+                addItem(name, isMutable, initValue, visibility, ObjRecord.Type.Field)
+                ObjVoid
+            }
+            return NopStatement
+        }
+
         return statement(nameToken.pos) { context ->
             if (context.containsLocal(name))
                 throw ScriptError(nameToken.pos, "Variable $name is already defined")
@@ -1589,7 +1715,7 @@ class Compiler(
             // create a separate copy:
             val initValue = initialExpression?.execute(context)?.byValueCopy() ?: ObjNull
 
-            context.addItem(name, isMutable, initValue, visibility)
+            context.addItem(name, isMutable, initValue, visibility, recordType = ObjRecord.Type.Field)
             initValue
         }
     }
@@ -1612,15 +1738,8 @@ class Compiler(
 
     companion object {
 
-        suspend fun compile(source: Source,pacman: Pacman = Pacman.emptyAllowAll): Script {
-            return Compiler(CompilerContext(parseLyng(source)),pacman).parseScript()
-        }
-
-        suspend fun compilePackage(source: Source): Pair<String, Script> {
-            val c = Compiler(CompilerContext(parseLyng(source)))
-            val script = c.parseScript()
-            if (c.packageName == null) throw ScriptError(source.startPos, "package not set")
-            return c.packageName!! to script
+        suspend fun compile(source: Source, importManager: ImportProvider): Script {
+            return Compiler(CompilerContext(parseLyng(source)), importManager).parseScript()
         }
 
         private var lastPriority = 0
@@ -1743,7 +1862,7 @@ class Compiler(
             allOps.filter { it.priority == l }.associateBy { it.tokenType }
         }
 
-        suspend fun compile(code: String): Script = compile(Source("<eval>", code))
+        suspend fun compile(code: String): Script = compile(Source("<eval>", code), Script.defaultImportManager)
 
         /**
          * The keywords that stop processing of expression term

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

@@ -49,6 +49,10 @@ class CompilerContext(val tokens: List<Token>) {
         throw ScriptError(at, message)
     }
 
+    fun syntaxError(message: String = "Syntax error"): Nothing {
+        throw ScriptError(currentPos(), message)
+    }
+
     fun currentPos(): Pos = tokens[currentIndex].pos
 
     /**
@@ -164,7 +168,9 @@ class CompilerContext(val tokens: List<Token>) {
      * Note that [Token.Type.EOF] is not considered a whitespace token.
      */
     fun skipWsTokens(): Token {
-        while( current().type in wstokens ) next()
+        while( current().type in wstokens ) {
+            next()
+        }
         return next()
     }
 

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

@@ -1,130 +0,0 @@
-package net.sergeych.lyng
-
-import kotlinx.coroutines.Deferred
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-import net.sergeych.mp_tools.globalDefer
-
-/**
- * Package manager. Chained manager, too simple. Override [createModuleScope] to return either
- * valid [ModuleScope] or call [parent] - or return null.
- */
-abstract class Pacman(
-    val parent: Pacman? = null,
-    val rootScope: Scope = parent!!.rootScope,
-    val securityManager: SecurityManager = parent!!.securityManager
-) {
-    private val opScopes = Mutex()
-
-    private val cachedScopes = mutableMapOf<String, Scope>()
-
-    /**
-     * Create a new module scope if this pacman can import the module, return null otherwise so
-     * the manager can decide what to do
-     */
-    abstract suspend fun createModuleScope(name: String): ModuleScope?
-
-    suspend fun prepareImport(pos: Pos, name: String, symbols: Map<String, String>?) {
-        if (!securityManager.canImportModule(name))
-            throw ImportException(pos, "Module $name is not allowed")
-        symbols?.keys?.forEach {
-            if (!securityManager.canImportSymbol(name, it)) throw ImportException(
-                pos,
-                "Symbol $name.$it is not allowed"
-            )
-        }
-        // if we can import the module, cache it, or go further
-        opScopes.withLock {
-            cachedScopes[name] ?: createModuleScope(name)?.let { cachedScopes[name] = it }
-        } ?: parent?.prepareImport(pos, name, symbols) ?: throw ImportException(pos, "Module $name is not found")
-    }
-
-    suspend fun performImport(scope: Scope, name: String, symbols: Map<String, String>?) {
-        val module = opScopes.withLock { cachedScopes[name] }
-            ?: scope.raiseSymbolNotFound("module $name not found")
-        val symbolsToImport = symbols?.keys?.toMutableSet()
-        for ((symbol, record) in module.objects) {
-            if (record.visibility.isPublic) {
-                println("import $name: $symbol: $record")
-                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
-                println("import $name.$symbol as $newName")
-                if (newName in scope.objects)
-                    scope.raiseError("symbol $newName already exists, redefinition on import is not allowed")
-                scope.objects[newName] = record
-            }
-        }
-        if (!symbolsToImport.isNullOrEmpty())
-            scope.raiseSymbolNotFound("symbols $name.{$symbolsToImport} are.were not found")
-    }
-
-    companion object {
-        val emptyAllowAll = object : Pacman(rootScope = Script.defaultScope, securityManager = SecurityManager.allowAll) {
-            override suspend fun createModuleScope(name: String): ModuleScope? {
-                return null
-            }
-
-        }
-    }
-
-}
-
-/**
- * Module scope supports importing and contains the [pacman]; it should be the same
- * used in [Compiler];
- */
-class ModuleScope(
-    val pacman: Pacman,
-    pos: Pos = Pos.builtIn,
-    val packageName: String
-) : Scope(pacman.rootScope, Arguments.EMPTY, pos) {
-
-    constructor(pacman: Pacman,source: Source) : this(pacman, source.startPos, source.fileName)
-
-    override suspend fun checkImport(pos: Pos, name: String, symbols: Map<String, String>?) {
-        pacman.prepareImport(pos, name, symbols)
-    }
-
-    /**
-     * Import symbols into the scope. It _is called_ after the module is imported by [checkImport].
-     * If [checkImport] was not called, the symbols will not be imported with exception as module is not found.
-     */
-    override suspend fun importInto(scope: Scope, name: String, symbols: Map<String, String>?) {
-        pacman.performImport(scope, name, symbols)
-    }
-
-    val packageNameObj by lazy { ObjString(packageName).asReadonly}
-
-    override fun get(name: String): ObjRecord? {
-        return if( name == "__PACKAGE__")
-            packageNameObj
-        else
-            super.get(name)
-    }
-}
-
-
-class InlineSourcesPacman(pacman: Pacman,val sources: List<Source>) : Pacman(pacman) {
-
-    val modules: Deferred<Map<String,Deferred<ModuleScope>>> = globalDefer {
-        val result = mutableMapOf<String, Deferred<ModuleScope>>()
-        for (source in sources) {
-            // retrieve the module name and script for deferred execution:
-            val (name, script) = Compiler.compilePackage(source)
-            // scope is created used pacman's root scope:
-            val scope = ModuleScope(this@InlineSourcesPacman, source.startPos, name)
-            // we execute scripts in parallel which allow cross-imports to some extent:
-            result[name] = globalDefer { script.execute(scope); scope }
-        }
-        result
-    }
-
-    override suspend fun createModuleScope(name: String): ModuleScope? =
-        modules.await()[name]?.await()
-
-}
-
-

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

@@ -1,5 +1,7 @@
 package net.sergeych.lyng
 
+import net.sergeych.lyng.obj.Accessor
+
 sealed class ListEntry {
     data class Element(val accessor: Accessor) : ListEntry()
 

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

@@ -1,5 +1,8 @@
 package net.sergeych.lyng
 
+import net.sergeych.lyng.obj.Obj
+import net.sergeych.lyng.obj.ObjVoid
+
 class LoopBreakContinueException(
     val doContinue: Boolean,
     val result: Obj = ObjVoid,

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

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

@@ -1,31 +0,0 @@
-package net.sergeych.lyng
-
-data class ObjBool(val value: Boolean) : Obj() {
-    override val asStr by lazy { ObjString(value.toString()) }
-
-    override suspend fun compareTo(scope: Scope, 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(scope: Scope): Obj = ObjBool(!value)
-
-    override suspend fun logicalAnd(scope: Scope, other: Obj): Obj = ObjBool(value && other.toBool())
-
-    override suspend fun logicalOr(scope: Scope, other: Obj): Obj = ObjBool(value || other.toBool())
-
-    override suspend fun toKotlin(scope: Scope): Any {
-        return value
-    }
-
-    companion object {
-        val type = ObjClass("Bool")
-    }
-}
-
-val ObjTrue = ObjBool(true)
-val ObjFalse = ObjBool(false)

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

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

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

@@ -1,55 +0,0 @@
-package net.sergeych.lyng
-
-class ObjInstance(override val objClass: ObjClass) : Obj() {
-
-    internal lateinit var instanceScope: Scope
-
-    override suspend fun readField(scope: Scope, name: String): ObjRecord {
-        return instanceScope[name]?.let {
-            if (it.visibility.isPublic)
-                it
-            else
-                scope.raiseError(ObjAccessException(scope, "can't access non-public field $name"))
-        }
-            ?: super.readField(scope, name)
-    }
-
-    override suspend fun writeField(scope: Scope, name: String, newValue: Obj) {
-        instanceScope[name]?.let { f ->
-            if (!f.visibility.isPublic)
-                ObjIllegalAssignmentException(scope, "can't assign to non-public field $name")
-            if (!f.isMutable) ObjIllegalAssignmentException(scope, "can't reassign val $name").raise()
-            if (f.value.assign(scope, newValue) == null)
-                f.value = newValue
-        } ?: super.writeField(scope, name, newValue)
-    }
-
-    override suspend fun invokeInstanceMethod(scope: Scope, name: String, args: Arguments): Obj =
-        instanceScope[name]?.let {
-            if (it.visibility.isPublic)
-                it.value.invoke(scope, this, args)
-            else
-                scope.raiseError(ObjAccessException(scope, "can't invoke non-public method $name"))
-        }
-            ?: super.invokeInstanceMethod(scope, name, args)
-
-    private val publicFields: Map<String, ObjRecord>
-        get() = instanceScope.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(scope: Scope, 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.instanceScope[f.key]!!.value
-            val d = a.compareTo(scope, b)
-            if (d != 0) return d
-        }
-        return 0
-    }
-}

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

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

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

@@ -109,7 +109,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)
                 }
 
                 '*' -> {
@@ -250,7 +250,7 @@ private class Parser(fromPos: Pos) {
 
             in digitsSet -> {
                 pos.back()
-                decodeNumber(loadChars(digits), from)
+                decodeNumber(loadChars { it in digitsSet || it == '_'}, from)
             }
 
             '\'' -> {
@@ -375,6 +375,32 @@ private class Parser(fromPos: Pos) {
 
     private val currentChar: Char get() = pos.currentChar
 
+    private fun fixMultilineStringLiteral(source: String): String {
+        val sizes = mutableListOf<Int>()
+        val lines = source.lines().toMutableList()
+        if( lines.size == 0 ) return ""
+        if( lines[0].isBlank() ) lines.removeFirst()
+        if( lines.isEmpty()) return ""
+        if( lines.last().isBlank() ) lines.removeLast()
+
+        val normalized = lines.map { l ->
+            if( l.isBlank() ) {
+                sizes.add(-1)
+                ""
+            }
+            else {
+                val margin = leftMargin(l)
+                sizes += margin
+                " ".repeat(margin) + l.trim()
+            }
+        }
+        val commonMargin = sizes.filter { it >= 0 }.min()
+        val fixed = if( commonMargin < 1 ) lines else normalized.map {
+            if( it.isBlank() ) "" else it.drop(commonMargin)
+        }
+        return fixed.joinToString("\n")
+    }
+
     private fun loadStringToken(): Token {
         val start = currentPos
 
@@ -383,6 +409,7 @@ private class Parser(fromPos: Pos) {
 //        start = start.back()
 
         val sb = StringBuilder()
+        var newlineDetected = false
         while (currentChar != '"') {
             if (pos.end) throw ScriptError(start, "unterminated string started there")
             when (currentChar) {
@@ -397,6 +424,12 @@ private class Parser(fromPos: Pos) {
                     }
                 }
 
+                '\n', '\r'-> {
+                    newlineDetected = true
+                    sb.append(currentChar)
+                    pos.advance()
+                }
+
                 else -> {
                     sb.append(currentChar)
                     pos.advance()
@@ -404,7 +437,10 @@ private class Parser(fromPos: Pos) {
             }
         }
         pos.advance()
-        return Token(sb.toString(), start, Token.Type.STRING)
+
+        val result = sb.toString().let { if( newlineDetected ) fixMultilineStringLiteral(it) else it }
+
+        return Token(result, start, Token.Type.STRING)
     }
 
     /**
@@ -445,7 +481,7 @@ private class Parser(fromPos: Pos) {
         }
     }
 
-    private fun loadToEnd(): String {
+    private fun loadToEndOfLine(): String {
         val result = StringBuilder()
         val l = pos.line
         do {
@@ -479,4 +515,10 @@ private class Parser(fromPos: Pos) {
         return null
     }
 
+    init {
+        // skip shebang
+        if( pos.readFragment("#!") )
+            loadToEndOfLine()
+    }
+
 }

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

@@ -1,13 +1,22 @@
 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.
  *
- * There are special types of scopes:
+ * 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.
  *
- * - [Script.defaultScope] - root scope for a script, safe one
- * - [AppliedScope] - scope used to apply a closure to some thisObj scope
+ * 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?,
@@ -16,11 +25,13 @@ open class Scope(
     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.defaultScope, args, pos)
+            : this(Script.defaultImportManager.copy().newModuleAt(pos), args, pos)
 
     fun raiseNotImplemented(what: String = "operation"): Nothing = raiseError("$what is not implemented")
 
@@ -35,6 +46,13 @@ open class Scope(
     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))
@@ -55,7 +73,7 @@ open class Scope(
 
     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)
+        return (args.list[index].byValueCopy() as? T)
             ?: raiseClassCastError("Expected type ${T::class.simpleName}, got ${args.list[index]::class.simpleName}")
     }
 
@@ -71,8 +89,20 @@ open class Scope(
         }
     }
 
-    inline fun <reified T : Obj> thisAs(): T = (thisObj as? T)
-        ?: raiseClassCastError("Cannot cast ${thisObj.objClass.className} to ${T::class.simpleName}")
+    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>()
 
@@ -96,9 +126,10 @@ open class Scope(
         name: String,
         isMutable: Boolean,
         value: Obj,
-        visibility: Visibility = Visibility.Public
+        visibility: Visibility = Visibility.Public,
+        recordType: ObjRecord.Type = ObjRecord.Type.Other
     ): ObjRecord {
-        return ObjRecord(value, isMutable, visibility).also { objects[name] = it }
+        return ObjRecord(value, isMutable, visibility,type = recordType).also { objects[name] = it }
     }
 
     fun getOrCreateNamespace(name: String): ObjClass {
@@ -132,21 +163,66 @@ open class Scope(
     fun addConst(name: String, value: Obj) = addItem(name, false, value)
 
     suspend fun eval(code: String): Obj =
-        Compiler.compile(code.toSource()).execute(this)
+        eval(code.toSource())
 
-    suspend fun eval(source: Source): Obj =
-        Compiler.compile(
+    suspend fun eval(source: Source): Obj {
+        return Compiler.compile(
             source,
-            (this as? ModuleScope)?.pacman?.also { println("pacman found: $pacman")} ?: Pacman.emptyAllowAll
-            ).execute(this)
+            currentImportProvider
+        ).execute(this)
+    }
 
     fun containsLocal(name: String): Boolean = name in objects
 
-    open suspend fun checkImport(pos: Pos, name: String, symbols: Map<String, String>? = null) {
-        throw ImportException(pos, "Import is not allowed here: $name")
+    /**
+     * 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"))
     }
 
-    open suspend fun importInto(scope: Scope, name: String, symbols: Map<String, String>? = null) {
-        scope.raiseError(ObjIllegalOperationException(scope,"Import is not allowed here: import $name"))
+    /**
+     * 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
+
+    }
+
+    companion object {
+
+        fun new(): Scope =
+            Script.defaultImportManager.copy().newModuleAt(Pos.builtIn)
     }
 }

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

@@ -1,6 +1,12 @@
 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(
@@ -17,11 +23,28 @@ class Script(
         return lastResult
     }
 
-    suspend fun execute() = execute(defaultScope.copy(pos = pos))
+    suspend fun execute() = execute(
+        defaultImportManager.newStdScope()
+    )
 
     companion object {
-        val defaultScope: Scope = Scope().apply {
+
+        /**
+         * Create new scope using standard safe set of modules, using [defaultImportManager]. It is
+         * suspended as first time calls requires compilation of standard library or other
+         * asynchronous initialization.
+         */
+        suspend fun newScope(pos: Pos = Pos.builtIn) = defaultImportManager.newStdScope(pos)
+
+        internal val rootScope: Scope = Scope(null).apply {
             ObjException.addExceptionsToContext(this)
+            addFn("print") {
+                for ((i, a) in args.withIndex()) {
+                    if (i > 0) print(' ' + a.asStr.value)
+                    else print(a.asStr.value)
+                }
+                ObjVoid
+            }
             addFn("println") {
                 for ((i, a) in args.withIndex()) {
                     if (i > 0) print(' ' + a.asStr.value)
@@ -112,7 +135,7 @@ class Script(
             }
             addFn( "abs" ) {
                 val x = args.firstAndOnly()
-                if( x is ObjInt ) ObjInt( x.value.absoluteValue ) else ObjReal( x.toDouble().absoluteValue )
+                if( x is ObjInt) ObjInt( x.value.absoluteValue ) else ObjReal( x.toDouble().absoluteValue )
             }
 
             addVoidFn("assert") {
@@ -127,6 +150,12 @@ class Script(
                 if( a.compareTo(this, b) != 0 )
                     raiseError(ObjAssertionFailedException(this,"Assertion failed: ${a.inspect()} == ${b.inspect()}"))
             }
+            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()} != ${b.inspect()}"))
+            }
             addFn("assertThrows") {
                 val code = requireOnlyArg<Statement>()
                 val result =try {
@@ -142,6 +171,31 @@ class Script(
                 result ?: raiseError(ObjAssertionFailedException(this,"Expected exception but nothing was thrown"))
             }
 
+            addFn("dynamic") {
+                ObjDynamic.create(this, requireOnlyArg())
+            }
+
+            addFn("require") {
+                val condition = requiredArg<ObjBool>(0)
+                if( !condition.value ) {
+                    val message = args.list.getOrNull(1)?.toString() ?: "requirement not met"
+                    raiseIllegalArgument(message)
+                }
+                ObjVoid
+            }
+            addFn("check") {
+                val condition = requiredArg<ObjBool>(0)
+                if( !condition.value ) {
+                    val message = args.list.getOrNull(1)?.toString() ?: "check failed"
+                    raiseIllegalState(message)
+                }
+                ObjVoid
+            }
+            addFn("traceScope") {
+                this.trace(args.getOrNull(0)?.toString() ?: "")
+                ObjVoid
+            }
+
             addVoidFn("delay") {
                 delay((this.args.firstAndOnly().toDouble()/1000.0).roundToLong())
             }
@@ -163,15 +217,67 @@ class Script(
             addConst("Iterable", ObjIterable)
             addConst("Collection", ObjCollection)
             addConst("Array", ObjArray)
+            addConst("RingBuffer", ObjRingBuffer.type)
             addConst("Class", ObjClassType)
 
+            addConst("Deferred", ObjDeferred.type)
+            addConst("CompletableDeferred", ObjCompletableDeferred.type)
+            addConst("Mutex", ObjMutex.type)
+
+            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()}")
+                        }
+                        ObjVoid
+                    }
+                }
+            }
 
         }
+
     }
 }

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

@@ -2,6 +2,8 @@
 
 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
@@ -12,6 +14,8 @@ open class ScriptError(val pos: Pos, val errorMessage: String, cause: Throwable?
     cause
 )
 
+class ScriptFlowIsNoMoreCollected: Exception()
+
 class ExecutionError(val errorObject: ObjException) : ScriptError(errorObject.scope.pos, errorObject.message)
 
 class ImportException(pos: Pos, message: String) : ScriptError(pos, message)

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

@@ -12,4 +12,15 @@ class Source(val fileName: String, text: String) {
     val startPos: Pos = Pos(this, 0, 0)
 
     fun posAt(line: Int, column: Int): Pos = Pos(this, line, column)
+
+    fun extractPackageName(): String {
+        for ((n,line) in lines.withIndex()) {
+            if( line.isBlank() || line.isEmpty() )
+                continue
+            if( line.startsWith("package ") )
+                return line.substring(8).trim()
+            else throw ScriptError(Pos(this, n, 0),"package declaration expected")
+        }
+        throw ScriptError(Pos(this, 0, 0),"package declaration expected")
+    }
 }

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

@@ -0,0 +1,33 @@
+
+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

@@ -1,48 +1,26 @@
-package net.sergeych.lyng
+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.bintools.encodeToHex
+import net.sergeych.lyng.*
+import net.sergeych.lynon.LynonDecoder
+import net.sergeych.lynon.LynonEncoder
+import net.sergeych.lynon.LynonType
 import net.sergeych.synctools.ProtectedOp
 import net.sergeych.synctools.withLock
 import kotlin.contracts.ExperimentalContracts
 
-/**
- * Record to store object with access rules, e.g. [isMutable] and access level [visibility].
- */
-data class ObjRecord(
-    var value: Obj,
-    val isMutable: Boolean,
-    val visibility: Visibility = Visibility.Public
-)
-
-/**
- * When we need read-write access to an object in some abstract storage, we need Accessor,
- * as in-site assigning is not always sufficient, in general case we need to replace the object
- * in the storage.
- *
- * Note that assigning new value is more complex than just replacing the object, see how assignment
- * operator is implemented in [Compiler.allOps].
- */
-data class Accessor(
-    val getter: suspend (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")
-}
-
 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
@@ -77,15 +55,26 @@ open class Obj {
         scope: Scope,
         name: String,
         args: Arguments = Arguments.EMPTY
-    ): T = invokeInstanceMethod(scope, name, args) as T
+    ): 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
+        args: Arguments = Arguments.EMPTY,
+        onNotFoundResult: Obj?=null
     ): Obj =
-        // note that getInstanceMember traverses the hierarchy
-        objClass.getInstanceMember(scope.pos, name).value.invoke(scope, this, args)
+        objClass.getInstanceMemberOrNull(name)?.value?.invoke(
+            scope,
+            this,
+            args)
+            ?: onNotFoundResult
+            ?: scope.raiseSymbolNotFound(name)
 
     open suspend fun getInstanceMethod(
         scope: Scope,
@@ -125,6 +114,10 @@ open class Obj {
         scope.raiseNotImplemented()
     }
 
+    open suspend fun negate(scope: Scope): Obj {
+        scope.raiseNotImplemented()
+    }
+
     open suspend fun mul(scope: Scope, other: Obj): Obj {
         scope.raiseNotImplemented()
     }
@@ -220,7 +213,7 @@ open class Obj {
 
     suspend fun getAt(scope: Scope, index: Int): Obj = getAt(scope, ObjInt(index.toLong()))
 
-    open suspend fun putAt(scope: Scope, index: Int, newValue: Obj) {
+    open suspend fun putAt(scope: Scope, index: Obj, newValue: Obj) {
         scope.raiseNotImplemented("indexing")
     }
 
@@ -256,31 +249,55 @@ open class Obj {
     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
+    }
 
     companion object {
 
         val rootObjectType = ObjClass("Obj").apply {
-                addFn("toString") {
-                    thisObj.asStr
-                }
-                addFn("contains") {
-                    ObjBool(thisObj.contains(this, args.firstAndOnly()))
-                }
-                // utilities
-                addFn("let") {
-                    args.firstAndOnly().callOn(copy(Arguments(thisObj)))
-                }
-                addFn("apply") {
-                    val newContext = ( thisObj as? ObjInstance)?.instanceScope ?: this
-                    args.firstAndOnly()
-                        .callOn(newContext)
-                    thisObj
-                }
-                addFn("also") {
-                    args.firstAndOnly().callOn(copy(Arguments(thisObj)))
-                    thisObj
-                }
+            addFn("toString") {
+                thisObj.asStr
             }
+            addFn("contains") {
+                ObjBool(thisObj.contains(this, args.firstAndOnly()))
+            }
+            // utilities
+            addFn("let") {
+                args.firstAndOnly().callOn(copy(Arguments(thisObj)))
+            }
+            addFn("apply") {
+                val newContext = (thisObj as? ObjInstance)?.instanceScope ?: this
+                args.firstAndOnly()
+                    .callOn(newContext)
+                thisObj
+            }
+            addFn("also") {
+                args.firstAndOnly().callOn(copy(Arguments(thisObj)))
+                thisObj
+            }
+            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 {
@@ -309,6 +326,8 @@ open class Obj {
     }
 }
 
+fun Double.toObj(): Obj = ObjReal(this)
+
 @Suppress("unused")
 inline fun <reified T> T.toObj(): Obj = Obj.from(this)
 
@@ -341,7 +360,7 @@ object ObjNull : Obj() {
         scope.raiseNPE()
     }
 
-    override suspend fun invokeInstanceMethod(scope: Scope, name: String, args: Arguments): Obj {
+    override suspend fun invokeInstanceMethod(scope: Scope, name: String, args: Arguments, onNotFoundResult: Obj?): Obj {
         scope.raiseNPE()
     }
 
@@ -349,7 +368,7 @@ object ObjNull : Obj() {
         scope.raiseNPE()
     }
 
-    override suspend fun putAt(scope: Scope, index: Int, newValue: Obj) {
+    override suspend fun putAt(scope: Scope, index: Obj, newValue: Obj) {
         scope.raiseNPE()
     }
 
@@ -362,6 +381,27 @@ object ObjNull : Obj() {
     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}")
+            }
+        }
+    }
 }
 
 interface Numeric {
@@ -492,6 +532,9 @@ class ObjIndexOutOfBoundsException(scope: Scope, message: String = "index out of
 class ObjIllegalArgumentException(scope: Scope, message: String = "illegal argument") :
     ObjException("IllegalArgumentException", scope, message)
 
+class ObjIllegalStateException(scope: Scope, message: String = "illegal state") :
+    ObjException("IllegalStateException", scope, message)
+
 @Suppress("unused")
 class ObjNoSuchElementException(scope: Scope, message: String = "no such element") :
     ObjException("IllegalArgumentException", scope, message)

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

@@ -1,4 +1,4 @@
-package net.sergeych.lyng
+package net.sergeych.lyng.obj
 
 val ObjArray by lazy {
 

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

@@ -1,4 +1,6 @@
-package net.sergeych.lyng
+package net.sergeych.lyng.obj
+
+import net.sergeych.lyng.Scope
 
 class ObjArrayIterator(val array: Obj) : Obj() {
 

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

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

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

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

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

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

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

@@ -1,4 +1,6 @@
-package net.sergeych.lyng
+package net.sergeych.lyng.obj
+
+import net.sergeych.lyng.Scope
 
 class ObjChar(val value: Char): Obj() {
 
@@ -11,6 +13,19 @@ class ObjChar(val value: Char): Obj() {
 
     override fun inspect(): String = "'$value'"
 
+    override fun hashCode(): Int {
+        return value.hashCode()
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || this::class != other::class) return false
+
+        other as ObjChar
+
+        return value == other.value
+    }
+
     companion object {
         val type = ObjClass("Char").apply {
             addFn("code") { ObjInt(thisAs<ObjChar>().value.code.toLong()) }

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

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

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

@@ -1,4 +1,4 @@
-package net.sergeych.lyng
+package net.sergeych.lyng.obj
 
 /**
  * Collection is an iterator with `size`]

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

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

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

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

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

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

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

@@ -0,0 +1,65 @@
+package net.sergeych.lyng.obj
+
+import net.sergeych.lyng.Arguments
+import net.sergeych.lyng.Scope
+import net.sergeych.lyng.Statement
+
+class ObjDynamicContext(val delegate: ObjDynamic) : Obj() {
+    override val objClass: ObjClass = type
+
+    companion object {
+        val type = ObjClass("DelegateContext").apply {
+            addFn("get") {
+                val d = thisAs<ObjDynamicContext>().delegate
+                if (d.readCallback != null)
+                    raiseIllegalState("get already defined")
+                d.readCallback = requireOnlyArg()
+                ObjVoid
+            }
+
+            addFn("set") {
+                val d = thisAs<ObjDynamicContext>().delegate
+                if (d.writeCallback != null)
+                    raiseIllegalState("set already defined")
+                d.writeCallback = requireOnlyArg()
+                ObjVoid
+            }
+
+        }
+
+    }
+}
+
+class ObjDynamic : Obj() {
+
+    internal var readCallback: Statement? = null
+    internal var writeCallback: Statement? = null
+
+    override suspend fun readField(scope: Scope, name: String): ObjRecord {
+        return readCallback?.execute(scope.copy(Arguments(ObjString(name))))?.let {
+            if (writeCallback != null)
+                it.asMutable
+            else
+                it.asReadonly
+        }
+            ?: super.readField(scope, name)
+    }
+
+    override suspend fun writeField(scope: Scope, name: String, newValue: Obj) {
+        writeCallback?.execute(scope.copy(Arguments(ObjString(name), newValue)))
+            ?: super.writeField(scope, name, newValue)
+    }
+
+    companion object {
+
+        suspend fun create(scope: Scope, builder: Statement): ObjDynamic {
+            val delegate = ObjDynamic()
+            val context = ObjDynamicContext(delegate)
+            builder.execute(scope.copy(newThisObj = context))
+            return delegate
+        }
+
+        val type = object : ObjClass("Delegate") {}
+    }
+
+}

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

@@ -0,0 +1,136 @@
+package net.sergeych.lyng.obj
+
+import kotlinx.coroutines.DelicateCoroutinesApi
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.channels.ChannelResult
+import kotlinx.coroutines.channels.ReceiveChannel
+import kotlinx.coroutines.channels.SendChannel
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import net.sergeych.lyng.*
+import net.sergeych.mp_tools.globalLaunch
+import kotlin.coroutines.cancellation.CancellationException
+
+
+class ObjFlowBuilder(val output: SendChannel<Obj>) : Obj() {
+
+    override val objClass = type
+
+    companion object {
+        @OptIn(DelicateCoroutinesApi::class)
+        val type = object : ObjClass("FlowBuilder") {}.apply {
+            addFn("emit") {
+                val data = requireOnlyArg<Obj>()
+                try {
+                    val channel = thisAs<ObjFlowBuilder>().output
+                    if( !channel.isClosedForSend )
+                        channel.send(data)
+                    else
+                        throw ScriptFlowIsNoMoreCollected()
+                } catch (x: Exception) {
+                    if( x !is CancellationException )
+                        x.printStackTrace()
+                    throw ScriptFlowIsNoMoreCollected()
+                }
+                ObjVoid
+            }
+        }
+    }
+}
+
+private fun createLyngFlowInput(scope: Scope, producer: Statement): ReceiveChannel<Obj> {
+    val channel = Channel<Obj>(Channel.RENDEZVOUS)
+    val builder = ObjFlowBuilder(channel)
+    val builderScope = scope.copy(newThisObj = builder)
+    globalLaunch {
+        try {
+            producer.execute(builderScope)
+        }
+        catch(x: ScriptFlowIsNoMoreCollected) {
+            x.printStackTrace()
+            // premature flow closing, OK
+        }
+        catch(x: Exception) {
+            x.printStackTrace()
+        }
+        channel.close()
+    }
+    return channel
+}
+
+class ObjFlow(val producer: Statement, val scope: Scope) : Obj() {
+
+    override val objClass = type
+
+    companion object {
+        val type = object : ObjClass("Flow", ObjIterable) {
+            override suspend fun callOn(scope: Scope): Obj {
+                scope.raiseError("Flow constructor is not available")
+            }
+        }.apply {
+            addFn("iterator") {
+                val objFlow = thisAs<ObjFlow>()
+                ObjFlowIterator( statement { objFlow.producer.execute(ClosureScope(this,objFlow.scope)) } )
+            }
+        }
+    }
+}
+
+
+class ObjFlowIterator(val producer: Statement) : Obj() {
+
+    override val objClass: ObjClass = type
+
+    private var channel: ReceiveChannel<Obj>? = null
+
+    private var nextItem: ChannelResult<Obj>? = null
+
+    private var isCancelled = false
+
+    private fun checkNotCancelled(scope: Scope) {
+        if( isCancelled )
+            scope.raiseIllegalState("iteration is cancelled")
+    }
+    suspend fun hasNext(scope: Scope): ObjBool {
+        checkNotCancelled(scope)
+        // cold start:
+        if (channel == null) channel = createLyngFlowInput(scope, producer)
+        if (nextItem == null) nextItem = channel!!.receiveCatching()
+        return ObjBool(nextItem!!.isSuccess)
+    }
+
+    suspend fun next(scope: Scope): Obj {
+        checkNotCancelled(scope)
+        if (hasNext(scope).value == false) scope.raiseIllegalState("iteration is done")
+        return nextItem!!.getOrThrow().also { nextItem = null }
+    }
+
+    private val access = Mutex()
+    suspend fun cancel() {
+        access.withLock {
+            if (!isCancelled) {
+                isCancelled = true
+                channel?.cancel()
+            }
+        }
+    }
+
+    companion object {
+        val type = object : ObjClass("FlowIterator", ObjIterator) {
+
+        }.apply {
+            addFn("hasNext") {
+                thisAs<ObjFlowIterator>().hasNext(this).toObj()
+            }
+            addFn("next") {
+                val x = thisAs<ObjFlowIterator>()
+                x.next(this)
+            }
+            addFn("cancelIteration") {
+                val x = thisAs<ObjFlowIterator>()
+                x.cancel()
+                ObjVoid
+            }
+        }
+    }
+}

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

@@ -0,0 +1,109 @@
+package net.sergeych.lyng.obj
+
+import net.sergeych.lyng.Arguments
+import net.sergeych.lyng.Scope
+import net.sergeych.lynon.LynonDecoder
+import net.sergeych.lynon.LynonEncoder
+import net.sergeych.lynon.LynonType
+
+class ObjInstance(override val objClass: ObjClass) : Obj() {
+
+    internal lateinit var instanceScope: Scope
+
+    override suspend fun readField(scope: Scope, name: String): ObjRecord {
+        return instanceScope[name]?.let {
+            if (it.visibility.isPublic)
+                it
+            else
+                scope.raiseError(ObjAccessException(scope, "can't access non-public field $name"))
+        }
+            ?: super.readField(scope, name)
+    }
+
+    override suspend fun writeField(scope: Scope, name: String, newValue: Obj) {
+        instanceScope[name]?.let { f ->
+            if (!f.visibility.isPublic)
+                ObjIllegalAssignmentException(scope, "can't assign to non-public field $name")
+            if (!f.isMutable) ObjIllegalAssignmentException(scope, "can't reassign val $name").raise()
+            if (f.value.assign(scope, newValue) == null)
+                f.value = newValue
+        } ?: super.writeField(scope, name, newValue)
+    }
+
+    override suspend fun invokeInstanceMethod(scope: Scope, name: String, args: Arguments,
+                                              onNotFoundResult: Obj?): Obj =
+        instanceScope[name]?.let {
+            if (it.visibility.isPublic)
+                it.value.invoke(
+                    instanceScope,
+                    this,
+                    args)
+            else
+                scope.raiseError(ObjAccessException(scope, "can't invoke non-public method $name"))
+        }
+            ?: super.invokeInstanceMethod(scope, name, args, onNotFoundResult)
+
+    private val publicFields: Map<String, ObjRecord>
+        get() = instanceScope.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 serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
+        val meta = objClass.constructorMeta
+            ?: scope.raiseError("can't serialize non-serializable object (no constructor meta)")
+        // actual constructor can vary, for example, adding new fields with default
+        // values, so we save size of the construction:
+
+        // using objlist allow for some optimizations:
+        val params = meta.params.map { readField(scope, it.name).value }
+        encoder.encodeAnyList(scope, params)
+        serializeStateVars(scope, encoder)
+    }
+
+    protected val instanceVars: Map<String, ObjRecord> by lazy {
+        instanceScope.objects.filter { it.value.type.serializable }
+    }
+
+    protected suspend fun serializeStateVars(scope: Scope,encoder: LynonEncoder) {
+        val vars = instanceVars.values.map { it.value }
+        if( vars.isNotEmpty()) {
+            encoder.encodeAnyList(scope, vars)
+            println("serialized state vars $vars")
+        }
+    }
+
+    internal suspend fun deserializeStateVars(scope: Scope, decoder: LynonDecoder) {
+        val localVars = instanceVars.values.toList()
+        if( localVars.isNotEmpty() ) {
+            println("gonna read vars")
+            val vars = decoder.decodeAnyList(scope)
+            if (vars.size > instanceVars.size)
+                scope.raiseIllegalArgument("serialized vars has bigger size than instance vars")
+            println("deser state vars $vars")
+            for ((i, v) in vars.withIndex()) {
+                localVars[i].value = v
+            }
+        }
+    }
+
+    protected val comparableVars: Map<String, ObjRecord> by lazy {
+        instanceScope.objects.filter {
+            it.value.type.comparable
+        }
+    }
+
+    override suspend fun compareTo(scope: Scope, other: Obj): Int {
+        if (other !is ObjInstance) return -1
+        if (other.objClass != objClass) return -1
+        for (f in comparableVars) {
+            val a = f.value.value
+            val b = other.instanceScope[f.key]!!.value
+            val d = a.compareTo(scope, b)
+            if (d != 0) return d
+        }
+        return 0
+    }
+}

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

@@ -0,0 +1,26 @@
+package net.sergeych.lyng.obj
+
+import net.sergeych.lyng.Arguments
+import net.sergeych.lyng.Scope
+import net.sergeych.lynon.LynonDecoder
+import net.sergeych.lynon.LynonType
+
+/**
+ * Special variant of [ObjClass] to be used in [ObjInstance], e.g. for Lyng compiled classes
+ */
+class ObjInstanceClass(val name: String) : ObjClass(name) {
+
+    override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj {
+        val args = decoder.decodeAnyList(scope)
+        println("deserializing constructor $name, $args params")
+        val actualSize = constructorMeta?.params?.size ?: 0
+        if( args.size > actualSize )
+            scope.raiseIllegalArgument("constructor $name has only $actualSize but serialized version has ${args.size}")
+        val newScope = scope.copy(args = Arguments(args))
+        return (callOn(newScope) as ObjInstance).apply {
+            deserializeStateVars(scope,decoder)
+            invokeInstanceMethod(scope, "onDeserialized", onNotFoundResult = ObjVoid)
+        }
+    }
+
+}

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

@@ -0,0 +1,178 @@
+package net.sergeych.lyng.obj
+
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+import kotlinx.datetime.isDistantFuture
+import kotlinx.datetime.isDistantPast
+import net.sergeych.lyng.Scope
+import net.sergeych.lynon.LynonDecoder
+import net.sergeych.lynon.LynonEncoder
+import net.sergeych.lynon.LynonSettings
+import net.sergeych.lynon.LynonType
+
+class ObjInstant(val instant: Instant,val truncateMode: LynonSettings.InstantTruncateMode=LynonSettings.InstantTruncateMode.Microsecond) : Obj() {
+    override val objClass: ObjClass get() = type
+
+    override fun toString(): String {
+        return instant.toString()
+    }
+
+    override suspend fun plus(scope: Scope, other: Obj): Obj {
+        return when (other) {
+            is ObjDuration -> ObjInstant(instant + other.duration)
+            else -> super.plus(scope, other)
+        }
+    }
+
+    override suspend fun minus(scope: Scope, other: Obj): Obj {
+        return when (other) {
+            is ObjDuration -> ObjInstant(instant - other.duration)
+            is ObjInstant -> ObjDuration(instant - other.instant)
+            else -> super.plus(scope, other)
+        }
+    }
+
+    override suspend fun compareTo(scope: Scope, other: Obj): Int {
+        if( other is ObjInstant) {
+            return instant.compareTo(other.instant)
+        }
+        return super.compareTo(scope, other)
+    }
+
+    override suspend fun toKotlin(scope: Scope): Any {
+        return instant
+    }
+
+    override fun hashCode(): Int {
+        return instant.hashCode()
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || this::class != other::class) return false
+
+        other as ObjInstant
+
+        return instant == other.instant
+    }
+
+    override suspend fun lynonType(): LynonType = LynonType.Instant
+
+    override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
+        encoder.putBits(truncateMode.ordinal, 2)
+        when(truncateMode) {
+            LynonSettings.InstantTruncateMode.Millisecond ->
+                encoder.encodeSigned(instant.toEpochMilliseconds())
+            LynonSettings.InstantTruncateMode.Second ->
+                encoder.encodeSigned(instant.epochSeconds)
+            LynonSettings.InstantTruncateMode.Microsecond -> {
+                encoder.encodeSigned(instant.epochSeconds)
+                encoder.encodeUnsigned(instant.nanosecondsOfSecond.toULong() / 1000UL)
+            }
+        }
+    }
+
+    companion object {
+        val distantFuture by lazy {
+            ObjInstant(Instant.DISTANT_FUTURE)
+        }
+
+        val distantPast by lazy {
+            ObjInstant(Instant.DISTANT_PAST)
+        }
+
+        val type = object : ObjClass("Instant") {
+            override suspend fun callOn(scope: Scope): Obj {
+                val args = scope.args
+                val a0 = args.list.getOrNull(0)
+                return ObjInstant(
+                    when (a0) {
+                        null -> {
+                            val t = Clock.System.now()
+                            Instant.fromEpochSeconds(t.epochSeconds, t.nanosecondsOfSecond)
+                        }
+                        is ObjInt -> Instant.fromEpochSeconds(a0.value)
+                        is ObjReal -> {
+                            val seconds = a0.value.toLong()
+                            val nanos = (a0.value - seconds) * 1e9
+                            Instant.fromEpochSeconds(seconds, nanos.toLong())
+                        }
+                        is ObjInstant -> a0.instant
+
+                        else -> {
+                            scope.raiseIllegalArgument("can't construct Instant(${args.inspect()})")
+                        }
+                    }
+                )
+            }
+
+            override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj {
+                val mode = LynonSettings.InstantTruncateMode.entries[decoder.getBitsAsInt(2)]
+                return when (mode) {
+                    LynonSettings.InstantTruncateMode.Microsecond -> ObjInstant(
+                        Instant.fromEpochSeconds(
+                            decoder.unpackSigned(), decoder.unpackUnsignedInt() * 1000
+                        )
+                    )
+                    LynonSettings.InstantTruncateMode.Millisecond -> ObjInstant(
+                        Instant.fromEpochMilliseconds(
+                            decoder.unpackSigned()
+                        )
+                    )
+                    LynonSettings.InstantTruncateMode.Second -> ObjInstant(
+                        Instant.fromEpochSeconds(decoder.unpackSigned())
+                    )
+                }
+            }
+
+        }.apply {
+            addFn("epochSeconds") {
+                val instant = thisAs<ObjInstant>().instant
+                ObjReal(instant.epochSeconds + instant.nanosecondsOfSecond * 1e-9)
+            }
+            addFn("isDistantFuture") {
+                thisAs<ObjInstant>().instant.isDistantFuture.toObj()
+            }
+            addFn("isDistantPast") {
+                thisAs<ObjInstant>().instant.isDistantPast.toObj()
+            }
+            addFn("epochWholeSeconds") {
+                ObjInt(thisAs<ObjInstant>().instant.epochSeconds)
+            }
+            addFn("nanosecondsOfSecond") {
+                ObjInt(thisAs<ObjInstant>().instant.nanosecondsOfSecond.toLong())
+            }
+            addFn("truncateToSecond") {
+                val t = thisAs<ObjInstant>().instant
+                ObjInstant(Instant.fromEpochSeconds(t.epochSeconds), LynonSettings.InstantTruncateMode.Second)
+            }
+            addFn("truncateToMillisecond") {
+                val t = thisAs<ObjInstant>().instant
+                ObjInstant(
+                    Instant.fromEpochSeconds(t.epochSeconds, t.nanosecondsOfSecond / 1_000_000 * 1_000_000),
+                    LynonSettings.InstantTruncateMode.Millisecond
+                )
+            }
+            addFn("truncateToMicrosecond") {
+                val t = thisAs<ObjInstant>().instant
+                ObjInstant(
+                    Instant.fromEpochSeconds(t.epochSeconds, t.nanosecondsOfSecond / 1_000 * 1_000),
+                    LynonSettings.InstantTruncateMode.Microsecond
+                )
+            }
+            // class members
+
+            addClassConst("distantFuture", distantFuture)
+            addClassConst("distantPast", distantPast)
+            addClassFn("now") {
+                ObjInstant(Clock.System.now())
+            }
+//            addFn("epochMilliseconds") {
+//                ObjInt(instant.toEpochMilliseconds())
+//            }
+        }
+
+    }
+}
+
+

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

@@ -1,6 +1,11 @@
-package net.sergeych.lyng
+package net.sergeych.lyng.obj
 
-data class ObjInt(var value: Long) : Obj(), Numeric {
+import net.sergeych.lyng.Scope
+import net.sergeych.lynon.LynonDecoder
+import net.sergeych.lynon.LynonEncoder
+import net.sergeych.lynon.LynonType
+
+class ObjInt(var value: Long, override val isConst: Boolean = false) : Obj(), Numeric {
     override val asStr get() = ObjString(value.toString())
     override val longValue get() = value
     override val doubleValue get() = value.toDouble()
@@ -14,18 +19,22 @@ data class ObjInt(var value: Long) : Obj(), Numeric {
     }
 
     override suspend fun getAndIncrement(scope: Scope): Obj {
+        ensureNotConst(scope)
         return ObjInt(value).also { value++ }
     }
 
     override suspend fun getAndDecrement(scope: Scope): Obj {
+        ensureNotConst(scope)
         return ObjInt(value).also { value-- }
     }
 
     override suspend fun incrementAndGet(scope: Scope): Obj {
+        ensureNotConst(scope)
         return ObjInt(++value)
     }
 
     override suspend fun decrementAndGet(scope: Scope): Obj {
+        ensureNotConst(scope)
         return ObjInt(--value)
     }
 
@@ -70,7 +79,7 @@ data class ObjInt(var value: Long) : Obj(), Numeric {
      * assignment
      */
     override suspend fun assign(scope: Scope, other: Obj): Obj? {
-        return if (other is ObjInt) {
+        return if (!isConst && other is ObjInt) {
             value = other.value
             this
         } else null
@@ -89,10 +98,44 @@ data class ObjInt(var value: Long) : Obj(), Numeric {
         return value == other.value
     }
 
+    override suspend fun negate(scope: Scope): Obj {
+        return ObjInt(-value)
+    }
+
+    override suspend fun lynonType(): LynonType = when (value) {
+        0L -> LynonType.Int0
+        else -> {
+            if (value > 0) LynonType.IntPositive
+            else LynonType.IntNegative
+        }
+    }
+
+
+    override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
+        when (lynonType) {
+            null -> encoder.encodeSigned(value)
+            LynonType.Int0 -> {}
+            LynonType.IntPositive -> encoder.encodeUnsigned(value.toULong())
+            LynonType.IntNegative -> encoder.encodeUnsigned((-value).toULong())
+            LynonType.IntSigned -> encoder.encodeSigned(value)
+            else -> scope.raiseIllegalArgument("Unsupported lynon type code for Int: $lynonType")
+        }
+    }
+
     companion object {
-        val Zero = ObjInt(0)
-        val One = ObjInt(1)
-        val type = ObjClass("Int")
+        val Zero = ObjInt(0, true)
+        val One = ObjInt(1, true)
+        val type = object : ObjClass("Int") {
+            override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj =
+                when (lynonType) {
+                    null -> ObjInt(decoder.unpackSigned())
+                    LynonType.Int0 -> Zero
+                    LynonType.IntPositive -> ObjInt(decoder.unpackUnsigned().toLong())
+                    LynonType.IntNegative -> ObjInt(-decoder.unpackUnsigned().toLong())
+                    LynonType.IntSigned -> ObjInt(decoder.unpackSigned())
+                    else -> scope.raiseIllegalState("illegal type code for Int: $lynonType")
+                }
+        }
     }
 }
 

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

@@ -1,4 +1,7 @@
-package net.sergeych.lyng
+package net.sergeych.lyng.obj
+
+import net.sergeych.lyng.Arguments
+import net.sergeych.lyng.Statement
 
 /**
  * Abstract class that must provide `iterator` method that returns [ObjIterator] instance.
@@ -50,7 +53,7 @@ val ObjIterable by lazy {
         addFn("toMap") {
             val result = ObjMap()
             thisObj.toFlow(this).collect { pair ->
-                result.map[pair.getAt(this,0)] = pair.getAt(this, 1)
+                result.map[pair.getAt(this, 0)] = pair.getAt(this, 1)
             }
             result
         }
@@ -83,6 +86,24 @@ val ObjIterable by lazy {
             ObjList(result)
         }
 
+        addFn("take") {
+            var n = requireOnlyArg<ObjInt>().value.toInt()
+            val result = mutableListOf<Obj>()
+            if (n > 0) {
+                thisObj.enumerate(this) {
+                    result += it
+                    --n > 0
+                }
+            }
+            ObjList(result)
+        }
+
+//        addFn("drop" ) {
+//            var n = requireOnlyArg<ObjInt>().value.toInt()
+//            if( n < 0 ) raiseIllegalArgument("drop($n): should be positive")
+//            val it = callMethod<>()
+//        }
+
         addFn("isEmpty") {
             ObjBool(
                 thisObj.invokeInstanceMethod(this, "iterator")
@@ -90,6 +111,5 @@ val ObjIterable by lazy {
                     .not()
             )
         }
-
     }
 }

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

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

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

@@ -1,9 +1,10 @@
 @file:Suppress("unused")
 
-package net.sergeych.lyng
+package net.sergeych.lyng.obj
 
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.flow
+import net.sergeych.lyng.Scope
 
 /**
  * Iterator wrapper to allow Kotlin collections to be returned from Lyng objects;
@@ -35,7 +36,9 @@ class ObjKotlinObjIterator(val iterator: Iterator<Obj>) : Obj() {
             addFn("next") {
                 thisAs<ObjKotlinObjIterator>().iterator.next()
             }
-            addFn("hasNext") { thisAs<ObjKotlinIterator>().iterator.hasNext().toObj() }
+            addFn("hasNext") {
+                thisAs<ObjKotlinObjIterator>().iterator.hasNext().toObj()
+            }
         }
 
     }
@@ -55,3 +58,25 @@ fun Obj.toFlow(scope: Scope): Flow<Obj> = flow {
         emit(next.invoke(scope, iterator))
     }
 }
+
+/**
+ * Call [callback] for each element of this obj considering it provides [Iterator]
+ * methods `hasNext` and `next`.
+ *
+ * IF callback returns false, iteration is stopped.
+ */
+suspend fun Obj.enumerate(scope: Scope,callback: suspend (Obj)->Boolean) {
+    val iterator = invokeInstanceMethod(scope, "iterator")
+    val hasNext = iterator.getInstanceMethod(scope, "hasNext")
+    val next = iterator.getInstanceMethod(scope, "next")
+    var closeIt = false
+    while (hasNext.invoke(scope, iterator).toBool()) {
+        val nextValue = next.invoke(scope, iterator)
+        if( !callback(nextValue) ) {
+            closeIt = true
+            break
+        }
+    }
+    if( closeIt )
+        iterator.invokeInstanceMethod(scope, "cancelIteration", onNotFoundResult = ObjVoid)
+}

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

@@ -1,12 +1,13 @@
-package net.sergeych.lyng
+package net.sergeych.lyng.obj
+
+import net.sergeych.lyng.Scope
+import net.sergeych.lyng.statement
+import net.sergeych.lynon.LynonDecoder
+import net.sergeych.lynon.LynonEncoder
+import net.sergeych.lynon.LynonType
 
 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() }
     }]"
@@ -51,9 +52,8 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
         }
     }
 
-    override suspend fun putAt(scope: Scope, index: Int, newValue: Obj) {
-        val i = index
-        list[i] = newValue
+    override suspend fun putAt(scope: Scope, index: Obj, newValue: Obj) {
+        list[index.toInt()] = newValue
     }
 
     override suspend fun compareTo(scope: Scope, other: Obj): Int {
@@ -128,24 +128,23 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
         return list == other.list
     }
 
-    companion object {
-        val type = ObjClass("List", ObjArray).apply {
+    override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
+        encoder.encodeAnyList(scope,list)
+    }
 
+    override suspend fun lynonType(): LynonType = LynonType.List
+
+    companion object {
+        val type = object : ObjClass("List", ObjArray) {
+            override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj {
+                return ObjList(decoder.decodeAnyList(scope))
+            }
+        }.apply {
             createField("size",
                 statement {
                     (thisObj as ObjList).list.size.toObj()
                 }
             )
-            addFn("getAt") {
-                requireExactCount(1)
-                thisAs<ObjList>().getAt(this, requiredArg<Obj>(0))
-            }
-            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

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

@@ -1,4 +1,10 @@
-package net.sergeych.lyng
+package net.sergeych.lyng.obj
+
+import net.sergeych.lyng.Scope
+import net.sergeych.lyng.Statement
+import net.sergeych.lynon.LynonDecoder
+import net.sergeych.lynon.LynonEncoder
+import net.sergeych.lynon.LynonType
 
 class ObjMapEntry(val key: Obj, val value: Obj) : Obj() {
 
@@ -9,6 +15,14 @@ class ObjMapEntry(val key: Obj, val value: Obj) : Obj() {
         return value.compareTo(scope, other.value)
     }
 
+    override fun hashCode(): Int {
+        return key.hashCode() + value.hashCode()
+    }
+
+    override fun equals(other: Any?): Boolean {
+        return other is ObjMapEntry && key == other.key && value == other.value
+    }
+
     override suspend fun getAt(scope: Scope, index: Obj): Obj = when (index.toInt()) {
         0 -> key
         1 -> value
@@ -21,11 +35,23 @@ class ObjMapEntry(val key: Obj, val value: Obj) : Obj() {
 
     override val objClass = type
 
+    override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
+        encoder.encodeAny(scope,key)
+        encoder.encodeAny(scope,value)
+    }
+
     companion object {
         val type = object : ObjClass("MapEntry", ObjArray) {
             override suspend fun callOn(scope: Scope): Obj {
                 return ObjMapEntry(scope.requiredArg<Obj>(0), scope.requiredArg<Obj>(1))
             }
+
+            override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj {
+                return ObjMapEntry(
+                    decoder.decodeAny(scope),
+                    decoder.decodeAny(scope)
+                )
+            }
         }.apply {
             addFn("key") { thisAs<ObjMapEntry>().key }
             addFn("value") { thisAs<ObjMapEntry>().value }
@@ -39,7 +65,11 @@ class ObjMap(val map: MutableMap<Obj, Obj> = mutableMapOf()) : Obj() {
     override val objClass = type
 
     override suspend fun getAt(scope: Scope, index: Obj): Obj =
-        map.getOrElse(index) { scope.raiseNoSuchElement() }
+        map.get(index) ?: ObjNull
+
+    override suspend fun putAt(scope: Scope, index: Obj, newValue: Obj) {
+        map[index] = newValue
+    }
 
     override suspend fun contains(scope: Scope, other: Obj): Boolean {
         return other in map
@@ -51,6 +81,28 @@ class ObjMap(val map: MutableMap<Obj, Obj> = mutableMapOf()) : Obj() {
     }
     override fun toString(): String = map.toString()
 
+    override fun hashCode(): Int {
+        return map.hashCode()
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || this::class != other::class) return false
+
+        other as ObjMap
+
+        return map == other.map
+    }
+
+    override suspend fun lynonType(): LynonType = LynonType.Map
+
+    override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
+        val keys = map.keys.map { it.toObj() }
+        val values = map.values.map { it.toObj() }
+        encoder.encodeAnyList(scope, keys)
+        encoder.encodeAnyList(scope, values, fixedSize = true)
+    }
+
     companion object {
 
         suspend fun listToMap(scope: Scope, list: List<Obj>): MutableMap<Obj, Obj> {
@@ -78,6 +130,13 @@ class ObjMap(val map: MutableMap<Obj, Obj> = mutableMapOf()) : Obj() {
             override suspend fun callOn(scope: Scope): Obj {
                 return ObjMap(listToMap(scope, scope.args.list))
             }
+
+            override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj {
+                val keys = decoder.decodeAnyList(scope)
+                val values = decoder.decodeAnyList(scope,fixedSize = keys.size)
+                if( keys.size != values.size) scope.raiseIllegalArgument("map keys and values should be same size")
+                return ObjMap(keys.zip(values).toMap().toMutableMap())
+            }
         }.apply {
             addFn("getOrNull") {
                 val key = args.firstAndOnly(pos)

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

@@ -0,0 +1,71 @@
+package net.sergeych.lyng.obj
+
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.toList
+import net.sergeych.lyng.Scope
+
+class ObjMutableBuffer(byteArray: UByteArray) : ObjBuffer(byteArray) {
+
+    override suspend fun putAt(scope: Scope, index: Obj, newValue: Obj) {
+        byteArray[checkIndex(scope, index.toObj())] = when (newValue) {
+            is ObjInt -> newValue.value.toUByte()
+            is ObjChar -> newValue.value.code.toUByte()
+            else -> scope.raiseIllegalArgument(
+                "invalid byte value for buffer at index ${index.inspect()}: ${newValue.inspect()}"
+            )
+        }
+    }
+
+    companion object {
+
+        private suspend fun createBufferFrom(scope: Scope, obj: Obj): ObjBuffer =
+            when (obj) {
+                is ObjBuffer -> ObjMutableBuffer(obj.byteArray.copyOf())
+                is ObjInt -> {
+                    if (obj.value < 0)
+                        scope.raiseIllegalArgument("buffer size must be positive")
+                    val data = UByteArray(obj.value.toInt())
+                    ObjMutableBuffer(data)
+                }
+
+                is ObjString -> ObjMutableBuffer(obj.value.encodeToByteArray().asUByteArray())
+                else -> {
+                    if (obj.isInstanceOf(ObjIterable)) {
+                        ObjMutableBuffer(
+                            obj.toFlow(scope).map { it.toLong().toUByte() }.toList().toTypedArray()
+                                .toUByteArray()
+                        )
+                    } else
+                        scope.raiseIllegalArgument(
+                            "can't construct buffer from ${obj.inspect()}"
+                        )
+                }
+            }
+
+        val type = object : ObjClass("MutableBuffer", ObjBuffer.type) {
+            override suspend fun callOn(scope: Scope): Obj {
+                val args = scope.args.list
+                return when (args.size) {
+                    // empty buffer
+                    0 -> ObjMutableBuffer(ubyteArrayOf())
+                    1 -> createBufferFrom(scope, args[0])
+                    else -> {
+                        // create buffer from array, each argument should be a byte then:
+                        val data = UByteArray(args.size)
+                        for ((i, b) in args.withIndex()) {
+                            val code = when (b) {
+                                is ObjChar -> b.value.code.toUByte()
+                                is ObjInt -> b.value.toUByte()
+                                else -> scope.raiseIllegalArgument(
+                                    "invalid byte value for buffer constructor at index $i: ${b.inspect()}"
+                                )
+                            }
+                            data[i] = code
+                        }
+                        ObjMutableBuffer(data)
+                    }
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,23 @@
+package net.sergeych.lyng.obj
+
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import net.sergeych.lyng.Scope
+import net.sergeych.lyng.Statement
+
+class ObjMutex(val mutex: Mutex): Obj() {
+    override val objClass = type
+
+    companion object {
+        val type = object: ObjClass("Mutex") {
+            override suspend fun callOn(scope: Scope): Obj {
+                return ObjMutex(Mutex())
+            }
+        }.apply {
+            addFn("withLock") {
+                val f = requiredArg<Statement>(0)
+                thisAs<ObjMutex>().mutex.withLock { f.execute(this) }
+            }
+        }
+    }
+}

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

@@ -1,4 +1,6 @@
-package net.sergeych.lyng
+package net.sergeych.lyng.obj
+
+import net.sergeych.lyng.Scope
 
 class ObjRange(val start: Obj?, val end: Obj?, val isEndInclusive: Boolean) : Obj() {
 
@@ -15,6 +17,31 @@ class ObjRange(val start: Obj?, val end: Obj?, val isEndInclusive: Boolean) : Ob
         return result.toString()
     }
 
+    /**
+     * IF end is open (null/ObjNull), returns null
+     * Otherwise, return correct value for the exclusive end
+     * raises [ObjIllegalArgumentException] if end is not ObjInt
+     */
+    fun exclusiveIntEnd(scope: Scope): Int? =
+        if (end == null || end is ObjNull) null
+        else {
+            if (end !is ObjInt) scope.raiseIllegalArgument("end is not int")
+            if (isEndInclusive) end.value.toInt() + 1 else end.value.toInt()
+        }
+
+
+    /**
+     * If start is null/ObjNull, returns 0
+     * if start is not ObjInt, raises [ObjIllegalArgumentException]
+     * otherwise returns start.value.toInt()
+     */
+    fun startInt(scope: Scope): Int =
+        if( start == null || start is ObjNull) 0
+        else {
+            if( start is ObjInt) start.value.toInt()
+            else scope.raiseIllegalArgument("start is not Int: ${start.inspect()}")
+        }
+
     suspend fun containsRange(scope: Scope, other: ObjRange): Boolean {
         if (start != null) {
             // our start is not -∞ so other start should be GTE or is not contained:
@@ -74,6 +101,27 @@ class ObjRange(val start: Obj?, val end: Obj?, val isEndInclusive: Boolean) : Ob
             ?: -1
     }
 
+    override fun hashCode(): Int {
+        var result = start?.hashCode() ?: 0
+        result = 31 * result + (end?.hashCode() ?: 0)
+        result = 31 * result + isEndInclusive.hashCode()
+        return result
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || this::class != other::class) return false
+
+        other as ObjRange
+
+        if (start != other.start) return false
+        if (end != other.end) return false
+        if (isEndInclusive != other.isEndInclusive) return false
+
+        return true
+    }
+
+
     companion object {
         val type = ObjClass("Range", ObjIterable).apply {
             addFn("start") {

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

@@ -1,4 +1,6 @@
-package net.sergeych.lyng
+package net.sergeych.lyng.obj
+
+import net.sergeych.lyng.Scope
 
 class ObjRangeIterator(val self: ObjRange) : Obj() {
 

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

@@ -1,5 +1,11 @@
-package net.sergeych.lyng
+package net.sergeych.lyng.obj
 
+import net.sergeych.lyng.Pos
+import net.sergeych.lyng.Scope
+import net.sergeych.lyng.statement
+import net.sergeych.lynon.LynonDecoder
+import net.sergeych.lynon.LynonEncoder
+import net.sergeych.lynon.LynonType
 import kotlin.math.floor
 import kotlin.math.roundToLong
 
@@ -56,8 +62,21 @@ data class ObjReal(val value: Double) : Obj(), Numeric {
         return value == other.value
     }
 
+    override suspend fun negate(scope: Scope): Obj {
+        return ObjReal(-value)
+    }
+
+    override suspend fun lynonType(): LynonType = LynonType.Real
+
+    override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
+        encoder.encodeReal(value)
+    }
+
     companion object {
-        val type: ObjClass = ObjClass("Real").apply {
+        val type: ObjClass = object : ObjClass("Real") {
+            override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj =
+                ObjReal(decoder.unpackDouble())
+        }.apply {
             createField(
                 "roundToInt",
                 statement(Pos.builtIn) {

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

@@ -0,0 +1,27 @@
+package net.sergeych.lyng.obj
+
+import net.sergeych.lyng.Scope
+import net.sergeych.lyng.Visibility
+
+/**
+ * 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,
+    var importedFrom: Scope? = null,
+    val isTransient: Boolean = false,
+    val type: Type = Type.Other
+) {
+    enum class Type(val comparable: Boolean = false,val serializable: Boolean = false) {
+        Field(true, true),
+        @Suppress("unused")
+        Fun,
+        ConstructorField(true, true),
+        Other
+    }
+    @Suppress("unused")
+    fun qualifiedName(name: String): String =
+        "${importedFrom?.packageName ?: "anonymous"}.$name"
+}

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

@@ -0,0 +1,91 @@
+package net.sergeych.lyng.obj
+
+import net.sergeych.lyng.Scope
+
+class RingBuffer<T>(val maxSize: Int) : Iterable<T> {
+    private val data = arrayOfNulls<Any>(maxSize)
+
+    var size = 0
+        private set
+
+    private var start = 0
+
+    init {
+        check(maxSize > 0) { "Max size should be a positive number: $maxSize" }
+    }
+
+    fun add(item: T) {
+        if (size < maxSize)
+            size++
+        else
+            start = (start + 1) % maxSize
+        data[(start + size - 1) % maxSize] = item
+    }
+
+    @Suppress("unused")
+    fun addAll(vararg items: T) {
+        for (i in items) add(i)
+    }
+
+    @Suppress("unused")
+    fun addAll(elements: Iterable<T>) {
+        elements.forEach { add(it) }
+    }
+
+    @Suppress("unused")
+    fun clear() {
+        start = 0
+        size = 0
+        for (i in data.indices) {
+            data[i] = null
+        }
+    }
+
+    override fun iterator(): Iterator<T> =
+        object : Iterator<T> {
+            private var i = 0
+
+            override fun hasNext(): Boolean = i < size
+
+            override fun next(): T {
+                if (!hasNext()) throw NoSuchElementException()
+
+                @Suppress("UNCHECKED_CAST")
+                return data[(start + i++) % maxSize] as T
+            }
+        }
+}
+
+
+class ObjRingBuffer(val capacity: Int) : Obj() {
+    val buffer = RingBuffer<Obj>(capacity)
+
+    override val objClass: ObjClass = type
+
+    override suspend fun plusAssign(scope: Scope, other: Obj): Obj {
+        buffer.add(other.byValueCopy())
+        return this
+    }
+
+    companion object {
+        val type = object : ObjClass("RingBuffer", ObjIterable) {
+            override suspend fun callOn(scope: Scope): Obj {
+                return ObjRingBuffer(scope.requireOnlyArg<ObjInt>().toInt())
+            }
+        }.apply {
+            addFn("capacity") {
+                thisAs<ObjRingBuffer>().capacity.toObj()
+            }
+            addFn("size") {
+                thisAs<ObjRingBuffer>().buffer.size.toObj()
+            }
+            addFn("iterator") {
+                val buffer = thisAs<ObjRingBuffer>().buffer
+                ObjKotlinObjIterator(buffer.iterator())
+            }
+            addFn("add") {
+                thisAs<ObjRingBuffer>().apply { buffer.add(requireOnlyArg<Obj>()) }
+            }
+        }
+    }
+}

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

@@ -1,4 +1,9 @@
-package net.sergeych.lyng
+package net.sergeych.lyng.obj
+
+import net.sergeych.lyng.Scope
+import net.sergeych.lynon.LynonDecoder
+import net.sergeych.lynon.LynonEncoder
+import net.sergeych.lynon.LynonType
 
 class ObjSet(val set: MutableSet<Obj> = mutableSetOf()) : Obj() {
 
@@ -65,6 +70,25 @@ class ObjSet(val set: MutableSet<Obj> = mutableSetOf()) : Obj() {
         }
     }
 
+    override fun hashCode(): Int {
+        return set.hashCode()
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || this::class != other::class) return false
+
+        other as ObjSet
+
+        return set == other.set
+    }
+
+    override suspend fun lynonType(): LynonType = LynonType.Set
+
+    override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
+        encoder.encodeAnyList(scope, set.toList())
+    }
+
     companion object {
 
 
@@ -72,6 +96,9 @@ class ObjSet(val set: MutableSet<Obj> = mutableSetOf()) : Obj() {
             override suspend fun callOn(scope: Scope): Obj {
                 return ObjSet(scope.args.list.toMutableSet())
             }
+
+            override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj =
+                ObjSet(decoder.decodeAnyList(scope).toMutableSet())
         }.apply {
             addFn("size") {
                 thisAs<ObjSet>().set.size.toObj()

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

@@ -1,7 +1,12 @@
-package net.sergeych.lyng
+package net.sergeych.lyng.obj
 
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
+import net.sergeych.lyng.Scope
+import net.sergeych.lyng.statement
+import net.sergeych.lynon.LynonDecoder
+import net.sergeych.lynon.LynonEncoder
+import net.sergeych.lynon.LynonType
 import net.sergeych.sprintf.sprintf
 
 @Serializable
@@ -15,7 +20,6 @@ data class ObjString(val value: String) : Obj() {
 //        return i
 //    }
 
-
     override suspend fun compareTo(scope: Scope, other: Obj): Int {
         if (other !is ObjString) return -2
         return this.value.compareTo(other.value)
@@ -37,12 +41,12 @@ data class ObjString(val value: String) : Obj() {
     }
 
     override suspend fun getAt(scope: Scope, index: Obj): Obj {
-        if( index is ObjInt ) return ObjChar(value[index.toInt()])
-        if( index is ObjRange ) {
-            val start = if(index.start == null || index.start.isNull) 0 else  index.start.toInt()
-            val end = if( index.end  == null || index.end.isNull ) value.length else  {
+        if (index is ObjInt) return ObjChar(value[index.toInt()])
+        if (index is ObjRange) {
+            val start = if (index.start == null || index.start.isNull) 0 else index.start.toInt()
+            val end = if (index.end == null || index.end.isNull) value.length else {
                 val e = index.end.toInt()
-                if( index.isEndInclusive) e + 1 else e
+                if (index.isEndInclusive) e + 1 else e
             }
             return ObjString(value.substring(start, end))
         }
@@ -54,7 +58,10 @@ data class ObjString(val value: String) : Obj() {
     }
 
     override suspend fun callOn(scope: Scope): Obj {
-        return ObjString(this.value.sprintf(*scope.args.toKotlinList(scope).toTypedArray()))
+        return ObjString(this.value.sprintf(*scope.args
+            .toKotlinList(scope)
+            .map { if (it == null) "null" else it }
+            .toTypedArray()))
     }
 
     override suspend fun contains(scope: Scope, other: Obj): Boolean {
@@ -74,10 +81,21 @@ data class ObjString(val value: String) : Obj() {
         return value == other.value
     }
 
+    override suspend fun lynonType(): LynonType = LynonType.String
+
+    override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
+        encoder.encodeBinaryData(value.encodeToByteArray())
+    }
+
     companion object {
-        val type = ObjClass("String").apply {
+        val type = object : ObjClass("String") {
+            override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj =
+                ObjString(decoder.unpackBinaryData().decodeToString())
+        }.apply {
             addFn("toInt") {
-                ObjInt(thisAs<ObjString>().value.toLong())
+                ObjInt(thisAs<ObjString>().value.toLongOrNull()
+                    ?: raiseIllegalArgument("can't convert to int: $thisObj")
+                )
             }
             addFn("startsWith") {
                 ObjBool(thisAs<ObjString>().value.startsWith(requiredArg<ObjString>(0).value))
@@ -114,8 +132,16 @@ data class ObjString(val value: String) : Obj() {
             addFn("upper") {
                 thisAs<ObjString>().value.uppercase().let(::ObjString)
             }
+            addFn("characters") {
+                ObjList(
+                    thisAs<ObjString>().value.map { ObjChar(it) }.toMutableList()
+                )
+            }
+            addFn("encodeUtf8") { ObjBuffer(thisAs<ObjString>().value.encodeToByteArray().asUByteArray()) }
             addFn("size") { ObjInt(thisAs<ObjString>().value.length.toLong()) }
-            addFn("toReal") { ObjReal(thisAs<ObjString>().value.toDouble())}
+            addFn("toReal") {
+                ObjReal(thisAs<ObjString>().value.toDouble())
+            }
         }
     }
 }

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

@@ -0,0 +1,141 @@
+package net.sergeych.lyng.pacman
+
+import net.sergeych.lyng.*
+import net.sergeych.synctools.ProtectedOp
+import net.sergeych.synctools.withLock
+
+/**
+ * Import manager allow to register packages with builder lambdas and act as an
+ * [ImportProvider]. Note that packages _must be registered_ first with [addPackage],
+ * [addSourcePackages] or [addTextPackages]. Registration is cheap, actual package
+ * building is lazily performed on [createModuleScope], when the package will
+ * be first imported.
+ *
+ * It is possible to register new packages at any time, but it is not allowed to override
+ * packages already registered.
+ */
+class ImportManager(
+    rootScope: Scope = Script.defaultImportManager.newModule(),
+    securityManager: SecurityManager = SecurityManager.allowAll
+) : ImportProvider(rootScope, securityManager) {
+
+    val packageNames: List<String> get() = imports.keys.toList()
+
+    private inner class Entry(
+        val packageName: String,
+        val builder: suspend (ModuleScope) -> Unit,
+        var cachedScope: ModuleScope? = null
+    ) {
+
+        suspend fun getScope(pos: Pos): ModuleScope {
+            cachedScope?.let { return it }
+            return ModuleScope(inner, pos, packageName).apply {
+                cachedScope = this
+                builder(this)
+            }
+        }
+    }
+
+
+    /**
+     * Inner provider does not lock [op], the only difference; it is meant to be used
+     * exclusively by the coroutine that starts actual import chain
+     */
+    private inner class InternalProvider : ImportProvider(rootScope) {
+        override suspend fun createModuleScope(pos: Pos, packageName: String): ModuleScope {
+            return doImport(packageName, pos)
+        }
+
+        override fun getActualProvider(): ImportProvider {
+            return this@ImportManager
+        }
+    }
+
+    /**
+     * Inner module import provider used to prepare lazily prepared modules
+     */
+    private val inner = InternalProvider()
+
+
+    private val imports = mutableMapOf<String, Entry>()
+
+    val op = ProtectedOp()
+
+
+    /**
+     * Register new package that can be imported. It is not possible to unregister or
+     * update package already registered.
+     *
+     * Packages are lazily created when first imported somewhere, so the registration is
+     * cheap; the recommended procedure is to register all available packages prior to
+     * compile with this.
+     *
+     * @param name package name
+     * @param builder lambda to create actual package using the given [ModuleScope]
+     */
+    fun addPackage(name: String, builder: suspend (ModuleScope) -> Unit) {
+        op.withLock {
+            if (name in imports)
+                throw IllegalArgumentException("Package $name already exists")
+            imports[name] = Entry(name, builder)
+        }
+    }
+
+    /**
+     * Bulk [addPackage] with slightly better performance
+     */
+    @Suppress("unused")
+    fun addPackages(registrationData: List<Pair<String, suspend (ModuleScope) -> Unit>>) {
+        op.withLock {
+            for (pp in registrationData) {
+                if (pp.first in imports)
+                    throw IllegalArgumentException("Package ${pp.first} already exists")
+                imports[pp.first] = Entry(pp.first, pp.second)
+            }
+        }
+    }
+
+    /**
+     * Perform actual import or return ready scope. __It must only be called when
+     * [op] is locked__, e.g. only internally
+     */
+    private suspend fun doImport(packageName: String, pos: Pos): ModuleScope {
+        val entry = imports[packageName] ?: throw ImportException(pos, "package not found: $packageName")
+        return entry.getScope(pos)
+    }
+
+    override suspend fun createModuleScope(pos: Pos, packageName: String): ModuleScope =
+        doImport(packageName, pos)
+
+    /**
+     * Add packages that only need to compile [Source].
+     */
+    fun addSourcePackages(vararg sources: Source) {
+        for (s in sources) {
+            addPackage(s.extractPackageName()) {
+                it.eval(s)
+            }
+
+        }
+    }
+
+    /**
+     * Add source packages using package name as [Source.fileName], for simplicity
+     */
+    fun addTextPackages(vararg sourceTexts: String) {
+        for (s in sourceTexts) {
+            var source = Source("tmp", s)
+            val packageName = source.extractPackageName()
+            source = Source(packageName, s)
+            addPackage(packageName) { it.eval(source) }
+        }
+    }
+
+    fun copy(): ImportManager =
+        op.withLock {
+            ImportManager(rootScope, securityManager).apply {
+                imports.putAll(this@ImportManager.imports)
+            }
+        }
+
+}

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

@@ -0,0 +1,61 @@
+package net.sergeych.lyng.pacman
+
+import net.sergeych.lyng.*
+import net.sergeych.mptools.CachedExpression
+
+/**
+ * Package manager INTERFACE (abstract class). Performs import routines
+ * using abstract [createModuleScope] method ot be implemented by heirs.
+ *
+ * Notice that [createModuleScope] is responsible for caching the modules;
+ * base class relies on caching. This is not implemented here as the correct
+ * caching strategy depends on the import provider
+ */
+abstract class ImportProvider(
+    val rootScope: Scope,
+    val securityManager: SecurityManager = SecurityManager.allowAll
+) {
+
+    open fun getActualProvider() = this
+
+    /**
+     * Find an import and create a scope for it. This method must implement caching so repeated
+     * imports are not repeatedly loaded and parsed and should be cheap.
+     *
+     * @throws ImportException if the module is not found
+     */
+    abstract suspend fun createModuleScope(pos: Pos,packageName: String): ModuleScope
+
+    /**
+     * Check that the import is possible and allowed. This method is called on compile time by [Compiler];
+     * actual module loading is performed by [ModuleScope.importInto]
+     */
+    suspend fun prepareImport(pos: Pos, name: String, symbols: Map<String, String>?): ModuleScope {
+        if (!securityManager.canImportModule(name))
+            throw ImportException(pos, "Module $name is not allowed")
+        symbols?.keys?.forEach {
+            if (!securityManager.canImportSymbol(name, it)) throw ImportException(
+                pos,
+                "Symbol $name.$it is not allowed"
+            )
+        }
+        return createModuleScope(pos, name)
+    }
+
+    fun newModule() = newModuleAt(Pos.builtIn)
+
+    fun newModuleAt(pos: Pos): ModuleScope =
+        ModuleScope(this, pos, "unknown")
+
+    private var cachedStdScope = CachedExpression<Scope>()
+
+    suspend fun newStdScope(pos: Pos = Pos.builtIn): Scope =
+        cachedStdScope.get {
+            newModuleAt(pos).also {
+                it.eval("import lyng.stdlib\n")
+            }
+        }.copy()
+}
+
+
+

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

@@ -0,0 +1,35 @@
+package net.sergeych.lyng.pacman
+
+import kotlinx.coroutines.CompletableDeferred
+import net.sergeych.lyng.*
+import net.sergeych.mp_tools.globalLaunch
+
+/**
+ * The sample import provider that imports sources available in memory.
+ * on construction time.
+ *
+ * Actually it is left here only as a demo.
+ */
+class InlineSourcesImportProvider(sources: List<Source>,
+                                  rootScope: ModuleScope = Script.defaultImportManager.newModule(),
+                                  securityManager: SecurityManager = SecurityManager.allowAll
+) : ImportProvider(rootScope) {
+
+    private val manager = ImportManager(rootScope, securityManager)
+
+    private val readyManager = CompletableDeferred<ImportManager>()
+
+    /**
+     * This implementation only
+     */
+    override suspend fun createModuleScope(pos: Pos, packageName: String): ModuleScope {
+        return readyManager.await().createModuleScope(pos, packageName)
+    }
+
+    init {
+        globalLaunch {
+            manager.addSourcePackages(*sources.toTypedArray())
+            readyManager.complete(manager)
+        }
+    }
+}

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

@@ -1,17 +1,24 @@
 package net.sergeych.lyng
 
+import net.sergeych.lyng.obj.Obj
+import net.sergeych.lyng.obj.ObjClass
+import net.sergeych.lyng.obj.ObjVoid
+
 fun String.toSource(name: String = "eval"): Source = Source(name, this)
 
 sealed class ObjType {
     object Any : ObjType()
-    object Int : ObjType()
+    object Void: ObjType()
+
+    companion object {
+    }
 }
 
 
 @Suppress("unused")
 abstract class Statement(
     val isStaticConst: Boolean = false,
-    val isConst: Boolean = false,
+    override val isConst: Boolean = false,
     val returnType: ObjType = ObjType.Any
 ) : Obj() {
 
@@ -59,4 +66,8 @@ fun statement(isStaticConst: Boolean = false, isConst: Boolean = false, f: suspe
         override suspend fun execute(scope: Scope): Obj = f(scope)
     }
 
+object NopStatement: Statement(true, true, ObjType.Void) {
+    override val pos: Pos = Pos.builtIn
 
+    override suspend fun execute(scope: Scope): Obj = ObjVoid
+}

lynglib/src/commonMain/kotlin/net/sergeych/lyng/stdlib_included/root_lyng.kt

@@ -0,0 +1,58 @@
+package net.sergeych.lyng.stdlib_included
+internal val rootLyng = """
+package lyng.stdlib
+    
+fun Iterable.filter(predicate) {
+    val list = this
+    flow {
+        for( item in list ) {
+            if( predicate(item) ) {
+                emit(item)
+            }
+        }
+    }
+}
+
+fun Iterable.drop(n) {
+    var cnt = 0
+    filter { cnt++ >= n }
+}
+
+fun Iterable.first() {
+    val i = iterator()
+    if( !i.hasNext() ) throw NoSuchElementException()
+    i.next()
+}
+
+fun Iterable.last() {
+    var found = false
+    var element = null
+    for( i in this ) {
+        element = i
+        found = true
+    }
+    if( !found ) throw NoSuchElementException()
+    element
+}
+
+fun Iterable.dropLast(n) {
+    val list = this
+    val buffer = RingBuffer(n)
+    flow {
+        for( item in list ) {
+            if( buffer.size == n ) 
+                emit( buffer.first() )
+            buffer += item
+        }
+    }
+}
+
+fun Iterable.takeLast(n) {
+    val list = this
+    val buffer = RingBuffer(n)
+    for( item in list ) buffer += item
+    buffer
+}
+    
+""".trimIndent()
+

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

@@ -0,0 +1,13 @@
+package net.sergeych.lyng
+
+fun leftMargin(s: String): Int {
+    var cnt = 0
+    for (c in s) {
+        when (c) {
+            ' ' -> cnt++
+            '\t' -> cnt = (cnt / 4.0 + 0.9).toInt() * 4
+            else -> break
+        }
+    }
+    return cnt
+}

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

@@ -0,0 +1,90 @@
+package net.sergeych.lynon
+
+interface BitInput {
+
+
+    fun getBitOrNull(): Int?
+
+    fun getBitsOrNull(count: Int): ULong? {
+        var result = 0UL
+        var resultMask = 1UL
+        for( i in 0 ..< count) {
+            when(getBitOrNull()) {
+                null -> return null
+                1 -> result = result or resultMask
+                0 -> {}
+            }
+            resultMask = resultMask shl 1
+        }
+        return result
+    }
+
+    fun getBits(count: Int): ULong {
+        return getBitsOrNull(count) ?: throw IllegalStateException("Unexpected end of stream")
+    }
+
+    fun getBit(): Int {
+        return getBitOrNull() ?: throw IllegalStateException("Unexpected end of stream")
+    }
+
+    fun unpackUnsigned(): ULong =
+        unpackUnsignedOrNull() ?: throw IllegalStateException("Unexpected end of stream")
+
+    fun unpackUnsignedOrNull(): ULong? {
+        val tetrades = getBitsOrNull(4)?.toInt() ?: return null
+        var result = 0UL
+        var shift = 0
+        for (i in 0.. tetrades) {
+            result = result or (getBits(4) shl shift)
+            shift += 4
+        }
+        return result
+    }
+
+    fun unpackSigned(): Long {
+        val isNegative = getBit()
+        val value = unpackUnsigned().toLong()
+        return if( isNegative == 1) -value else value
+    }
+
+    @Suppress("unused")
+    fun getBool(): Boolean {
+        return getBit() == 1
+    }
+
+    fun getBytes(count: Int): ByteArray? {
+        val result = ByteArray(count)
+        for (i in 0..<count) {
+            val b = getBitsOrNull(8) ?: return null
+            result[i] = b.toByte()
+        }
+        return result
+    }
+
+
+    fun decompress(): ByteArray = decompressOrNull() ?: throw DecompressionException("Unexpected end of stream")
+
+    fun decompressOrNull(): ByteArray? {
+        val originalSize = unpackUnsignedOrNull()?.toInt() ?: return null
+        return if( getBit() == 1) {
+            // data is compressed
+//            val expectedCRC = getBits(32).toUInt()
+            val method = getBits(2).toInt()
+            if( method != 0) throw DecompressionException("Unknown compression method")
+            LZW.decompress(this, originalSize).asByteArray()
+        }
+        else {
+            getBytes(originalSize) ?: throw DecompressionException("Unexpected end of stream in uncompressed data")
+        }
+    }
+
+    @Suppress("unused")
+    fun decompressStringOrNull(): String? = decompressOrNull()?.decodeToString()
+
+    fun decompressString(): String = decompress().decodeToString()
+    fun unpackDouble(): Double {
+        val bits = getBits(64)
+        return Double.fromBits(bits.toLong())
+    }
+}
+

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

@@ -0,0 +1,34 @@
+package net.sergeych.lynon
+
+@Suppress("unused")
+interface BitList {
+    operator fun get(bitIndex: Long): Int
+    operator fun set(bitIndex: Long,value: Int)
+    val size: Long
+    val indices: LongRange
+
+    fun toInput(): BitInput = object : BitInput {
+        private var index = 0L
+
+        override fun getBitOrNull(): Int? =
+            if( index < size) this@BitList[index++]
+            else null
+    }
+}
+
+fun bitListOf(vararg bits: Int): BitList {
+    return if( bits.size > 64) {
+        BitArray.ofBits(*bits)
+    }
+    else
+        TinyBits.of(*bits)
+}
+
+@Suppress("unused")
+fun bitListOfSize(sizeInBits: Long): BitList {
+    return if( sizeInBits > 64) {
+        BitArray.withBitSize(sizeInBits)
+    }
+    else
+        TinyBits()
+}

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

@@ -0,0 +1,104 @@
+package net.sergeych.lynon
+
+interface BitOutput {
+
+    fun putBits(bits: ULong, count: Int) {
+        require(count <= 64)
+        var x = bits
+        for (i in 0..<count) {
+            putBit((x and 1u).toInt())
+            x = x shr 1
+        }
+    }
+
+    fun putBits(bits: Int, count: Int) {
+        require(count <= 32)
+        var x = bits
+        for (i in 0..<count) {
+            putBit((x and 1))
+            x = x shr 1
+        }
+    }
+
+    fun putBit(bit: Int)
+
+    fun putBits(bitList: BitList) {
+        for (i in bitList.indices)
+            putBit(bitList[i])
+    }
+
+    fun packUnsigned(value: ULong) {
+        val tetrades = sizeInTetrades(value)
+        putBits(tetrades - 1, 4)
+        var rest = value
+        for (i in 0..<tetrades) {
+            putBits(rest and 0xFu, 4)
+            rest = rest shr 4
+        }
+    }
+
+    @Suppress("unused")
+    fun packSigned(value: Long) {
+        if (value < 0) {
+            putBit(1)
+            packUnsigned((-value).toULong())
+        } else {
+            putBit(0)
+            packUnsigned(value.toULong())
+        }
+    }
+
+    fun putBytes(data: ByteArray) {
+        for (b in data) {
+            putBits(b.toULong(), 8)
+        }
+    }
+
+
+    /**
+     * Create compressed record with content and size check. Compression works with _bytes_.
+     *
+     * Structure:
+     *
+     * | size | meaning                                          |
+     * |------|--------------------------------------------------|
+     * | packed unsigned | size of uncompressed content in bytes |
+     * | 1               | 0 - not compressed, 1 - compressed |
+     *
+     * __If compressed__, then:
+     *
+     * | size | meaning                              |
+     * |------|--------------------------------------|
+     * |  2   | 00 - LZW, other combinations reserved|
+     *
+     * After this header compressed bits follow.
+     *
+     * __If not compressed,__ then source data follows as bit stream.
+     *
+     * Compressed block overhead is 3 bits, uncompressed 1.
+     */
+    fun compress(source: ByteArray) {
+        // size
+        packUnsigned(source.size.toULong())
+        // check compression is effective?
+        val compressed = LZW.compress(source.asUByteArray())
+        // check that compression is effective including header bits size:
+        if( compressed.size + 2 < source.size * 8L) {
+            println("write compressed")
+            putBit(1)
+            // LZW algorithm
+            putBits(0, 2)
+            // compressed data
+            putBits(compressed)
+        }
+        else {
+            putBit(0)
+            putBytes(source)
+        }
+    }
+
+    fun compress(source: String) {
+        compress(source.encodeToByteArray())
+    }
+
+}

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

@@ -0,0 +1,3 @@
+package net.sergeych.lynon
+
+class DecompressionException(message: String) : IllegalArgumentException(message) {}

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

@@ -0,0 +1,106 @@
+package net.sergeych.lynon
+
+import net.sergeych.lyng.Scope
+import net.sergeych.lyng.obj.Obj
+import net.sergeych.lyng.obj.ObjClass
+import net.sergeych.lyng.obj.ObjString
+
+open class LynonDecoder(val bin: BitInput, val settings: LynonSettings = LynonSettings.default) {
+
+    fun getBitsAsInt(bitsSize: Int): Int {
+        return bin.getBits(bitsSize).toInt()
+    }
+
+    fun unpackUnsignedInt(): Int = bin.unpackUnsigned().toInt()
+
+    fun decompress() = bin.decompress()
+
+    val cache = mutableListOf<Any>()
+
+
+    inline fun <reified T : Any> decodeCached(f: LynonDecoder.() -> T): T {
+        return if (bin.getBit() == 0) {
+            // unpack and cache
+            f().also {
+//                println("decode: cache miss: ${cache.size}: $it:${it::class.simpleName}")
+                if (settings.shouldCache(it)) cache.add(it)
+            }
+        } else {
+            // get cache reference
+            val size = sizeInBits(cache.size)
+            val id = bin.getBitsOrNull(size)?.toInt()
+                ?: throw RuntimeException("Invalid object id: unexpected end of stream")
+            if (id >= cache.size) throw RuntimeException("Invalid object id: $id should be in 0..<${cache.size}")
+//            println("decode: cache hit ${id}: ${cache[id]}:${cache[id]::class.simpleName}")
+//            @Suppress("UNCHECKED_CAST")
+            cache[id] as T
+        }
+    }
+
+    suspend fun decodeAny(scope: Scope): Obj = decodeCached {
+        val type = LynonType.entries[bin.getBits(4).toInt()]
+        if (type != LynonType.Other) {
+            type.objClass.deserialize(scope, this, type)
+        } else {
+            decodeClassObj(scope).deserialize(scope, this, null)
+        }
+    }
+
+    private suspend fun decodeClassObj(scope: Scope): ObjClass {
+        val className = decodeObject(scope, ObjString.type, null) as ObjString
+        println("expected class name $className")
+        return scope.get(className.value)?.value?.let {
+            if (it !is ObjClass)
+                scope.raiseClassCastError("Expected obj class but got ${it::class.simpleName}")
+            it
+        } ?: scope.raiseSymbolNotFound("can't deserialize: not found type $className")
+    }
+
+    suspend fun decodeAnyList(scope: Scope,fixedSize: Int?=null): MutableList<Obj> {
+        return if (bin.getBit() == 1) {
+            // homogenous
+            val type = LynonType.entries[getBitsAsInt(4)]
+            val list = mutableListOf<Obj>()
+            val objClass = if (type == LynonType.Other)
+                decodeClassObj(scope).also { println("detected class obj: $it") }
+            else type.objClass
+            val size = fixedSize ?: bin.unpackUnsigned().toInt()
+            println("detected homogenous list type $type, $size items")
+            for (i in 0..<size) {
+                list += decodeObject(scope, objClass, type).also {
+                    println("decoded: $it")
+                }
+            }
+            list
+        } else {
+            val size = fixedSize ?: unpackUnsigned().toInt()
+            (0..<size).map { decodeAny(scope) }.toMutableList()
+        }
+    }
+
+    suspend fun decodeObject(scope: Scope, type: ObjClass, overrideType: LynonType? = null): Obj {
+        return decodeCached { type.deserialize(scope, this, overrideType) }
+    }
+
+    fun unpackBinaryData(): ByteArray = bin.decompress()
+
+    @Suppress("unused")
+    fun unpackBinaryDataOrNull(): ByteArray? = bin.decompressOrNull()
+
+    fun unpackBoolean(): Boolean {
+        return bin.getBit() == 1
+    }
+
+    fun unpackDouble(): Double {
+        return Double.fromBits(bin.getBits(64).toLong())
+    }
+
+    fun unpackSigned(): Long {
+        return bin.unpackSigned()
+    }
+
+    fun unpackUnsigned(): ULong {
+        return bin.unpackUnsigned()
+    }
+
+}

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

@@ -0,0 +1,194 @@
+package net.sergeych.lynon
+
+import net.sergeych.bintools.ByteChunk
+import net.sergeych.lyng.Scope
+import net.sergeych.lyng.obj.*
+
+enum class LynonType(val objClass: ObjClass, val defaultFrequency: Int = 1) {
+    Null(ObjNull.objClass, 80),
+    Int0(ObjInt.type, 70),
+    IntNegative(ObjInt.type, 50),
+    IntPositive(ObjInt.type, 100),
+    IntSigned(ObjInt.type, 30),
+    String(ObjString.type, 100),
+    Real(ObjReal.type),
+    Bool(ObjBool.type, 80),
+    List(ObjList.type, 70),
+    Map(ObjMap.type, 40),
+    Set(ObjSet.type),
+    Buffer(ObjBuffer.type, 50),
+    Instant(ObjInstant.type, 30),
+    Duration(ObjDuration.type),
+    Other(Obj.rootObjectType, 60);
+
+    fun generalizeTo(other: LynonType): LynonType? {
+        if (this == other) return this
+        return (if (this.isInt && other.isInt) {
+            when {
+                this == Int0 -> other // upgrade 0 to some other int
+                other == Int0 -> this // 0 is member of our class, ignore
+                // different signum propagate to signed
+                else -> IntSigned
+            }
+        } else
+        // impossible to generalize
+            null
+                ).also { println("Gen $this + $other -> $it") }
+    }
+
+    val isInt by lazy {
+        when (this) {
+            Int0, IntSigned, IntPositive, IntNegative -> true
+            else -> false
+        }
+    }
+
+}
+
+open class LynonEncoder(val bout: BitOutput, val settings: LynonSettings = LynonSettings.default) {
+
+    val cache = mutableMapOf<Any, Int>()
+
+    suspend fun encodeCached(item: Any, packer: suspend LynonEncoder.() -> Unit) {
+
+        suspend fun serializeAndCache(key: Any = item) {
+            cache[key]?.let { cacheId ->
+//                println("encode: Cache hit: ${cacheId}: $item: ${item::class.simpleName}")
+                val size = sizeInBits(cache.size)
+                bout.putBit(1)
+                bout.putBits(cacheId.toULong(), size)
+            } ?: run {
+                bout.putBit(0)
+                if (settings.shouldCache(item)) {
+//                    println("encode add cache: ${cache.size}: $item: ${item::class.simpleName}")
+                    packer()
+                    cache[key] = cache.size
+                } else {
+//                    println("encode but not cache $item")
+                    packer()
+                }
+            }
+        }
+
+        when (item) {
+            is ByteArray -> serializeAndCache(ByteChunk(item.asUByteArray()))
+            is UByteArray -> serializeAndCache(ByteChunk(item))
+            else -> serializeAndCache(item)
+        }
+    }
+
+    /**
+     * Encode any Lyng object [Obj], which can be serialized, using type record. This allow to
+     * encode any object with the overhead of type record.
+     *
+     * Caching is used automatically.
+     */
+    suspend fun encodeAny(scope: Scope, obj: Obj) {
+        encodeCached(obj) {
+            val type = putTypeRecord(scope, obj, obj.lynonType())
+            obj.serialize(scope, this, type)
+        }
+    }
+
+    private suspend fun putTypeRecord(scope: Scope, obj: Obj, type: LynonType): LynonType {
+        putType(type)
+        if( type == LynonType.Other) {
+            encodeObject(scope, obj.objClass.classNameObj)
+        }
+        return type
+    }
+
+    private fun putType(type: LynonType) {
+        bout.putBits(type.ordinal.toULong(), 4)
+    }
+
+    /**
+     * AnyList could be homogenous (first bit=1) and heterogeneous (first bit=0). Homogenous list
+     * has a single type record that precedes the list, heterogeneous hash typed record
+     * for each item.
+     *
+     */
+    suspend fun encodeAnyList(scope: Scope, list: List<Obj>,fixedSize: Boolean = false) {
+        if( list.isEmpty()) {
+            // any-typed, empty, save space
+            putBit(0)
+            encodeUnsigned(0u)
+        }
+        else {
+            val objClass = list[0].objClass
+            var type = list[0].lynonType()
+            var isHomogeneous = true
+            for (i in list.drop(1))
+                if (i.objClass != objClass) {
+                    isHomogeneous = false
+                    break
+                } else {
+                    // same class but type might need generalization
+                    type = type.generalizeTo(i.lynonType())
+                        ?: scope.raiseError("inner error: can't generalize lynon type $type to ${i.lynonType()}")
+                }
+            if (isHomogeneous) {
+                putBit(1)
+                putTypeRecord(scope, list[0], type)
+                if (!fixedSize)
+                    encodeUnsigned(list.size.toULong())
+                for (i in list) encodeObject(scope, i, type)
+            } else {
+                putBit(0)
+                if (!fixedSize)
+                    encodeUnsigned(list.size.toULong())
+                for (i in list) encodeAny(scope, i)
+            }
+        }
+    }
+
+    /**
+     * Write object _with no type record_: type is known
+     */
+    suspend fun encodeObject(scope: Scope, obj: Obj,overrideType: LynonType? = null) {
+        encodeCached(obj) {
+            obj.serialize(scope, this, overrideType)
+        }
+    }
+
+    suspend fun encodeCachedBytes(bytes: ByteArray) {
+        encodeCached(bytes) {
+            bout.compress(bytes)
+        }
+    }
+
+    fun encodeBinaryData(data: ByteArray) {
+        bout.compress(data)
+    }
+
+    fun encodeSigned(value: Long) {
+        bout.packSigned(value)
+    }
+
+    @Suppress("unused")
+    fun encodeUnsigned(value: ULong) {
+        bout.packUnsigned(value)
+    }
+
+    @Suppress("unused")
+    fun encodeBool(value: Boolean) {
+        bout.putBit(if (value) 1 else 0)
+    }
+
+    fun encodeReal(value: Double) {
+        bout.putBits(value.toRawBits().toULong(), 64)
+    }
+
+    fun encodeBoolean(value: Boolean) {
+        bout.putBit(if (value) 1 else 0)
+    }
+
+    fun putBits(value: Int, sizeInBits: Int) {
+        bout.putBits(value.toULong(), sizeInBits)
+    }
+
+    fun putBit(bit: Int) {
+        bout.putBit(bit)
+    }
+
+}

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

@@ -0,0 +1,29 @@
+package net.sergeych.lynon
+
+import net.sergeych.lyng.obj.ObjBool
+import net.sergeych.lyng.obj.ObjChar
+import net.sergeych.lyng.obj.ObjInt
+import net.sergeych.lyng.obj.ObjNull
+import kotlin.math.absoluteValue
+
+open class LynonSettings {
+    enum class InstantTruncateMode {
+        Second,
+        Millisecond,
+        Microsecond
+    }
+
+    open fun shouldCache(obj: Any): Boolean = when (obj) {
+        is ObjChar -> false
+        is ObjInt -> obj.value.absoluteValue > 0x10000FF
+        is ObjBool -> false
+        is ObjNull -> false
+        is ByteArray -> obj.size > 2
+        is UByteArray -> obj.size > 2
+        else -> true
+    }
+
+    companion object {
+        val default = LynonSettings()
+    }
+}

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

@@ -0,0 +1,40 @@
+package net.sergeych.lynon
+
+
+class MemoryBitInput(val packedBits: UByteArray, val lastByteBits: Int) : BitInput {
+
+    constructor(ba: BitArray) : this(ba.bytes, ba.lastByteBits) {}
+    constructor(mba: MemoryBitOutput) : this(mba.toBitArray()) {}
+
+    private var index = 0
+
+    private var isEndOfStream: Boolean = packedBits.isEmpty() || (packedBits.size == 1 && lastByteBits == 0)
+        private set
+
+    /**
+     * Return next byte, int in 0..255 range, or -1 if end of stream reached
+     */
+    private var accumulator = if( isEndOfStream ) 0 else packedBits[0].toInt()
+
+    private var bitCounter = 0
+
+    override fun getBitOrNull(): Int? {
+        if (isEndOfStream) return null
+        val result = accumulator and 1
+        accumulator = accumulator shr 1
+        bitCounter++
+        // is end?
+        if( index == packedBits.lastIndex && bitCounter == lastByteBits ) {
+            isEndOfStream = true
+        }
+        else {
+            if( bitCounter == 8 ) {
+                bitCounter = 0
+                accumulator = packedBits[++index].toInt()
+            }
+        }
+        return result
+    }
+
+
+}

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

@@ -0,0 +1,157 @@
+package net.sergeych.lynon
+
+import kotlin.math.min
+
+/**
+ * BitList implementation as fixed suze array of bits; indexing works exactly same as if
+ * [MemoryBitInput] is used with [MemoryBitInput.getBit]. See [MemoryBitOutput] for
+ * bits order and more information.
+ */
+class BitArray(val bytes: UByteArray, val lastByteBits: Int) : BitList {
+
+    val bytesSize: Int get() = bytes.size
+
+    override val size by lazy { bytes.size * 8L - (8 - lastByteBits) }
+
+    override val indices by lazy { 0..<size }
+
+    /**
+     * @return [BitInput] that can be used to read from this array
+     */
+    fun toBitInput(): BitInput = MemoryBitInput(bytes, lastByteBits)
+
+    private fun getIndexAndMask(bitIndex: Long): Pair<Int, Int> {
+        val byteIndex = (bitIndex / 8).toInt()
+        if (byteIndex !in bytes.indices)
+            throw IndexOutOfBoundsException("$bitIndex is out of bounds")
+        val i = (bitIndex % 8).toInt()
+        if (byteIndex == bytes.lastIndex && i >= lastByteBits)
+                throw IndexOutOfBoundsException("$bitIndex is out of bounds (last)")
+        return byteIndex to (1 shl i)
+    }
+
+    override operator fun get(bitIndex: Long): Int =
+        getIndexAndMask(bitIndex).let { (byteIndex, mask) ->
+            if (bytes[byteIndex].toInt() and mask == 0) 0 else 1
+        }
+
+    override operator fun set(bitIndex: Long, value: Int) {
+        require(value == 0 || value == 1)
+        val (byteIndex, mask) = getIndexAndMask(bitIndex)
+        if (value == 1)
+            bytes[byteIndex] = bytes[byteIndex] or mask.toUByte()
+        else
+            bytes[byteIndex] = bytes[byteIndex] and mask.inv().toUByte()
+    }
+
+    override fun toString(): String {
+        val result = StringBuilder()
+        val s = min(size, 64)
+        for (i in 0..<s) result.append(this[i])
+        if (s < size) result.append("…")
+        return result.toString()
+    }
+
+    @Suppress("unused")
+    fun asByteArray(): ByteArray = bytes.asByteArray()
+
+    @Suppress("unused")
+    fun asUbyteArray(): UByteArray = bytes
+
+    companion object {
+
+        fun withBitSize(size: Long): BitArray {
+            val byteSize = ((size + 7) / 8).toInt()
+            val lastByteBits = size % 8
+            return BitArray(UByteArray(byteSize), lastByteBits.toInt())
+        }
+
+        fun ofBits(vararg bits: Int): BitArray {
+            return withBitSize(bits.size.toLong()).apply {
+                for (i in bits.indices) {
+                    this[i.toLong()] = bits[i]
+                }
+            }
+        }
+    }
+
+}
+
+/**
+ * [BitOutput] implementation that writes to a memory buffer, LSB first.
+ *
+ * Bits are stored in the least significant bits of the bytes. E.g. the first bit
+ * added by [putBit] will be stored in the bit 0x01 of the first byte, the second bit
+ * in the bit 0x02 of the first byte, etc.
+ *
+ * This allows automatic fill of the last byte with zeros. This is important when
+ * using bytes stored from [asByteArray] or [asUbyteArray]. When converting to
+ * bytes, automatic padding to byte size is applied. With such bit order, constructing
+ * [BitInput] to read from [ByteArray.toUByteArray] result only provides 0 to 7 extra zeroes bits
+ * at teh end which is often acceptable. To avoid this, use [toBitArray]; the [BitArray]
+ * stores exact number of bits and [BitArray.toBitInput] provides [BitInput] that
+ * decodes exactly same bits.
+ *
+ */
+class MemoryBitOutput : BitOutput {
+    private val buffer = mutableListOf<UByte>()
+
+    private var accumulator = 0
+
+    private var mask = 1
+
+    override fun putBit(bit: Int) {
+        when (bit) {
+            0 -> {}
+            1 -> accumulator = accumulator or mask
+            else -> throw IllegalArgumentException("Bit must be 0 or 1")
+        }
+        mask = mask shl 1
+        if(mask == 0x100) {
+            mask = 1
+            outputByte(accumulator.toUByte())
+            accumulator = accumulator shr 8
+        }
+    }
+
+    var isClosed = false
+        private set
+
+    fun close(): BitArray {
+        if (!isClosed) {
+            if (mask != 0x01) {
+                outputByte(accumulator.toUByte())
+            }
+            isClosed = true
+        }
+        return toBitArray()
+    }
+
+    fun lastBits(): Int {
+        check(isClosed)
+        return when(mask) {
+            0x01 -> 8   // means that all bits of the last byte are in use
+            0x02 -> 1
+            0x04 -> 2
+            0x08 -> 3
+            0x10 -> 4
+            0x20 -> 5
+            0x40 -> 6
+            0x80 -> 7
+            else -> throw IllegalStateException("Invalid state, mask=${mask.toString(16)}")
+        }
+    }
+
+    fun toBitArray(): BitArray {
+        if (!isClosed) {
+            close()
+        }
+        return BitArray(buffer.toTypedArray().toUByteArray(), lastBits())
+    }
+
+    fun toBitInput(): BitInput = toBitArray().toBitInput()
+
+    private fun outputByte(byte: UByte) {
+        buffer.add(byte)
+    }
+}

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

@@ -0,0 +1,71 @@
+package net.sergeych.lynon
+
+
+/**
+ * Bit size-aware code, short [BitList] implementation, up to 64 bits (efficiency tradeoff).
+ * E.g `Bits(0, 3) != Bits(0, 2). For longer, use [BitArray].
+ *
+ * Note that [bitListOf] creates [TinyBits] when possible.
+ */
+class TinyBits(initValue: ULong = 0U, override val size: Long = 0): BitList {
+
+    private var bits: ULong = initValue
+
+    constructor(value: ULong, size: Int): this(value, size.toLong()) {}
+
+    override val indices: LongRange by lazy { 0..<size }
+
+    override operator fun get(bitIndex: Long): Int {
+        if( bitIndex !in indices) throw IndexOutOfBoundsException("index out of bounds: $bitIndex")
+        val mask = 1UL shl (size - bitIndex - 1).toInt()
+        return if (bits and mask != 0UL) 1 else 0
+    }
+
+    override fun set(bitIndex: Long, value: Int) {
+        val mask = 1UL shl (size - bitIndex - 1).toInt()
+        if( value == 1)
+            bits = bits or mask
+        else
+            bits = bits and mask.inv()
+    }
+
+    override fun toString(): String {
+        val result = StringBuilder()
+        for (i in 0..<size) result.append(this[i])
+        return result.toString()
+    }
+
+    val value by ::bits
+
+    /**
+     * Add bit shifting value to the left and return _new instance_
+     */
+    fun insertBit(bit: Int): TinyBits {
+        return TinyBits((bits shl 1) or bit.toULong(), size + 1)
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || this::class != other::class) return false
+
+        other as TinyBits
+
+        if (size != other.size) return false
+        if (bits != other.bits) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        var result = size.hashCode()
+        result = 31 * result + bits.hashCode()
+        return result
+    }
+
+
+    companion object {
+        fun of(vararg bits: Int): TinyBits {
+            return TinyBits(0UL, bits.size).apply { bits.forEachIndexed { i, v -> this[i.toLong()] = v } }
+        }
+    }
+}

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

@@ -0,0 +1,35 @@
+package net.sergeych.lynon
+
+/**
+ * Hoq many tetrades needed to store the value. It is faster to use this function
+ * than to use sizeInBits
+ *
+ * Size for 0 is 1
+ */
+fun sizeInTetrades(value: ULong): Int {
+    if( value == 0UL ) return 1
+    var size = 0
+    var rest = value
+    while( rest != 0UL ) {
+        size++
+        rest = rest shr 4
+    }
+    return size
+}
+
+/**
+ * How many bits needed to store the value. Size for 0 is 1,
+ */
+@Suppress("unused")
+fun sizeInBits(value: ULong): Int {
+    if( value == 0UL ) return 1
+    var size = 0
+    var rest = value
+    while( rest != 0UL ) {
+        size++
+        rest = rest shr 1
+    }
+    return size
+}
+
+fun sizeInBits(value: Int): Int = sizeInBits(value.toULong())

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

@@ -0,0 +1,274 @@
+package net.sergeych.lynon
+
+import net.sergeych.collections.SortedList
+import net.sergeych.lynon.Huffman.Alphabet
+
+
+/**
+ * Generic huffman encoding implementation using bits input/output and abstract [Alphabet].
+ */
+object Huffman {
+
+    /**
+     * Alphabet interface: source can be variable bit size codes, not just bytes,
+     * so the Huffman encoding is not limited to bytes. It works with any alphabet
+     * using its _ordinals_; encoding between source symbols and ordinals are
+     * performed by the alphabet. See [byteAlphabet] for example.
+     */
+    interface Alphabet<T> {
+        val maxOrdinal: Int
+
+        /**
+         * Write correct symbol for the [ordinal] to the [bout]. This is
+         * the inverse of [ordinalOf] but as [T] could be variable bit size,
+         * we provide output bit stream.
+         */
+        fun decodeOrdinalTo(bout: BitOutput, ordinal: Int)
+
+        /**
+         * Find the ordinal of the source symbol
+         */
+        fun ordinalOf(value: T): Int
+
+        operator fun get(ordinal: Int): T
+    }
+
+    /**
+     * Alphabet for unsigned bytes, allows to encode bytes easily
+     */
+    val byteAlphabet = object : Alphabet<UByte> {
+        override val maxOrdinal: Int
+            get() = 256
+
+        override fun decodeOrdinalTo(bout: BitOutput, ordinal: Int) {
+            bout.putBits(ordinal, 8)
+        }
+
+        override fun ordinalOf(value: UByte): Int = value.toInt()
+
+        override operator fun get(ordinal: Int): UByte = ordinal.toUByte()
+    }
+
+    sealed class Node(val freq: Int) : Comparable<Node> {
+        override fun compareTo(other: Node): Int {
+            return freq.compareTo(other.freq)
+        }
+
+        abstract fun decodeOrdinal(bin: BitInput): Int?
+
+        class Leaf(val ordinal: Int, freq: Int) : Node(freq) {
+            override fun toString(): String {
+                return "[$ordinal:$freq]"
+            }
+
+            override fun decodeOrdinal(bin: BitInput): Int {
+                return ordinal//.also { println(": ${Char(value)}") }
+            }
+        }
+
+        class Internal(val left: Node, val right: Node) : Node(left.freq + right.freq) {
+            override fun toString(): String {
+                return "[${left.freq}<- :<$freq>: ->${right.freq}]"
+            }
+
+            override fun decodeOrdinal(bin: BitInput): Int? {
+                return when (bin.getBitOrNull().also { print("$it") }) {
+                    1 -> left.decodeOrdinal(bin)
+                    0 -> right.decodeOrdinal(bin)
+                    else -> null
+                }
+            }
+        }
+    }
+
+    data class Code(val ordinal: Int, val bits: TinyBits) {
+
+        val size by bits::size
+
+        override fun toString(): String {
+            return "[$ordinal:$size:$bits]"
+        }
+
+    }
+
+    private fun generateCanonicCodes(tree: Node, alphabet: Alphabet<*>): List<Code?> {
+        val codes = MutableList<Code?>(alphabet.maxOrdinal) { null }
+
+        fun traverse(node: Node, code: TinyBits) {
+            when (node) {
+                is Node.Leaf ->
+                    codes[node.ordinal] = (Code(node.ordinal, code))
+
+                is Node.Internal -> {
+                    traverse(node.left, code.insertBit(1))
+                    traverse(node.right, code.insertBit(0))
+                }
+            }
+        }
+        traverse(tree, TinyBits())
+
+        return makeCanonical(codes, alphabet)
+    }
+
+    private fun makeCanonical(source: List<Code?>,alphabet: Alphabet<*>): List<Code?> {
+        val sorted = source.filterNotNull().sortedWith(canonicComparator)
+
+        val canonical = MutableList<Code?>(alphabet.maxOrdinal) { null }
+
+        val first = sorted[0]
+        val prevValue = first.copy(bits = TinyBits(0UL, first.bits.size))
+        canonical[first.ordinal] = prevValue
+        var prev = prevValue.bits
+
+        for (i in 1..<sorted.size) {
+            var bits = TinyBits(prev.value + 1U, prev.size)
+            val code = sorted[i]
+            while (code.bits.size > bits.size) {
+                bits = bits.insertBit(0)
+            }
+            canonical[code.ordinal] = code.copy(bits = bits)//.also { println("$it") }
+            prev = bits
+        }
+        return canonical
+    }
+
+    private val canonicComparator = { a: Code, b: Code ->
+        if (a.bits.size == b.bits.size) {
+            a.ordinal.compareTo(b.ordinal)
+        } else {
+            a.bits.size.compareTo(b.bits.size)
+        }
+    }
+
+    private fun buildTree(data: Iterable<Int>,alphabet: Alphabet<*>): Node {
+        val frequencies = buildFrequencies(alphabet, data)
+        return buildTree(frequencies)
+    }
+
+    private fun buildTree(frequencies: Array<Int>): Node {
+//        println(data.toDump())
+
+        val list: SortedList<Node> = SortedList(*frequencies.mapIndexed { index, frequency -> Node.Leaf(index, frequency) }.filter { it.freq > 0 }
+            .toTypedArray())
+
+        // build the tree
+        while (list.size > 1) {
+            val left = list.removeAt(0)
+            val right = list.removeAt(0)
+            list.add(Node.Internal(left, right))
+        }
+        return list[0]
+    }
+
+    private fun buildFrequencies(
+        alphabet: Alphabet<*>,
+        data: Iterable<Int>
+    ): Array<Int> {
+        val maxOrdinal = alphabet.maxOrdinal
+        val frequencies = Array(maxOrdinal) { 0 }
+        data.forEach { frequencies[it]++ }
+        return frequencies
+    }
+
+    fun decompressUsingCodes(bin: BitInput, codes: List<Code?>, alphabet: Alphabet<*>): BitArray {
+        val result = MemoryBitOutput()
+        val table = codes.filterNotNull().associateBy { it.bits }
+
+        outer@ while (true) {
+            var input = TinyBits()
+            while (true) {
+                bin.getBitOrNull()?.let { input = input.insertBit(it) }
+                    ?: break@outer
+                val data = table[input]
+                if (data != null) {
+//                    println("Code found: ${data.bits} -> [${data.symbol.toChar()}]")
+                    alphabet.decodeOrdinalTo(result,data.ordinal)
+                    break
+                }
+            }
+        }
+        return result.toBitArray()
+    }
+
+    private fun serializeCanonicCodes(bout: BitOutput, codes: List<Code?>) {
+        var minSize: Int? = null
+        var maxSize: Int? = null
+        for (i in 1..<codes.size) {
+            val s = codes[i]?.size?.toInt() ?: continue
+            if (minSize == null || s < minSize) minSize = s
+            if (maxSize == null || s > maxSize) maxSize = s
+        }
+        val size = maxSize!! - minSize!! + 1
+        val sizeInBits = sizeInBits(size)
+        bout.packUnsigned(minSize.toULong())
+        bout.packUnsigned(sizeInBits.toULong())
+        for (c in codes) {
+            if (c != null)
+                bout.putBits(c.bits.size.toInt() - minSize + 1, sizeInBits)
+            else
+                bout.putBits(0, sizeInBits)
+        }
+    }
+
+    fun deserializeCanonicCodes(bin: BitInput, alphabet: Alphabet<*>): List<Code?> {
+        val minSize = bin.unpackUnsigned().toInt()
+        val sizeInBits = bin.unpackUnsigned().toInt()
+        val sorted = mutableListOf<Code>().also { codes ->
+            for (i in 0..<alphabet.maxOrdinal) {
+                val s = bin.getBits(sizeInBits).toInt()
+                if (s > 0) {
+                    codes.add(Code(i, TinyBits(0U, s - 1 + minSize)))
+                }
+            }
+        }.sortedWith(canonicComparator)
+
+        val result = MutableList<Code?>(alphabet.maxOrdinal) { null }
+        var prev = sorted[0].copy(bits = TinyBits(0U, sorted[0].bits.size))
+        result[prev.ordinal] = prev
+
+        for (i in 1..<sorted.size) {
+            val code = sorted[i]
+            var bits = TinyBits(prev.bits.value + 1u, prev.bits.size)
+            while (bits.size < code.bits.size) bits = bits.insertBit(0)
+            result[code.ordinal] = code.copy(bits = bits).also {
+                prev = it
+            }
+        }
+        return result
+    }
+
+//    fun generateCanonicalCodes(frequencies: Iterable<Int>): List<Code?> {
+//
+//    }
+
+    fun generateCanonicalCodes(frequencies: Array<Int>,alphabet: Alphabet<*>): List<Code?> =
+        generateCanonicCodes(buildTree(frequencies), alphabet)
+
+    fun <T>compress(plain: Iterable<T>,alphabet: Alphabet<T>): BitArray {
+
+        val source = plain.map { alphabet.ordinalOf(it) }
+        val root = buildTree(source,alphabet)
+
+        val codes = generateCanonicCodes(root, alphabet)
+
+        // serializa table
+
+        // test encode:
+        val bout = MemoryBitOutput()
+        serializeCanonicCodes(bout, codes)
+        for (i in source) {
+            val code = codes[i]!!
+//            println(">> $code")
+            bout.putBits(code.bits)
+        }
+//        println(bout.toBitArray().bytes.toDump())
+        val compressed = bout.toBitArray()
+        return compressed
+    }
+
+    fun <T>decompress(bin: BitInput,alphabet: Alphabet<T>): UByteArray {
+        val codes = deserializeCanonicCodes(bin, alphabet)
+        return decompressUsingCodes(bin, codes, alphabet).asUbyteArray()
+    }
+
+}

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

@@ -0,0 +1,128 @@
+package net.sergeych.lynon
+
+import net.sergeych.bintools.ByteChunk
+import kotlin.math.roundToInt
+
+/**
+ * LZW lightweight pure kotlin compression.
+ */
+object LZW {
+
+    val MAX_CODE_SIZE = 17
+    val STOP_CODE = (1 shl MAX_CODE_SIZE) - 1
+    val MAX_DICT_SIZE = (STOP_CODE * 0.92).roundToInt()
+
+
+    fun compress(input: ByteArray, bitOutput: BitOutput)
+        = compress(input.asUByteArray(), bitOutput)
+
+    /**
+     * Compresses the input string using LZW algorithm
+     * @param input The string to compress
+     * @return List of compressed codes
+     */
+    fun compress(input: UByteArray, bitOutput: BitOutput) {
+        // Initialize dictionary with all possible single characters
+        val dictionary = mutableMapOf<ByteChunk, Int>()
+        for (i in 0..255) {
+            // 23
+            dictionary[ByteChunk(ubyteArrayOf(i.toUByte()))] = i
+        }
+
+        var nextCode = 256
+        var current = ByteChunk(ubyteArrayOf())
+//            val result = mutableListOf<Int>()
+
+        for (char in input) {
+            val combined = current + char
+            if (dictionary.containsKey(combined)) {
+                current = combined
+            } else {
+                val size = sizeInBits(dictionary.size)
+                bitOutput.putBits(dictionary[current]!!, size)
+                if (dictionary.size >= MAX_DICT_SIZE) {
+                    bitOutput.putBits(STOP_CODE, size)
+                    dictionary.clear()
+                    nextCode = 256
+                    for (i in 0..255) {
+                        dictionary[ByteChunk(ubyteArrayOf(i.toUByte()))] = i
+                    }
+                } else
+                    dictionary[combined] = nextCode++
+                current = ByteChunk(ubyteArrayOf(char))
+            }
+        }
+
+        if (current.size > 0) {
+            val size = sizeInBits(dictionary.size)
+            bitOutput.putBits(dictionary[current]!!, size)
+        }
+    }
+
+    fun compress(input: UByteArray): BitArray {
+        return MemoryBitOutput().apply {
+            compress(input, this)
+        }.toBitArray()
+    }
+
+    /**
+     * Decompresses a list of LZW codes back to the original string. Note that usage of apriori existing
+     * size is crucial: it let repeal explosion style attacks.
+     *
+     * @param compressed The list of compressed codes
+     * @param resultSize The expected size of the decompressed string
+     *
+     * @throws DecompressionException if something goes wrong
+     * @return The decompressed string
+     */
+    fun decompress(compressed: BitInput, resultSize: Int): UByteArray {
+        // Initialize dictionary with all possible single characters
+        val dictionary = mutableMapOf<Int, UByteArray>()
+        for (i in 0..255) {
+            dictionary[i] = ubyteArrayOf(i.toUByte())
+        }
+
+        var nextCode = 256
+        val firstCode = compressed.getBits(9).toInt()
+        var previous = dictionary[firstCode]
+            ?: throw DecompressionException("Invalid first compressed code: $firstCode")
+        val result = mutableListOf<UByte>()
+        result += previous
+
+        while (result.size < resultSize) {
+            val codeSize = sizeInBits(nextCode + 1)
+            val code = compressed.getBitsOrNull(codeSize)?.toInt() ?: break
+
+            if (code == STOP_CODE) {
+                nextCode = 256
+                dictionary.clear()
+                for (i in 0..255)
+                    dictionary[i] = ubyteArrayOf(i.toUByte())
+                previous = dictionary[compressed.getBits(9).toInt()]!!
+            } else {
+
+                val current = if (code in dictionary) {
+                    dictionary[code]!!
+                } else if (code == nextCode) {
+                    // Special case for pattern like cScSc
+                    previous + previous[0]
+                } else {
+                    throw DecompressionException("Invalid compressed code: $code")
+                }
+
+                result += current
+                dictionary[nextCode++] = previous + current[0]
+                previous = current
+            }
+        }
+
+        if (result.size != resultSize)
+            throw DecompressionException("Decompressed size is not equal to expected: real/expected = ${result.size}/$resultSize")
+        return result.toTypedArray().toUByteArray()
+    }
+}
+
+
+private operator fun ByteChunk.plus(byte: UByte): ByteChunk {
+    return ByteChunk(data + byte)
+}

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

@@ -0,0 +1,36 @@
+package net.sergeych.lynon
+
+import net.sergeych.lyng.Scope
+import net.sergeych.lyng.obj.Obj
+import net.sergeych.lyng.obj.ObjBitBuffer
+import net.sergeych.lyng.obj.ObjClass
+import net.sergeych.lyng.obj.ObjString
+
+// Most often used types:
+
+
+val ObjLynonClass = object : ObjClass("Lynon") {
+
+    suspend fun Scope.encodeAny(obj: Obj): Obj {
+        val bout = MemoryBitOutput()
+        val serializer = LynonEncoder(bout)
+        serializer.encodeAny(this, obj)
+        return ObjBitBuffer(bout.toBitArray())
+    }
+
+    suspend fun Scope.decodeAny(source: Obj): Obj {
+        if( source !is ObjBitBuffer) throw Exception("Invalid source: $source")
+        val bin = source.bitArray.toInput()
+        val deserializer = LynonDecoder(bin)
+        return deserializer.decodeAny(this)
+    }
+
+}.apply {
+    addClassConst("test", ObjString("test_const"))
+    addClassFn("encode") {
+        encodeAny(requireOnlyArg<Obj>())
+    }
+    addClassFn("decode") {
+        decodeAny(requireOnlyArg<Obj>())
+    }
+}

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

@@ -0,0 +1,15 @@
+package net.sergeych.lynon
+
+/**
+ * Variant of [LynonEncoder] that writes to embedded [MemoryBitOutput]
+ */
+class LynonPacker(bout: MemoryBitOutput = MemoryBitOutput(), settings: LynonSettings = LynonSettings.default)
+    : LynonEncoder(bout, settings) {
+}
+
+/**
+ * Variant of [LynonDecoder] that reads from a given `source` using [MemoryBitInput]
+ */
+class LynonUnpacker(source: BitInput) : LynonDecoder(source) {
+    constructor(packer: LynonPacker) : this((packer.bout as MemoryBitOutput).toBitInput())
+}

lynglib/src/commonMain/lyng/stdlib/Iterable.lyng

@@ -0,0 +1,16 @@
+
+fun Iterable.filter( predicate ) {
+    flow {
+        for( item in this )
+            if( predicate(item) )
+                emit(item)
+    }
+}
+
+fun Iterable.drop(n) {
+    require( n >= 0, "drop amount must be non-negative")
+    var count = 0
+    filter {
+        count++ < N
+    }
+}

lynglib/src/commonTest/kotlin/CoroutinesTest.kt

@@ -0,0 +1,171 @@
+import kotlinx.coroutines.test.runTest
+import net.sergeych.lyng.eval
+import kotlin.test.Test
+
+class TestCoroutines {
+
+    @Test
+    fun testLaunch() = runTest {
+        eval(
+            """
+            var passed = false
+            val x = launch { 
+                delay(10)
+                passed = true
+                "ok"
+            }
+            assert(!passed)
+            assertEquals( x.await(), "ok")
+            assert(passed)
+            assert(x.isCompleted)
+        """.trimIndent()
+        )
+    }
+
+    @Test
+    fun testCompletableDeferred() = runTest {
+        eval(
+            """
+            val done = CompletableDeferred()
+            
+            launch { 
+                delay(30)
+                done.complete("ok")
+            }
+            
+            assert(!done.isCompleted)
+            assert(done.isActive)
+            assertEquals( done.await(), "ok")
+            assert(done.isCompleted)
+        """.trimIndent()
+        )
+    }
+
+    @Test
+    fun testMutex() = runTest {
+        eval(
+            """
+            var counter = 0
+            val mutex = Mutex()
+            
+            (1..4).map { 
+                launch {
+//                    mutex.withLock {
+                        val c = counter
+                        delay(5)
+                        counter = c + 1
+//                    }
+                }
+             }.forEach { it.await() }
+             println(counter)
+             assert( counter < 10 )
+             
+    """.trimIndent()
+        )
+    }
+
+    @Test
+    fun testFlows() = runTest {
+        eval("""
+            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]
+            assertEquals( correctFibs, f.take(correctFibs.size))
+            
+        """.trimIndent())
+    }
+
+    @Test
+    fun testFlow2() = runTest {
+        eval("""
+                val f = flow {
+                        emit("start")
+                        emit("start2")
+                        (1..4).forEach { 
+                            emit(it) 
+                        }
+                }
+                // let's collect flow:
+                val result = []
+                for( x in f ) result += x
+                    println(result)
+                
+                // let's collect it once again:
+                assertEquals( result, f.toList())
+                assertEquals( result, f.toList())
+        """.trimIndent())
+    }
+
+    @Test
+    fun testFlowClosures() = runTest {
+        eval("""
+            fun filter( a, b ) {
+                println("filter: %s, %s"(a,b))
+                flow {
+                    emit(a)
+                    emit(b)
+                }
+            }
+            
+            assertEquals( [5, 1], filter(5,1).toList() )
+            assertEquals( [2, 3], filter(2,3).toList() )
+            
+        """.trimIndent())
+    }
+
+    @Test
+    fun testFilterFlow() = runTest {
+        eval("""
+            fun filter( list, predicate ) {
+                val p = predicate
+                println("predicate "+predicate+" / "+p)
+                flow {
+                    // here p is captured only once and does not change!
+                    for( item in list ) {
+                        print("filter "+p+" "+item+": ")
+                        if( p(item) ) {
+                            println("OK")
+                            emit(item)
+                        }
+                        else println("NO")
+                    }
+                }
+            }
+            
+//            fun drop(i, n) {
+//                require( n >= 0, "drop amount must be non-negative")
+//                var count = 0
+//                println("drop %d"(n))
+//                filter(i) {
+//                    count++ >= n
+//                }
+//            }
+            
+            val src = (1..1).toList()
+            assertEquals( 1, filter(src) { true }.toList().size )
+            println("----------------------------------------------------------")
+            println("----------------------------------------------------------")
+            println("----------------------------------------------------------")
+            println("----------------------------------------------------------")
+            assertEquals( 0, filter(src) { false }.toList().size )
+//            assertEquals( 3, filter(src) { true }.size() ) 
+            
+//            assertEquals( [7,8], drop((1..8).toList(),6).toList())
+//            assertEquals( [1,3,5,7], filter((1..8).toList()) { 
+//                println("call2")
+//                it % 2 == 1 
+//            }.toList())
+        """.trimIndent())
+    }
+}

lynglib/src/commonTest/kotlin/OOTest.kt

@@ -0,0 +1,92 @@
+import kotlinx.coroutines.test.runTest
+import net.sergeych.lyng.eval
+import kotlin.test.Test
+
+class OOTest {
+    @Test
+    fun testClassProps() = runTest {
+        eval("""
+            import lyng.time
+            
+            class Point(x,y) {
+                static val origin = Point(0,0)
+                static var center = origin
+            }
+            assertEquals(Point(0,0), Point.origin)
+            assertEquals(Point(0,0), Point.center)
+            Point.center = Point(1,2)
+            assertEquals(Point(0,0), Point.origin)
+            assertEquals(Point(1,2), Point.center)
+            
+        """.trimIndent())
+    }
+    @Test
+    fun testClassMethods() = runTest {
+        eval("""
+            import lyng.time
+            
+            class Point(x,y) {
+                private static var data = null
+                
+                static fun getData() { data }
+                static fun setData(value) { 
+                    data = value 
+                    callFrom()
+                }
+                static fun callFrom() {
+                    data = data + "!"
+                }
+            }
+            assertEquals(Point(0,0), Point(0,0) )
+            assertEquals(null, Point.getData() )
+            Point.setData("foo")
+            assertEquals( "foo!", Point.getData() )
+        """.trimIndent())
+    }
+
+    @Test
+    fun testDynamicGet() = runTest {
+        eval("""
+            val accessor = dynamic {
+                get { name ->
+                    if( name == "foo" ) "bar" else null
+                }
+            }
+           
+            println("-- " + accessor.foo)
+            assertEquals("bar", accessor.foo)
+            assertEquals(null, accessor.bar)
+            
+        """.trimIndent())
+    }
+
+    @Test
+    fun testDelegateSet() = runTest {
+        eval("""
+            var setValueForBar = null
+            val accessor = dynamic {
+                get { name ->
+                    when(name) {
+                        "foo" -> "bar"
+                        "bar" -> setValueForBar 
+                        else -> null
+                    }
+                }
+                set { name, value ->
+                    if( name == "bar" )
+                        setValueForBar = value
+                    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"
+            }
+        """.trimIndent())
+    }
+}

lynglib/src/commonTest/kotlin/ScriptTest.kt

@@ -1,8 +1,10 @@
-
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.toList
 import kotlinx.coroutines.test.runTest
 import net.sergeych.lyng.*
+import net.sergeych.lyng.obj.*
+import net.sergeych.lyng.pacman.InlineSourcesImportProvider
 import kotlin.test.*
 
 class ScriptTest {
@@ -604,7 +606,7 @@ class ScriptTest {
     }
 
     @Test
-    fun testAssignArgumentsmiddleEllipsis() = runTest {
+    fun testAssignArgumentsMiddleEllipsis() = runTest {
         val ttEnd = Token.Type.RBRACE
         val pa = ArgsDeclaration(
             listOf(
@@ -706,19 +708,13 @@ class ScriptTest {
             var t1 = 10
             outer@ while( t1 > 0 ) {
                 var t2 = 10
-                println("starting t2 = " + t2)
                 while( t2 > 0 ) {
                     t2 = t2 - 1
-                    println("t2 " + t2 + " t1 " + t1)
                     if( t2 == 3 && t1 == 7) {
-                        println("will break")
                         break@outer "ok2:"+t2+":"+t1
                     }
                 }
-                println("next t1")
-                t1 = t1 - 1
-                println("t1 now "+t1)
-                t1
+                --t1
             }
         """.trimIndent()
             ).toString()
@@ -733,8 +729,6 @@ class ScriptTest {
                 """
                 val count = 3
                 val res = if( count > 10 ) "too much" else "just " + count
-                println(count)
-                println(res)
                 res
                 """.trimIndent()
             )
@@ -770,7 +764,7 @@ class ScriptTest {
     fun testDecr() = runTest {
         val c = Scope()
         c.eval("var x = 9")
-        assertEquals(9, c.eval("x--").toInt())
+        assertEquals(9, c.eval("println(x); val a = x--; println(x); println(a); a").toInt())
         assertEquals(8, c.eval("x--").toInt())
         assertEquals(7, c.eval("x--").toInt())
         assertEquals(6, c.eval("x--").toInt())
@@ -1280,6 +1274,106 @@ class ScriptTest {
         )
     }
 
+    @Test
+    fun testCaptureLocals() = runTest {
+        eval(
+            """
+            
+            fun outer(prefix) {
+                val p1 = "0" + prefix
+                { 
+                    p1 + "2" + it
+                }
+            }
+            fun outer2(prefix) {
+                val p1 = "*" + prefix
+                { 
+                    p1 + "2" + it
+                }
+            }
+            val x = outer("1")
+            val y = outer2("1")
+            println(x("!"))
+            assertEquals( "0123", x("3") )
+            assertEquals( "*123", y("3") )
+        """.trimIndent()
+        )
+    }
+
+    @Test
+    fun testInstanceCallScopeIsCorrect() = runTest {
+        eval(
+            """
+            
+            val prefix = ":"
+            
+            class T(text) {
+                fun getText() { 
+                    println(text)
+                    prefix + text + "!" 
+                }
+            }
+            
+            val text = "invalid"
+            
+            val t1 = T("foo")
+            val t2 = T("bar")
+            
+            // get inside the block
+            for( i in 1..3 ) {
+                assertEquals( "foo", t1.text )
+                assertEquals( ":foo!", t1.getText() )
+                assertEquals( "bar", t2.text )
+                assertEquals( ":bar!", t2.getText() )
+            }
+        """.trimIndent()
+        )
+    }
+
+    @Test
+    fun testAppliedScopes() = runTest {
+        eval(
+            """
+            class T(text) {
+                fun getText() { 
+                    println(text)
+                    text + "!" 
+                }
+            }
+        
+            val prefix = ":"
+            val lambda = { 
+                prefix + getText() + "!"
+            }
+        
+            val text = "invalid"
+            val t1 = T("foo")
+            val t2 = T("bar")
+            
+            t1.apply { 
+                // it must take "text" from class t1:
+                assertEquals("foo", text)
+                assertEquals( "foo!", getText() ) 
+                assertEquals( ":foo!!", lambda() ) 
+            } 
+            t2.apply { 
+                assertEquals("bar", text)
+                assertEquals( "bar!", getText() ) 
+                assertEquals( ":bar!!", lambda() ) 
+            }
+            // worst case: names clash
+            fun badOne() {
+                val prefix = "&"
+                t1.apply {
+                    assertEquals( ":foo!!", lambda() ) 
+                }
+            }
+            badOne()
+            
+            """.trimIndent()
+        )
+    }
+
     @Test
     fun testLambdaWithArgsEllipsis() = runTest {
         eval(
@@ -2248,54 +2342,73 @@ class ScriptTest {
         )
     }
 
+    @Test
+    fun testSet2() = runTest {
+        eval(
+            """
+            assertEquals( Set( ...[1,2,3]), Set(1,2,3) )
+            assertEquals( Set( ...[1,false,"ok"]), Set("ok", 1, false) )
+        """.trimIndent()
+        )
+    }
+
     @Test
     fun testLet() = runTest {
-        eval("""
+        eval(
+            """
             class Point(x=0,y=0)
             assert( Point() is Object) 
             Point().let { println(it.x, it.y) }
             val x = null
             x?.let { println(it.x, it.y) }
-        """.trimIndent())
+        """.trimIndent()
+        )
     }
 
     @Test
     fun testApply() = runTest {
-        eval("""
+        eval(
+            """
             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
-
-        """.trimIndent())
+        """.trimIndent()
+        )
     }
 
     @Test
     fun testApplyThis() = runTest {
-        eval("""
+        eval(
+            """
             class Point(x,y)
+            
             // see the difference: apply changes this to newly created Point:
             val p = Point(1,2).apply { 
-                this.x++; this.y++ 
+                this.x++ 
+                y++ 
             }
             assertEquals(p, Point(2,3))
-            >>> void
-
-        """.trimIndent())
+        """.trimIndent()
+        )
     }
 
     @Test
     fun testExtend() = runTest() {
-        eval("""
+        eval(
+            """
             
             fun Int.isEven() {
                 this % 2 == 0
             }
             
             fun Object.isInteger() {
+                println(this)
+                println(this is Int)
+                println(this is Real)
+                println(this is String)
                 when(this) {
                     is Int -> true
                     is Real -> toInt() == this
@@ -2310,8 +2423,9 @@ class ScriptTest {
             assert( 12.isInteger() == true )
             assert( 12.1.isInteger() == false )
             assert( "5".isInteger() )
-            assert( ! "5.2".isInteger() )
-        """.trimIndent())
+            assert( !"5.2".isInteger() )
+        """.trimIndent()
+        )
     }
 
     @Test
@@ -2319,33 +2433,35 @@ class ScriptTest {
         val c = Scope()
         val arr = c.eval("[1,2,3]")
         // array is iterable so we can:
-        assertEquals(listOf(1,2,3),  arr.toFlow(c).map { it.toInt() }.toList())
+        assertEquals(listOf(1, 2, 3), arr.toFlow(c).map { it.toInt() }.toList())
     }
 
     @Test
     fun testAssociateBy() = runTest() {
-        eval("""
+        eval(
+            """
             val m = [123, 456].associateBy { "k:%s"(it) }
             println(m)
             assertEquals(123, m["k:123"])
             assertEquals(456, m["k:456"])
-            """)
-        listOf(1,2,3).associateBy { it * 10 }
+            """
+        )
+        listOf(1, 2, 3).associateBy { it * 10 }
     }
 
-    @Test
-    fun testImports1() = runTest() {
-        val foosrc = """
-            package lyng.foo
+//    @Test
+//    fun testImports1() = runTest() {
+//        val foosrc = """
+//            package lyng.foo
+//
+//            fun foo() { "foo1" }
+//            """.trimIndent()
+//        val pm = InlineSourcesPacman(Pacman.emptyAllowAll, listOf(Source("foosrc", foosrc)))
+//        assertNotNull(pm.modules["lyng.foo"])
+//        assertIs<ModuleScope>(pm.modules["lyng.foo"]!!.deferredModule.await())
 
-            fun foo() { "foo1" }
-            """.trimIndent()
-        val pm = InlineSourcesPacman(Pacman.emptyAllowAll, listOf(Source("foosrc", foosrc)))
-        assertNotNull(pm.modules.await()["lyng.foo"])
-        assertIs<ModuleScope>(pm.modules.await()["lyng.foo"]!!.await())
-
-        assertEquals("foo1", pm.modules.await()["lyng.foo"]!!.await().eval("foo()").toString())
-    }
+//        assertEquals("foo1", pm.modules["lyng.foo"]!!.deferredModule.await().eval("foo()").toString())
+//    }
 
     @Test
     fun testImports2() = runTest() {
@@ -2354,7 +2470,7 @@ class ScriptTest {
             
             fun foo() { "foo1" }
             """.trimIndent()
-        val pm = InlineSourcesPacman(Pacman.emptyAllowAll, listOf(Source("foosrc", foosrc)))
+        val pm = InlineSourcesImportProvider(listOf(Source("foosrc", foosrc)))
 
         val src = """
             import lyng.foo
@@ -2365,4 +2481,354 @@ class ScriptTest {
         val scope = ModuleScope(pm, src)
         assertEquals("foo1", scope.eval(src).toString())
     }
+
+    @Test
+    fun testImports3() = runTest {
+        val foosrc = """
+            package lyng.foo
+            
+            import lyng.bar            
+            
+            fun foo() { "foo1" }
+            """.trimIndent()
+        val barsrc = """
+            package lyng.bar
+            
+            fun bar() { "bar1" }
+            """.trimIndent()
+        val pm = InlineSourcesImportProvider(
+            listOf(
+                Source("barsrc", barsrc),
+                Source("foosrc", foosrc),
+            )
+        )
+
+        val src = """
+            import lyng.foo
+            
+            foo() + " / " + bar()
+            """.trimIndent().toSource("test")
+
+        val scope = ModuleScope(pm, src)
+        assertEquals("foo1 / bar1", scope.eval(src).toString())
+    }
+
+    @Test
+    fun testImportsCircular() = runTest {
+        val foosrc = """
+            package lyng.foo
+            
+            import lyng.bar            
+            
+            fun foo() { "foo1" }
+            """.trimIndent()
+        val barsrc = """
+            package lyng.bar
+            
+            import lyng.foo
+            
+            fun bar() { "bar1" }
+            """.trimIndent()
+        val pm = InlineSourcesImportProvider(
+            listOf(
+                Source("barsrc", barsrc),
+                Source("foosrc", foosrc),
+            )
+        )
+
+        val src = """
+            import lyng.bar
+            
+            foo() + " / " + bar()
+            """.trimIndent().toSource("test")
+
+        val scope = ModuleScope(pm, src)
+        assertEquals("foo1 / bar1", scope.eval(src).toString())
+    }
+
+    @Test
+    fun testDefaultImportManager() = runTest {
+        val scope = Scope.new()
+        assertFails {
+            scope.eval(
+                """
+                import foo
+                foo()
+                """.trimIndent()
+            )
+        }
+        scope.importManager.addTextPackages(
+            """
+            package foo
+            
+            fun foo() { "bar" }
+        """.trimIndent()
+        )
+        scope.eval(
+            """
+                import foo
+                assertEquals( "bar", foo())
+                """.trimIndent()
+        )
+    }
+
+    @Test
+    fun testMaps() = runTest {
+        eval(
+            """
+                val map = Map( "a" => 1, "b" => 2 )
+                assertEquals( 1, map["a"] )
+                assertEquals( 2, map["b"] )
+                assertEquals( null, map["c"] )
+                map["c"] = 3
+                assertEquals( 3, map["c"] )
+        """.trimIndent()
+        )
+    }
+
+    @Test
+    fun testBuffer() = runTest {
+        eval(
+            """
+            import lyng.buffer
+            
+            assertEquals( 0, Buffer().size )
+            assertEquals( 3, Buffer(1, 2, 3).size )
+            assertEquals( 5, Buffer("hello").size )
+            
+            var buffer = Buffer("Hello")
+            assertEquals( 5, buffer.size)
+            assertEquals('l'.code, buffer[2] )
+            assertEquals('l'.code, buffer[3] )
+            assertEquals("Hello", buffer.decodeUtf8())
+            
+            buffer = buffer.toMutable()
+            
+            buffer[2] = 101
+            assertEquals(101, buffer[2])
+            assertEquals("Heelo", buffer.decodeUtf8())
+            
+        """.trimIndent()
+        )
+    }
+
+    @Test
+    fun testBufferCompare() = runTest {
+        eval(
+            """
+            import lyng.buffer
+            
+            println("Hello".characters())
+            val b1 = Buffer("Hello")
+            val b2 = Buffer("Hello".characters())
+            
+            assertEquals( b1, b2 )
+            val b3 = b1 + Buffer("!")
+            assertEquals( "Hello!", b3.decodeUtf8())
+            assert( b3 > b1 )
+            assert( b1 !== b2)
+            
+            val map = Map( b1 => "foo")
+            assertEquals("foo",  map[b1])
+            assertEquals("foo",  map[b2])
+            assertEquals(null,  map[b3])
+            
+        """.trimIndent()
+        )
+    }
+
+    @Test
+    fun testInstant() = runTest {
+        eval(
+            """
+            import lyng.time
+            
+            val now = Instant()
+//            assertEquals( now.epochSeconds, Instant(now.epochSeconds).epochSeconds )
+
+            assert( 10.seconds is Duration )
+            assertEquals( 10.seconds, Duration(10) )
+            assertEquals( 10.milliseconds, Duration(0.01) )
+            assertEquals( 10.milliseconds, 0.01.seconds )
+            assertEquals( 1001.5.milliseconds, 1.0015.seconds )
+
+            val n1 = now + 7.seconds
+            assert( n1 is Instant )
+
+            assertEquals( n1 - now, 7.seconds )
+            assertEquals( now - n1, -7.seconds )
+            
+            """.trimIndent()
+        )
+        delay(1000)
+    }
+
+    @Test
+    fun testTimeStatics() = runTest {
+        eval(
+            """
+            import lyng.time
+            assert( 100.minutes is Duration )
+            assert( 100.days is Duration )
+            assert( 1.day == 24.hours )
+            assert( 1.day.hours == 24 )
+            assert( 1.hour.seconds == 3600 )
+            assert( 1.minute.milliseconds == 60_000 )
+            
+            assert(Instant.distantFuture is Instant)
+            assert(Instant.distantPast is Instant)
+            assert( Instant.distantFuture - Instant.distantPast > 70_000_000.days)
+            val maxRange = Instant.distantFuture - Instant.distantPast
+            println("всего лет %g"(maxRange.days/365.2425))
+            """.trimIndent()
+        )
+    }
+
+    @Test
+    fun testInstantFormatting() = runTest {
+        eval(
+            """
+            import lyng.time
+            val now = Instant()
+            val unixEpoch = "%ts"(now)
+            println("current seconds is %s"(unixEpoch))
+            println("current time is %tT"(now))
+            assertEquals( unixEpoch.toInt(), now.epochSeconds.toInt() )
+            """.trimIndent()
+        )
+    }
+
+    @Test
+    fun testDoubleImports() = runTest {
+        val s = Scope.new()
+        println(Script.defaultImportManager.packageNames)
+        println(s.importManager.packageNames)
+
+        s.importManager.addTextPackages(
+            """
+            package foo
+             
+            import lyng.time
+            
+            fun foo() {
+                println("foo: %s"(Instant()))
+            }
+        """.trimIndent()
+        )
+        s.importManager.addTextPackages(
+            """
+            package bar
+             
+            import lyng.time
+            
+            fun bar() {
+                println("bar: %s"(Instant()))
+            }
+        """.trimIndent()
+        )
+
+        println(s.importManager.packageNames)
+
+        s.eval(
+            """
+            import foo
+            import bar
+            
+            foo()
+            bar()
+            
+        """.trimIndent()
+        )
+
+    }
+
+    @Test
+    fun testIndexIntIncrements() = runTest {
+        eval(
+            """
+        val x = [1,2,3]
+        x[1]++
+        ++x[0]
+        assertEquals( [2,3,3], x )
+        
+        import lyng.buffer
+        
+        val b = MutableBuffer(1,2,3)
+        b[1]++
+        assert( b == Buffer(1,3,3) )
+        ++b[0]
+        assertEquals( b, Buffer(2,3,3) )
+        """.trimIndent()
+        )
+    }
+
+    @Test
+    fun testIndexIntDecrements() = runTest {
+        eval(
+            """
+        val x = [1,2,3]
+        x[1]--
+        --x[0]
+        assertEquals( [0,1,3], x )
+        
+        import lyng.buffer
+        
+        val b = Buffer(1,2,3).toMutable()
+        b[1]--
+        assert( b == Buffer(1,1,3) )
+        --b[0]
+        assertEquals( b, Buffer(0,1,3) )
+        """.trimIndent()
+        )
+    }
+
+    @Test
+    fun testRangeToList() = runTest {
+        val x = eval("""(1..10).toList()""") as ObjList
+        assertEquals(listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10), x.list.map { it.toInt() })
+        val y = eval("""(-2..3).toList()""") as ObjList
+        println(y.list)
+    }
+
+    @Test
+    fun testMultilineStrings() = runTest {
+        assertEquals(
+            """
+            This is a multiline text.
+            This is a second line.
+        """.trimIndent(), eval(
+                """
+            "
+                This is a multiline text.
+                This is a second line.
+            "
+        """.trimIndent()
+            ).toString()
+        )
+        assertEquals(
+            """
+            This is a multiline text.
+        """.trimIndent(), eval(
+                """
+            "
+                This is a multiline text.
+            "
+        """.trimIndent()
+            ).toString()
+        )
+        assertEquals(
+            """
+
+            This is a multiline text.
+        """.trimIndent(), eval(
+                """
+            "
+
+                This is a multiline text.
+            "
+        """.trimIndent()
+            ).toString()
+        )
+    }
+
 }

lynglib/src/commonTest/kotlin/StdlibTest.kt

@@ -0,0 +1,65 @@
+import kotlinx.coroutines.test.runTest
+import net.sergeych.lyng.eval
+import kotlin.test.Test
+
+class StdlibTest {
+    @Test
+    fun testIterableFilter() = runTest {
+        eval("""
+            assertEquals([1,3,5,7], (1..8).filter{ it % 2 == 1 }.toList() )
+            assertEquals([2,4,6,8], (1..8).filter{ it % 2 == 0 }.toList() )
+        """.trimIndent())
+
+    }
+
+    @Test
+    fun testFirstLast() = runTest {
+        eval("""
+            assertEquals(1, (1..8).first )
+            assertEquals(8, (1..8).last )
+        """.trimIndent())
+    }
+
+    @Test
+    fun testTake() = runTest {
+        eval("""
+            assertEquals([1,2,3], (1..8).take(3).toList() )
+            assertEquals([7,8], (1..8).takeLast(2).toList() )
+        """.trimIndent())
+    }
+
+    @Test
+    fun testRingBuffer() = runTest {
+        eval("""
+            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() )
+            
+            r += 40
+            assertEquals(3, r.size)
+            assertEquals( [20, 30, 40], r.toList() )
+            
+        """.trimIndent())
+    }
+
+    @Test
+    fun testDrop() = runTest {
+        eval("""
+            assertEquals([7,8], (1..8).drop(6).toList() )
+            assertEquals([1,2], (1..8).dropLast(6).toList() )
+        """.trimIndent())
+    }
+}

lynglib/src/commonTest/kotlin/TypesTest.kt

@@ -50,4 +50,27 @@ class TypesTest {
            
         """.trimIndent())
     }
+
+    @Test
+    fun testUserClassCompareTo() = runTest {
+        eval("""
+            class Point(val a,b)
+            
+            assertEquals(Point(0,1), Point(0,1) )
+            assertNotEquals(Point(0,1), Point(1,1) )
+        """.trimIndent())
+    }
+
+    @Test
+    fun testUserClassCompareTo2() = runTest {
+        eval("""
+            class Point(val a,b) {
+                var c = 0
+            }
+            assertEquals(Point(0,1), Point(0,1) )
+            assertEquals(Point(0,1).apply { c = 2 }, Point(0,1).apply { c = 2 } )
+            assertNotEquals(Point(0,1), Point(1,1) )
+            assertNotEquals(Point(0,1), Point(0,1).apply { c = 1 } )
+        """.trimIndent())
+    }
 }

lynglib/src/jvmTest/kotlin/BookTest.kt

@@ -2,9 +2,12 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.test.runTest
-import net.sergeych.lyng.ObjVoid
 import net.sergeych.lyng.Scope
+import net.sergeych.lyng.Script
+import net.sergeych.lyng.leftMargin
+import net.sergeych.lyng.obj.ObjVoid
 import java.nio.file.Files
 import java.nio.file.Files.readAllLines
 import java.nio.file.Paths
@@ -14,18 +17,6 @@ import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.fail
 
-fun leftMargin(s: String): Int {
-    var cnt = 0
-    for (c in s) {
-        when (c) {
-            ' ' -> cnt++
-            '\t' -> cnt = (cnt / 4.0 + 0.9).toInt() * 4
-            else -> break
-        }
-    }
-    return cnt
-}
-
 data class DocTest(
     val fileName: String,
     val line: Int,
@@ -105,6 +96,10 @@ fun parseDocTests(fileName: String, bookMode: Boolean = false): Flow<DocTest> =
                         } else {
                             var isValid = true
                             val result = mutableListOf<String>()
+
+                            // remove empty trails:
+                            while( block.last().isEmpty() ) block.removeLast()
+
                             while (block.size > outStart) {
                                 val line = block.removeAt(outStart)
                                 if (!line.startsWith(">>> ")) {
@@ -158,9 +153,10 @@ fun parseDocTests(fileName: String, bookMode: Boolean = false): Flow<DocTest> =
 }
     .flowOn(Dispatchers.IO)
 
-suspend fun DocTest.test(scope: Scope = Scope()) {
+suspend fun DocTest.test(_scope: Scope? = null) {
     val collectedOutput = StringBuilder()
     val currentTest = this
+    val scope  = _scope ?: Script.newScope()
     scope.apply {
         addFn("println") {
             if( bookMode ) {
@@ -265,6 +261,11 @@ class BookTest {
         runDocTests("../docs/Map.md")
     }
 
+    @Test
+    fun testBuffer() = runTest {
+        runDocTests("../docs/Buffer.md")
+    }
+
     @Test
     fun testSampleBooks() = runTest {
         for (bt in Files.list(Paths.get("../docs/samples")).toList()) {
@@ -283,4 +284,20 @@ class BookTest {
     fun testExceptionsBooks() = runTest {
         runDocTests("../docs/exceptions_handling.md")
     }
+
+    @Test
+    fun testTimeBooks() = runBlocking {
+        runDocTests("../docs/time.md")
+    }
+
+    @Test
+    fun testParallelismBook() = runBlocking {
+        runDocTests("../docs/parallelism.md")
+    }
+
+    @Test
+    fun testRingBuffer() = runBlocking {
+        runDocTests("../docs/RingBuffer.md")
+    }
+
 }