Compare commits

...
19 Commits
Author SHA1 Message Date
sergeych f45fa7f7a0 fix #49 regular expressions, operator match and docs 2025-09-05 17:53:19 +04:00
sergeych ead2f7168e ref #49 basic regex support (but not in when yet) 2025-08-25 12:34:04 +03:00
sergeych 2743511b62 better readme 2025-08-24 09:04:40 +03:00
sergeych 8431ab4f96 missing link in readme 2025-08-24 00:15:25 +03:00
sergeych 80735f032d more links in docs 2025-08-24 00:10:17 +03:00
sergeych dc837e2095 +shiffle
+List.binarySearch
2025-08-24 00:09:38 +03:00
sergeych 0ec0ed96ee sorted* moved to Iterable
in-place List sort
v0.8.15-SNAPSHOT
2025-08-23 22:53:10 +03:00
sergeych a5e51a3f90 more tests 2025-08-23 09:41:23 +03:00
sergeych cf79163802 reflected current state in readme 2025-08-22 16:18:04 +03:00
sergeych c8e8bdc466 ref #56 exceptions are serializable
+fixed ambigity betwee lyng/kotln toString, added directional parameter to kotlin
2025-08-22 09:57:36 +03:00
sergeych 4b613fda7c fix #58 improper toString overload processing in Lyng
fix #57 Exception#getStackTrace()
ref #56 StackTraceEntry is serializable now
2025-08-22 00:02:23 +03:00
sergeych 8d1cafae80 fix #55 newlines in function declarations and constructors 2025-08-20 11:07:49 +03:00
sergeych 0526cdfb38 fix #54 on current version of the compiler it is no more an issue 2025-08-20 11:00:47 +03:00
sergeych cad6ba936d fix #53 chained calls and multiline expressions 2025-08-20 10:57:15 +03:00
sergeych cb333ab6bd less debug noise 2025-08-18 11:16:57 +03:00
sergeych 23737f9b5c removed debug stuff 2025-08-18 01:48:23 +03:00
sergeych fb6e2aa49e bugfix: elvis + throw 2025-08-18 01:19:49 +03:00
sergeych 95c1da60ed better elvis + throw
+added run {}
2025-08-18 00:56:52 +03:00
sergeych 835333dfad fixed objClass initialization in ObjInt.Zero, added Buffer.toBitInput, minimal descrription of Lynon 2025-08-17 23:51:50 +03:00
53 changed files with 1658 additions and 305 deletions

No files matched your search

+23 -6
View File
@@ -134,7 +134,19 @@ Designed to add scripting to kotlin multiplatform application in easy and effici
# Language Roadmap # Language Roadmap
## v1.0.0 ```mermaid
flowchart
v0([the idea])
v1([v1: make it happen])
v2([v1.5: testmake it fasted and rich featured])
v3([v2: ideal script language])
v0 --code MVP--> v1
v1 --refine and extend--> v2
v2 -- optimize --> v3
```
## v1.0.0 "Make it happen"
Planned autumn 2025. Complete dynamic language with sufficient standard library: Planned autumn 2025. Complete dynamic language with sufficient standard library:
@@ -158,27 +170,32 @@ Ready features:
- [x] compression/decompression (integrated in serialization) - [x] compression/decompression (integrated in serialization)
- [x] dynamic fields - [x] dynamic fields
- [x] function annotations - [x] function annotations
- [x] better stack reporting
### Under way: ### Under way:
- [ ] regular exceptions - [ ] regular exceptions + extended `when`
- [ ] multiple inheritance for user classes - [ ] multiple inheritance for user classes
- [ ] site with integrated interpreter to give a try - [ ] site with integrated interpreter to give a try
- [ ] kotlin part public API good docs, integration focused - [ ] kotlin part public API good docs, integration focused
- [ ] better stack reporting
## v1.1+ ## plan: v1.0 - v1.5 "Rich and stable"
Estimated spring of 2026
Planned features. Planned features.
- [ ] type specifications - [ ] type specifications
- [ ] language server or compose-based lyng-aware editor
- [ ] source docs and maybe lyng.md to a standard - [ ] source docs and maybe lyng.md to a standard
- [ ] metadata first class access from lyng - [ ] metadata first class access from lyng
Further ## After 1.5 "Ideal scripting"
Estimated winter 2027
- [ ] client with GUI support based on compose multiplatform somehow - [ ] client with GUI support based on compose multiplatform somehow
- [ ] notebook - style workbooks with graphs, formulae, etc. - [ ] notebook - style workbooks with graphs, formulae, etc.
- [ ] language server or compose-based lyng-aware editor - [ ] aggressive optimizations
[parallelism]: docs/parallelism.md [parallelism]: docs/parallelism.md
+37
View File
@@ -0,0 +1,37 @@
# Array
It's an interface if the [Collection] that provides indexing access, like `array[3] = 0`.
Array therefore implements [Iterable] too. The well known implementatino of the `Array` is
[List].
Array adds the following methods:
## Binary search
When applied to sorted arrays, binary search allow to quicly find an index of the element in the array, or where to insert it to keep order:
val coll = [1,2,3,4,5]
assertEquals( 2, coll.binarySearch(3) )
assertEquals( 0, coll.binarySearch(1) )
assertEquals( 4, coll.binarySearch(5) )
val src = (1..50).toList().shuffled()
val result = []
for( x in src ) {
val i = result.binarySearch(x)
assert( i < 0 )
result.insertAt(-i-1, x)
}
assertEquals( src.sorted(), result )
>>> void
So `binarySearch(x)` returns:
- index of `x`, a non-negative number
- negative: `x` not found, but if inserted at position `-returnedValue-1` will leave array sorted.
To pre-sort and array use `Iterable.sorted*` or in-place `List.sort*` families, see [List] and [Iterable] docs.
[Collection]: Collection.md
[Iterable]: Iterable.md
[List]: List.md
+6 -2
View File
@@ -121,7 +121,7 @@ which is used in `toString`) and hex encoding:
## Members ## Members
| name | meaning | type | | name | meaning | type |
|---------------------------|-----------------------------------|---------------| |----------------------------|-----------------------------------------|---------------|
| `size` | size | Int | | `size` | size | Int |
| `decodeUtf8` | decode to String using UTF8 rules | Any | | `decodeUtf8` | decode to String using UTF8 rules | Any |
| `+` | buffer concatenation | Any | | `+` | buffer concatenation | Any |
@@ -129,7 +129,8 @@ which is used in `toString`) and hex encoding:
| `hex` | encode to hex strign | String | | `hex` | encode to hex strign | String |
| `Buffer.decodeHex(hexStr) | decode hex string | Buffer | | `Buffer.decodeHex(hexStr) | decode hex string | Buffer |
| `base64` | encode to base64 (url flavor) (2) | String | | `base64` | encode to base64 (url flavor) (2) | String |
| `Buffer.decodeBase64` | decode base64 to new Buffer (2) | Buffer | | `Buffer.decodeBase64(str)` | decode base64 to new Buffer (2) | Buffer |
| `toBitInput()` | create bit input from a byte buffer (3) | |
(1) (1)
: optimized implementation that override `Iterable` one : optimized implementation that override `Iterable` one
@@ -139,6 +140,9 @@ which is used in `toString`) and hex encoding:
decoding supports both traditional and URL alphabets automatically, and ignores filling `=` characters. Base64URL is decoding supports both traditional and URL alphabets automatically, and ignores filling `=` characters. Base64URL is
well known and mentioned in the internet, for example, [here](https://base64.guru/standards/base64url). well known and mentioned in the internet, for example, [here](https://base64.guru/standards/base64url).
(3)
: `BitInput` is a bit buffer that is used, for example, in [Lynon.decode](serialization.md)
Also, it inherits methods from [Iterable] and [Array]. Also, it inherits methods from [Iterable] and [Array].
+6
View File
@@ -6,6 +6,12 @@ Is a [Iterable] with known `size`, a finite [Iterable]:
val size val size
} }
| name | description |
|------------------------|------------------------------------------------------|
(1)
: `comparator(a,b)` should return -1 if `a < b`, +1 if `a > b` or zero.
See [List], [Set] and [Iterable] See [List], [Set] and [Iterable]
[Iterable]: Iterable.md [Iterable]: Iterable.md
+40 -7
View File
@@ -1,9 +1,13 @@
# Iterable interface # 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. 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. `Map` and `String` have `Iterable` members to access its contents too.
Please see also [Collection] interface: many iterables are also collections, and it adds important features.
## Definition: ## Definition:
Iterable is a class that provides function that creates _the iterator_: Iterable is a class that provides function that creates _the iterator_:
@@ -23,7 +27,8 @@ Iterator itself is a simple interface that should provide only to method:
Just remember at this stage typed declarations are not yet supported. 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, for example Having `Iterable` in base classes allows to use it in for loop. Also, each `Iterable` has some utility functions
available, for example
val r = 1..10 // Range is Iterable! val r = 1..10 // Range is Iterable!
assertEquals( [9,10], r.takeLast(2).toList() ) assertEquals( [9,10], r.takeLast(2).toList() )
@@ -34,7 +39,8 @@ Having `Iterable` in base classes allows to use it in for loop. Also, each `Iter
## joinToString ## joinToString
This methods convert any iterable to a string joining string representation of each element, optionally transforming it and joining using specified suffix. This methods convert any iterable to a string joining string representation of each element, optionally transforming it
and joining using specified suffix.
Iterable.joinToString(suffux=' ', transform=null) Iterable.joinToString(suffux=' ', transform=null)
@@ -49,11 +55,23 @@ Here is the sample:
assertEquals( (1..3).joinToString { it * 10 }, "10 20 30") assertEquals( (1..3).joinToString { it * 10 }, "10 20 30")
>>> void >>> void
## `sum` and `sumBy`
These, again, does the thing:
assertEquals( 6, [1,2,3].sum() )
assertEquals( 12, [1,2,3].sumOf { it*2 } )
// sum of empty collections is null:
assertEquals( null, [].sum() )
assertEquals( null, [].sumOf { 2*it } )
>>> void
## Instance methods: ## Instance methods:
| fun/method | description | | fun/method | description |
|-------------------|---------------------------------------------------------------------------| |------------------------|---------------------------------------------------------------------------------|
| toList() | create a list from iterable | | toList() | create a list from iterable |
| toSet() | create a set from iterable | | toSet() | create a set from iterable |
| contains(i) | check that iterable contains `i` | | contains(i) | check that iterable contains `i` |
@@ -70,13 +88,24 @@ Here is the sample:
| taleLast(n) | return [Iterable] of up to n last elements | | taleLast(n) | return [Iterable] of up to n last elements |
| drop(n) | return new [Iterable] without first n elements | | drop(n) | return new [Iterable] without first n elements |
| dropLast(n) | return new [Iterable] without last n elements | | dropLast(n) | return new [Iterable] without last n elements |
| sum() | return sum of the collection applying `+` to its elements (3) |
| sumOf(predicate) | sum of the modified collection items (3) |
| sorted() | return [List] with collection items sorted naturally |
| sortedWith(comparator) | sort using a comparator that compares elements (1) |
| sortedBy(predicate) | sort by comparing results of the predicate function |
| joinToString(s,t) | convert iterable to string, see (2) | | joinToString(s,t) | convert iterable to string, see (2) |
| reversed() | create a list containing items from this in reverse order |
| shuffled() | create a listof shiffled elements |
(1) (1)
: throws `NoSuchElementException` if there is no such element : throws `NoSuchElementException` if there is no such element
(2) (2)
: `joinToString(suffix=" ",transform=null)`: suffix is inserted between items if there are more than one, trasnfom is optional function applied to each item that must return result string for an item, otherwise `item.toString()` is used. : `joinToString(suffix=" ",transform=null)`: suffix is inserted between items if there are more than one, trasnfom is
optional function applied to each item that must return result string for an item, otherwise `item.toString()` is used.
(3)
: sum of empty collection is `null`
fun Iterable.toList(): List fun Iterable.toList(): List
fun Iterable.toSet(): Set fun Iterable.toSet(): Set
@@ -87,7 +116,6 @@ Here is the sample:
fun Iterable.map(block: (Any?)->Void ): List fun Iterable.map(block: (Any?)->Void ): List
fun Iterable.associateBy( keyMaker: (Any?)->Any): Map fun Iterable.associateBy( keyMaker: (Any?)->Any): Map
## Abstract methods: ## Abstract methods:
fun iterator(): Iterator fun iterator(): Iterator
@@ -102,7 +130,12 @@ Creates a list by iterating to the end. So, the Iterator should be finite to be
- [List], [Range], [Buffer](Buffer.md), [BitBuffer], [Buffer], [Set], [RingBuffer] - [List], [Range], [Buffer](Buffer.md), [BitBuffer], [Buffer], [Set], [RingBuffer]
[Collection]: Collection.md
[List]: List.md [List]: List.md
[Range]: Range.md [Range]: Range.md
[Set]: Set.md [Set]: Set.md
[RingBuffer]: RingBuffer.md [RingBuffer]: RingBuffer.md
+36 -3
View File
@@ -92,10 +92,29 @@ Open end ranges remove head and tail elements:
assert( [1, 2, 3] !== [1, 2, 3]) assert( [1, 2, 3] !== [1, 2, 3])
>>> void >>> void
## In-place sort
List could be sorted in place, just like [Collection] provide sorted copies, in a very like way:
val l1 = [6,3,1,9]
l1.sort()
assertEquals( [1,3,6,9], l1)
l1.sortBy { -it }
assertEquals( [1,3,6,9].reversed(), l1)
l1.sort() // 1 3 6 9
l1.sortBy { it % 4 }
// 1,3,6,9 gives, mod 4:
// 1 3 2 1
// we hope we got it also stable:
assertEquals( [1,9,6,3], l1)
>>> void
## Members ## Members
| name | meaning | type | | name | meaning | type |
|-------------------------------|---------------------------------------|-------------| |-------------------------------|----------------------------------------------|-------------|
| `size` | current size | Int | | `size` | current size | Int |
| `add(elements...)` | add one or more elements to the end | Any | | `add(elements...)` | add one or more elements to the end | Any |
| `insertAt(index,elements...)` | insert elements at position | Int, Any | | `insertAt(index,elements...)` | insert elements at position | Int, Any |
@@ -107,7 +126,11 @@ Open end ranges remove head and tail elements:
| `contains(element)` | check the element is in the list (1) | | | `contains(element)` | check the element is in the list (1) | |
| `[index]` | get or set element at index | Int | | `[index]` | get or set element at index | Int |
| `[Range]` | get slice of the array (copy) | Range | | `[Range]` | get slice of the array (copy) | Range |
| `+=` | append element(s) | List or Obj | | `+=` | append element(s) (2) | List or Obj |
| `sort()` | in-place sort, natural order | void |
| `sortBy(predicate)` | in-place sort bu `predicate` call result (3) | void |
| `sortWith(comparator)` | in-place sort using `comarator` function (4) | void |
| `shiffle()` | in-place shiffle contents | |
(1) (1)
: optimized implementation that override `Array` one : optimized implementation that override `Array` one
@@ -116,7 +139,16 @@ Open end ranges remove head and tail elements:
: `+=` append either a single element, or all elements if the List or other Iterable : `+=` append either a single element, or all elements if the List or other Iterable
instance is appended. If you want to append an Iterable object itself, use `add` instead. instance is appended. If you want to append an Iterable object itself, use `add` instead.
It inherits from [Iterable] too. (3)
: predicate is called on each element, and the returned values are used to sort in natural
order, e.g. is same as `list.sortWith { a,b -> predicate(a) <=> predicate(b) }`
(4)
: comparator callable takes tho arguments and must return: negative value when first is less,
positive if first is greater, and zero if they are equal. For example, the equvalent comparator
for `sort()` will be `sort { a, b -> a <=> b }
It inherits from [Iterable] too and thus all iterable methods are applicable to any list.
## Member inherited from Array ## Member inherited from Array
@@ -134,4 +166,5 @@ It inherits from [Iterable] too.
[Range]: Range.md [Range]: Range.md
[Iterable]: Iterable.md [Iterable]: Iterable.md
+1 -1
View File
@@ -87,7 +87,7 @@ You can use Char as both ends of the closed range:
Exclusive end char ranges are supported too: Exclusive end char ranges are supported too:
('a'..<'c').toList ('a'..<'c').toList
>>> ['a', 'b'] >>> [a,b]
# Instance members # Instance members
+91
View File
@@ -0,0 +1,91 @@
# Regular expressions
In lyng, you create regular expressions using class `Regex` or `String.re` methods:
assert( "\d*".re is Regex )
assert( Regex("\d*") is Regex )
>>> void
We plan to add slash syntax at some point.
To check that some string matches as whole to some regex:
assert( "123".matches("\d{3}".re) )
assert( !"123".matches("\d{4}".re) )
assert( !"1234".matches("\d".re) )
>>> void
To check that _part of the string_ matches some regular expession, use _match operator_ `=~` just like in Ruby, and its
counterpart, _not match_ operator `!~`:
assert( "abc123def" =~ "\d\d\d".re )
assert( "abc" !~ "\d\d\d".re )
>>> void
When you need to find groups, and more detailed match information, use `Regex.find`:
val result = Regex("abc(\d)(\d)(\d)").find( "bad456 good abc123")
assert( result != null )
assertEquals( 12 .. 17, result.range )
assertEquals( "abc123", result[0] )
assertEquals( "1", result[1] )
assertEquals( "2", result[2] )
assertEquals( "3", result[3] )
>>> void
Note that the object `RegexMatch`, returned by [Regex.find], behaves much like in many other languages: it provides the
index range and groups matches as indexes.
Match operator actually also provides `RegexMatch` in `$~` reserved variable (borrowed from Ruby too):
assert( "bad456 good abc123" =~ "abc(\d)(\d)(\d)".re )
assertEquals( 12 .. 17, $~.range )
assertEquals( "abc123", $~[0] )
assertEquals( "1", $~[1] )
assertEquals( "2", $~[2] )
assertEquals( "3", $~[3] )
>>> void
This is often more readable than calling `find`.
Note that `=~` and `!~` operators against strings and regular expressions are commutative, e.g. regular expression and a
string can be either left or right operator, but not both:
assert( "abc" =~ "\wc".re )
assert( "abc" !~ "\w1c".re )
assert( "a\wc".re =~ "abcd" )
assert( "a[a-z]c".re !~ "a2cd" )
>>> void
Also, string indexing is Regex-aware, and works like `Regex.find` (_not findall!_):
assert( "cd" == "abcdef"[ "c.".re ].value )
>>> void
# Regex class reference
| name | description | notes |
|--------------|-------------------------------------|-------|
| matches(str) | true if the whole `str` matches | |
| find(str) | find first match in `str` or null | (1) |
| findAll(str) | find all matches in `str` as [List] | (1) |
(1)
:: See `RegexMatch` class description below
# RegexMatch
| name | description | notes |
|-------|-------------------------------------------|-------|
| range | the [Range] of the match in source string | |
| value | the value that matches | |
| [n] | [List] of group matches | (1) |
(1)
:: the [0] element is always value, [1] is group 1 match of any, etc.
[List]: List.md
[Range]: Range.md
+2 -2
View File
@@ -83,7 +83,7 @@ or whatever implementing [Iterable], is called _splats_. Here is how we use it:
} }
val array = [1,2,3] val array = [1,2,3]
testSplat("start", ...array, "end") testSplat("start", ...array, "end")
>>> ["start", 1, 2, 3, "end"] >>> [start,1,2,3,end]
>>> void >>> void
There could be any number of splats at any positions. You can splat any other [Iterable] type: There could be any number of splats at any positions. You can splat any other [Iterable] type:
@@ -93,7 +93,7 @@ There could be any number of splats at any positions. You can splat any other [I
} }
val range = 1..3 val range = 1..3
testSplat("start", ...range, "end") testSplat("start", ...range, "end")
>>> ["start", 1, 2, 3, "end"] >>> [start,1,2,3,end]
>>> void >>> void
+26
View File
@@ -122,6 +122,32 @@ This way, in turn, can also be shortened, as it is overly popular:
The trick, though, works with strings only, and always provide `Exception` instances, which is good for debugging but The trick, though, works with strings only, and always provide `Exception` instances, which is good for debugging but
most often not enough. most often not enough.
# Exception class
Serializable class that conveys information about the exception. Important members and methods are:
| name | description |
|-------------------|--------------------------------------------------------|
| message | String message |
| stackTrace | lyng stack trace, list of `StackTraceEntry`, see below |
| printStackTrace() | format and print stack trace using println() |
## StackTraceEntry
A simple structire that stores single entry in Lyng stack, it is created automatically on exception creation:
```kotlin
class StackTraceEntry(
val sourceName: String,
val line: Int,
val column: Int,
val sourceString: String
)
```
- `sourceString` is a line extracted from sources. Note that it _is serialized and printed_, so if you want to conceal it, catch all exceptions and filter out sensitive information.
# Custom error classes # Custom error classes
_this functionality is not yet released_ _this functionality is not yet released_
+2 -2
View File
@@ -183,8 +183,8 @@ Important difference from the channels or like, every time you collect the flow,
// and again: // and again:
assertEquals( result, f.toList() ) assertEquals( result, f.toList() )
>>> ["start", 1, 2, 3, 4] >>> [start,1,2,3,4]
>>> ["start", 1, 2, 3, 4] >>> [start,1,2,3,4]
>>> void >>> void
Notice that flow's lambda is not called until actual collection is started. Cold flows are Notice that flow's lambda is not called until actual collection is started. Cold flows are
@@ -16,9 +16,15 @@ fun naiveCountHappyNumbers() {
count count
} }
import lyng.time
// //
// After all optimizations it takes ~120ms. // After all optimizations it takes ~120ms.
// //
//for( r in 1..100 ) {
// val start = Instant.now()
val found = naiveCountHappyNumbers() val found = naiveCountHappyNumbers()
println("Found happy numbers: "+found) // println("Found happy numbers: %d time %s"(found, Instant.now() - start))
assert( found == 55252 ) assert( found == 55252 )
// delay(0.01)
//}
+46
View File
@@ -0,0 +1,46 @@
# Lyng serialization
Lyng has builting binary bit-effective serialization format, called Lynon for LYng Object Notation. It is typed, binary, implements caching, automatic compression, variable-length ints, one-bit Booleans an many nice features.
It is as simple as:
import lyng.serialization
val text = "
We hold these truths to be self-evident, that all men are created equal,
that they are endowed by their Creator with certain unalienable Rights,
that among these are Life, Liberty and the pursuit of Happiness.
"
val encodedBits = Lynon.encode(text)
// decode bits source:
assertEquals( text, Lynon.decode(encodedBits) )
// compression was used automatically
assert( text.length > encodedBits.toBuffer().size )
>>> void
Any class you create is serializable by default; lynon serializes first constructor fields, then any `var` member fields:
import lyng.serialization
class Point(x,y)
val p = Lynon.decode( Lynon.encode( Point(5,6) ) )
assertEquals( 5, p.x )
assertEquals( 6, p.y )
>>> void
just as expected.
Important is to understand that normally `Lynon.decode` wants [BitBuffer], as `Lynon.encode` produces. If you have the regular [Buffer], be sure to convert it:
buffer.toBitInput()
this possibly creates extra zero bits at the end, as bit content could be shorter than byte-grained but for the Lynon format it does not make sense. Note that when you serialize [BitBuffer], exact number of bits is written. To convert bit buffer to bytes:
Lynon.encode("hello").toBuffer()
(topic is incomplete and under construction)
+90 -11
View File
@@ -16,7 +16,8 @@ __Other documents to read__ maybe after this one:
- [math in Lyng](math.md) - [math in Lyng](math.md)
- [time](time.md) and [parallelism](parallelism.md) - [time](time.md) and [parallelism](parallelism.md)
- [parallelism] - multithreaded code, coroutines, etc. - [parallelism] - multithreaded code, coroutines, etc.
- Some class references: [List], [Set], [Map], [Real], [Range], [Iterable], [Iterator], [time manipulation](time.md), [RingBuffer], [Buffer]. - Some class
references: [List], [Set], [Map], [Real], [Range], [Iterable], [Iterator], [time manipulation](time.md), [Array], [RingBuffer], [Buffer].
- Some samples: [combinatorics](samples/combinatorics.lyng.md), national vars and - Some samples: [combinatorics](samples/combinatorics.lyng.md), national vars and
loops: [сумма ряда](samples/сумма_ряда.lyng.md). More at [samples folder](samples) loops: [сумма ряда](samples/сумма_ряда.lyng.md). More at [samples folder](samples)
@@ -225,6 +226,19 @@ It works much like `also`, but is executed in the context of the source object:
assertEquals(p, Point(2,3)) assertEquals(p, Point(2,3))
>>> void >>> void
## run
Executes a block after it returning the value passed by the block. for example, can be used with elvis operator:
var someVar = null
val result = someVar ?: run {
someVar = 121
"reset"
}
assertEquals("reset", result)
assertEquals(121, someVar)
>>> void
## Math ## Math
It is rather simple, like everywhere else: It is rather simple, like everywhere else:
@@ -261,6 +275,8 @@ Logical operation could be used the same
| === | | Any | (2) | | === | | Any | (2) |
| !== | | Any | (2) | | !== | | Any | (2) |
| != | | Any | (1) | | != | | Any | (1) |
| =~ | | | (3) |
| !~ | | | (3) |
| ++a, a++ | | Int | | | ++a, a++ | | Int | |
| --a, a-- | | Int | | | --a, a-- | | Int | |
@@ -272,6 +288,9 @@ Logical operation could be used the same
singleton object, like `null`, are referentially equal too, while string different literals even being equal are most singleton object, like `null`, are referentially equal too, while string different literals even being equal are most
likely referentially not equal likely referentially not equal
(3)
: Implemented now in String and Regex as regular expression match and not match, see [Regex].
Reference quality and object equality example: Reference quality and object equality example:
assert( null == null) // singletons assert( null == null) // singletons
@@ -475,7 +494,8 @@ Lyng has built-in mutable array class `List` with simple literals:
[1, "two", 3.33].size [1, "two", 3.33].size
>>> 3 >>> 3
[List] is an implementation of the type `Array`, and through it `Collection` and [Iterable]. Please read [Iterable], many collection based methods are implemented there. [List] is an implementation of the type `Array`, and through it `Collection` and [Iterable]. Please read [Iterable],
many collection based methods are implemented there.
Lists can contain any type of objects, lists too: Lists can contain any type of objects, lists too:
@@ -499,7 +519,7 @@ Of course, you can splat from anything that is List (or list-like, but it will b
val a = ["one", "two"] val a = ["one", "two"]
val b = [10.1, 20.2] val b = [10.1, 20.2]
["start", ...b, ...a, "end"] ["start", ...b, ...a, "end"]
>>> ["start", 10.1, 20.2, "one", "two", "end"] >>> [start,10.1,20.2,one,two,end]
Of course, you can set any list element: Of course, you can set any list element:
@@ -750,8 +770,8 @@ thrown.
Typical builtin types that are containers (e.g. support `contains`): Typical builtin types that are containers (e.g. support `contains`):
| class | notes | | class | notes |
|------------|------------------------------------------------| |--------------|------------------------------------------------|
| Collection | contains an element (1) | | [Collection] | contains an element (1) |
| Array | faster maybe that Collection's | | Array | faster maybe that Collection's |
| List | faster than Array's | | List | faster than Array's |
| String | character in string or substring in string (3) | | String | character in string or substring in string (3) |
@@ -1124,7 +1144,8 @@ See [more docs on time manipulation](time.md)
# Enums # Enums
For the moment, only simple enums are implemented. Enum is a list of constants, represented also by their _ordinal_ - [Int] value. For the moment, only simple enums are implemented. Enum is a list of constants, represented also by their
_ordinal_ - [Int] value.
enum Color { enum Color {
RED, GREEN, BLUE RED, GREEN, BLUE
@@ -1139,7 +1160,8 @@ For the moment, only simple enums are implemented. Enum is a list of constants,
assertEquals( Color.valueOf("GREEN"), Color.GREEN ) assertEquals( Color.valueOf("GREEN"), Color.GREEN )
>>> void >>> void
Enums are serialized as ordinals. Please note that due to caching, serialized string arrays could be even more compact than enum arrays, until `Lynon.encodeTyped` will be implemented. Enums are serialized as ordinals. Please note that due to caching, serialized string arrays could be even more compact
than enum arrays, until `Lynon.encodeTyped` will be implemented.
# Comments # Comments
@@ -1167,6 +1189,30 @@ See also [math operations](math.md)
The type for the character objects is `Char`. The type for the character objects is `Char`.
### String literal escapes
| escape | ASCII value |
|--------|-----------------------|
| \n | 0x10, newline |
| \r | 0x13, carriage return |
| \t | 0x07, tabulation |
| \\ | \ slash character |
| \" | " double quote |
Other `\c` combinations, where c is any char except mentioned above, are left intact, e.g.:
val s = "\a"
assert(s[0] == '\')
assert(s[1] == 'a')
>>> void
same as:
val s = "\\a"
assert(s[0] == '\')
assert(s[1] == 'a')
>>> void
### Char literal escapes ### Char literal escapes
Are the same as in string literals with little difference: Are the same as in string literals with little difference:
@@ -1174,6 +1220,7 @@ Are the same as in string literals with little difference:
| escape | ASCII value | | escape | ASCII value |
|--------|-------------------| |--------|-------------------|
| \n | 0x10, newline | | \n | 0x10, newline |
| \r | 0x13, carriage return |
| \t | 0x07, tabulation | | \t | 0x07, tabulation |
| \\ | \ slash character | | \\ | \ slash character |
| \' | ' apostrophe | | \' | ' apostrophe |
@@ -1243,9 +1290,26 @@ Open-ended ranges could be used to get start and end too:
assertEquals( "pult", "catapult"[ 4.. ]) assertEquals( "pult", "catapult"[ 4.. ])
>>> void >>> void
### String operations ### String operations
Concatenation is a `+`: `"hello " + name` works as expected. No confusion. Concatenation is a `+`: `"hello " + name` works as expected. No confusion. There is also
[Regex] support for strings, see the link, for example, whole string match:
assert( !"123".matches( "\d\d".re ) )
assert( "123".matches( "\d\d\d".re ) )
>>> void
Extraction:
"abcd42def"[ "\d+".re ].value
>>> "42"
Part match:
assert( "abc foo def" =~ "f[oO]+".re )
assert( "foo" == $~.value )
>>> void
Typical set of String functions includes: Typical set of String functions includes:
@@ -1253,6 +1317,7 @@ Typical set of String functions includes:
|--------------------|------------------------------------------------------------| |--------------------|------------------------------------------------------------|
| lower() | change case to unicode upper | | lower() | change case to unicode upper |
| upper() | change case to unicode lower | | upper() | change case to unicode lower |
| trim() | trim space chars from both ends |
| startsWith(prefix) | true if starts with a prefix | | startsWith(prefix) | true if starts with a prefix |
| endsWith(prefix) | true if ends with a prefix | | endsWith(prefix) | true if ends with a prefix |
| take(n) | get a new string from up to n first characters | | take(n) | get a new string from up to n first characters |
@@ -1262,17 +1327,24 @@ Typical set of String functions includes:
| size | size in characters like `length` because String is [Array] | | size | size in characters like `length` because String is [Array] |
| (args...) | sprintf-like formatting, see [string formatting] | | (args...) | sprintf-like formatting, see [string formatting] |
| [index] | character at index | | [index] | character at index |
| [Range] | substring at range | | [Range] | substring at range (2) |
| [Regex] | find first match of regex, like [Regex.find] (2) |
| s1 + s2 | concatenation | | s1 + s2 | concatenation |
| s1 += s2 | self-modifying concatenation | | s1 += s2 | self-modifying concatenation |
| toReal() | attempts to parse string as a Real value | | toReal() | attempts to parse string as a Real value |
| toInt() | parse string to Int value | | toInt() | parse string to Int value |
| characters() | create [List] of characters (1) | | characters() | create [List] of characters (1) |
| encodeUtf8() | returns [Buffer] with characters encoded to utf8 | | encodeUtf8() | returns [Buffer] with characters encoded to utf8 |
| matches(re) | matches the regular expression (2) |
| | |
(1) (1)
: List is mutable therefore a new copy is created on each call. : List is mutable therefore a new copy is created on each call.
(2)
: See [Regex]
### Literals ### Literals
String literal could be multiline: String literal could be multiline:
@@ -1292,7 +1364,8 @@ if blank, will be removed too, for example:
>>> This is a second line. >>> This is a second line.
>>> void >>> void
- as expected, empty lines and common indent were removed. It is much like kotlin's `""" ... """.trimIndent()` technique, but simpler ;) - as expected, empty lines and common indent were removed. It is much like kotlin's `""" ... """.trimIndent()`
technique, but simpler ;)
# Built-in functions # Built-in functions
@@ -1311,7 +1384,7 @@ See [math functions](math.md). Other general purpose functions are:
| flow {} | create flow sequence, see [parallelism] | | flow {} | create flow sequence, see [parallelism] |
| delay, launch, yield | see [parallelism] | | delay, launch, yield | see [parallelism] |
| cached(builder) | remembers builder() on first invocation and return it then | | cached(builder) | remembers builder() on first invocation and return it then |
| let, also, apply, run | see above, flow controls |
# Built-in constants # Built-in constants
@@ -1343,3 +1416,9 @@ See [math functions](math.md). Other general purpose functions are:
[parallelism]: parallelism.md [parallelism]: parallelism.md
[RingBuffer]: RingBuffer.md [RingBuffer]: RingBuffer.md
[Collection]: Collection.md
[Array]: Array.md
[Regex]: Regex.md
+2 -1
View File
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
import org.jetbrains.kotlin.gradle.dsl.JvmTarget import org.jetbrains.kotlin.gradle.dsl.JvmTarget
group = "net.sergeych" group = "net.sergeych"
version = "0.8.12-SNAPSHOT" version = "0.9.0-SNAPSHOT"
buildscript { buildscript {
repositories { repositories {
@@ -138,6 +138,7 @@ publishing {
} }
} }
//mavenPublishing { //mavenPublishing {
// publishToMavenCentral(SonatypeHost.CENTRAL_PORTAL) // publishToMavenCentral(SonatypeHost.CENTRAL_PORTAL)
// //
@@ -63,7 +63,7 @@ data class Arguments(val list: List<Obj>, val tailBlockMode: Boolean = false) :
return list.map { it.toKotlin(scope) } return list.map { it.toKotlin(scope) }
} }
fun inspect(): String = list.joinToString(", ") { it.inspect() } suspend fun inspect(scope: Scope): String = list.map{ it.inspect(scope)}.joinToString(",")
companion object { companion object {
val EMPTY = Arguments(emptyList()) val EMPTY = Arguments(emptyList())
@@ -211,11 +211,32 @@ class Compiler(
private suspend fun parseTerm(): Accessor? { private suspend fun parseTerm(): Accessor? {
var operand: Accessor? = null var operand: Accessor? = null
// newlines _before_
cc.skipWsTokens()
while (true) { while (true) {
val t = cc.next() val t = cc.next()
val startPos = t.pos val startPos = t.pos
when (t.type) { when (t.type) {
Token.Type.NEWLINE, Token.Type.SEMICOLON, Token.Type.EOF, Token.Type.RBRACE, Token.Type.COMMA -> { // Token.Type.NEWLINE, Token.Type.SINLGE_LINE_COMMENT, Token.Type.MULTILINE_COMMENT-> {
// continue
// }
// very special case chained calls: call()<NL>.call2 {}.call3()
Token.Type.NEWLINE -> {
val saved = cc.savePos()
if (cc.peekNextNonWhitespace().type == Token.Type.DOT) {
// chained call continue from it
continue
} else {
// restore position and stop parsing as a term:
cc.restorePos(saved)
cc.previous()
return operand
}
}
Token.Type.SEMICOLON, Token.Type.EOF, Token.Type.RBRACE, Token.Type.COMMA -> {
cc.previous() cc.previous()
return operand return operand
} }
@@ -376,6 +397,13 @@ class Compiler(
} }
"throw" -> {
val s = parseThrowStatement()
operand = Accessor {
s.execute(it).asReadonly
}
}
else -> operand?.let { left -> else -> operand?.let { left ->
// selector: <lvalue>, '.' , <id> // selector: <lvalue>, '.' , <id>
// we replace operand with selector code, that // we replace operand with selector code, that
@@ -461,7 +489,14 @@ class Compiler(
// range operator // range operator
val isEndInclusive = t.type == Token.Type.DOTDOT val isEndInclusive = t.type == Token.Type.DOTDOT
val left = operand val left = operand
val right = parseExpression() // if it is an open end range, then the end of line could be here that we do not want
// to skip in parseExpression:
val current = cc.current()
val right =
if (current.type == Token.Type.NEWLINE || current.type == Token.Type.SINLGE_LINE_COMMENT)
null
else
parseExpression()
operand = Accessor { operand = Accessor {
ObjRange( ObjRange(
left?.getter?.invoke(it)?.value ?: ObjNull, left?.getter?.invoke(it)?.value ?: ObjNull,
@@ -588,6 +623,8 @@ class Compiler(
var endTokenType: Token.Type? = null var endTokenType: Token.Type? = null
val startPos = cc.savePos() val startPos = cc.savePos()
cc.skipWsTokens()
while (endTokenType == null) { while (endTokenType == null) {
var t = cc.next() var t = cc.next()
when (t.type) { when (t.type) {
@@ -645,7 +682,7 @@ class Compiler(
// important: valid argument list continues with ',' and ends with '->' or ')' // important: valid argument list continues with ',' and ends with '->' or ')'
// otherwise it is not an argument list: // otherwise it is not an argument list:
when (val tt = cc.next().type) { when (val tt = cc.nextNonWhitespace().type) {
Token.Type.RPAREN -> { Token.Type.RPAREN -> {
// end of arguments // end of arguments
endTokenType = tt endTokenType = tt
@@ -857,7 +894,7 @@ class Compiler(
suspend fun parseAnnotation(t: Token): (suspend (Scope, ObjString, Statement) -> Statement) { suspend fun parseAnnotation(t: Token): (suspend (Scope, ObjString, Statement) -> Statement) {
val extraArgs = parseArgsOrNull() val extraArgs = parseArgsOrNull()
println("annotation ${t.value}: args: $extraArgs") // println("annotation ${t.value}: args: $extraArgs")
return { scope, name, body -> return { scope, name, body ->
val extras = extraArgs?.first?.toArguments(scope, extraArgs.second)?.list val extras = extraArgs?.first?.toArguments(scope, extraArgs.second)?.list
val required = listOf(name, body) val required = listOf(name, body)
@@ -948,7 +985,7 @@ class Compiler(
private suspend fun parseWhenStatement(): Statement { private suspend fun parseWhenStatement(): Statement {
// has a value, when(value) ? // has a value, when(value) ?
var t = cc.skipWsTokens() var t = cc.nextNonWhitespace()
return if (t.type == Token.Type.LPAREN) { return if (t.type == Token.Type.LPAREN) {
// when(value) // when(value)
val value = parseStatement() ?: throw ScriptError(cc.currentPos(), "when(value) expected") val value = parseStatement() ?: throw ScriptError(cc.currentPos(), "when(value) expected")
@@ -963,6 +1000,7 @@ class Compiler(
// condition could be a value, in and is clauses: // condition could be a value, in and is clauses:
// parse several conditions for one then clause // parse several conditions for one then clause
// loop cases // loop cases
outer@ while (true) { outer@ while (true) {
@@ -971,7 +1009,7 @@ class Compiler(
// loop conditions // loop conditions
while (true) { while (true) {
t = cc.skipWsTokens() t = cc.nextNonWhitespace()
when (t.type) { when (t.type) {
Token.Type.IN, Token.Type.IN,
@@ -1184,11 +1222,11 @@ class Compiler(
cc.skipTokenOfType(Token.Type.LBRACE) cc.skipTokenOfType(Token.Type.LBRACE)
do { do {
val t = cc.skipWsTokens() val t = cc.nextNonWhitespace()
when (t.type) { when (t.type) {
Token.Type.ID -> { Token.Type.ID -> {
names += t.value names += t.value
val t1 = cc.skipWsTokens() val t1 = cc.nextNonWhitespace()
when (t1.type) { when (t1.type) {
Token.Type.COMMA -> Token.Type.COMMA ->
continue continue
@@ -1327,8 +1365,8 @@ class Compiler(
} }
return statement(body.pos) { ctx -> return statement(body.pos) { cxt ->
val forContext = ctx.copy(start) val forContext = cxt.copy(start)
// loop var: StoredObject // loop var: StoredObject
val loopSO = forContext.addItem(tVar.value, true, ObjNull) val loopSO = forContext.addItem(tVar.value, true, ObjNull)
@@ -1339,15 +1377,28 @@ class Compiler(
if (sourceObj is ObjRange && sourceObj.isIntRange) { if (sourceObj is ObjRange && sourceObj.isIntRange) {
loopIntRange( loopIntRange(
forContext, forContext,
sourceObj.start!!.toInt(), sourceObj.start!!.toLong(),
if (sourceObj.isEndInclusive) sourceObj.end!!.toInt() + 1 else sourceObj.end!!.toInt(), if (sourceObj.isEndInclusive)
loopSO, body, elseStatement, label, canBreak sourceObj.end!!.toLong() + 1
else
sourceObj.end!!.toLong(),
loopSO,
body,
elseStatement,
label,
canBreak
) )
} else if (sourceObj.isInstanceOf(ObjIterable)) { } else if (sourceObj.isInstanceOf(ObjIterable)) {
loopIterable(forContext, sourceObj, loopSO, body, elseStatement, label, canBreak) loopIterable(forContext, sourceObj, loopSO, body, elseStatement, label, canBreak)
} else { } else {
val size = runCatching { sourceObj.invokeInstanceMethod(forContext, "size").toInt() } val size = runCatching { sourceObj.invokeInstanceMethod(forContext, "size").toInt() }
.getOrElse { throw ScriptError(tOp.pos, "object is not enumerable: no size", it) } .getOrElse {
throw ScriptError(
tOp.pos,
"object is not enumerable: no size in $sourceObj",
it
)
}
var result: Obj = ObjVoid var result: Obj = ObjVoid
var breakCaught = false var breakCaught = false
@@ -1357,7 +1408,7 @@ class Compiler(
.getOrElse { .getOrElse {
throw ScriptError( throw ScriptError(
tOp.pos, tOp.pos,
"object is not enumerable: no index access for ${sourceObj.inspect()}", "object is not enumerable: no index access for ${sourceObj.inspect(cxt)}",
it it
) )
} }
@@ -1384,7 +1435,7 @@ class Compiler(
} }
} }
if (!breakCaught && elseStatement != null) { if (!breakCaught && elseStatement != null) {
result = elseStatement.execute(ctx) result = elseStatement.execute(cxt)
} }
result result
} }
@@ -1396,7 +1447,7 @@ class Compiler(
} }
private suspend fun loopIntRange( private suspend fun loopIntRange(
forScope: Scope, start: Int, end: Int, loopVar: ObjRecord, forScope: Scope, start: Long, end: Long, loopVar: ObjRecord,
body: Statement, elseStatement: Statement?, label: String?, catchBreak: Boolean body: Statement, elseStatement: Statement?, label: String?, catchBreak: Boolean
): Obj { ): Obj {
var result: Obj = ObjVoid var result: Obj = ObjVoid
@@ -1404,7 +1455,7 @@ class Compiler(
loopVar.value = iVar loopVar.value = iVar
if (catchBreak) { if (catchBreak) {
for (i in start..<end) { for (i in start..<end) {
iVar.value = i.toLong() iVar.value = i//.toLong()
try { try {
result = body.execute(forScope) result = body.execute(forScope)
} catch (lbe: LoopBreakContinueException) { } catch (lbe: LoopBreakContinueException) {
@@ -1416,7 +1467,7 @@ class Compiler(
} }
} }
} else { } else {
for (i in start.toLong()..<end.toLong()) { for (i in start..<end) {
iVar.value = i iVar.value = i
result = body.execute(forScope) result = body.execute(forScope)
} }
@@ -1957,6 +2008,8 @@ class Compiler(
Operator.simple(Token.Type.NEQ, lastPriority) { c, a, b -> ObjBool(a.compareTo(c, b) != 0) }, Operator.simple(Token.Type.NEQ, lastPriority) { c, a, b -> ObjBool(a.compareTo(c, b) != 0) },
Operator.simple(Token.Type.REF_EQ, lastPriority) { _, a, b -> ObjBool(a === b) }, Operator.simple(Token.Type.REF_EQ, lastPriority) { _, a, b -> ObjBool(a === b) },
Operator.simple(Token.Type.REF_NEQ, lastPriority) { _, a, b -> ObjBool(a !== b) }, Operator.simple(Token.Type.REF_NEQ, lastPriority) { _, a, b -> ObjBool(a !== b) },
Operator.simple(Token.Type.MATCH, lastPriority) { s, a, b -> a.operatorMatch(s,b) },
Operator.simple(Token.Type.NOTMATCH, lastPriority) { s, a, b -> a.operatorNotMatch(s,b) },
// relational <=,... 5 // relational <=,... 5
Operator.simple(Token.Type.LTE, ++lastPriority) { c, a, b -> ObjBool(a.compareTo(c, b) <= 0) }, Operator.simple(Token.Type.LTE, ++lastPriority) { c, a, b -> ObjBool(a.compareTo(c, b) <= 0) },
Operator.simple(Token.Type.LT, lastPriority) { c, a, b -> ObjBool(a.compareTo(c, b) < 0) }, Operator.simple(Token.Type.LT, lastPriority) { c, a, b -> ObjBool(a.compareTo(c, b) < 0) },
@@ -1968,7 +2021,15 @@ class Compiler(
Operator.simple(Token.Type.IS, lastPriority) { _, a, b -> ObjBool(a.isInstanceOf(b)) }, Operator.simple(Token.Type.IS, lastPriority) { _, a, b -> ObjBool(a.isInstanceOf(b)) },
Operator.simple(Token.Type.NOTIS, lastPriority) { _, a, b -> ObjBool(!a.isInstanceOf(b)) }, Operator.simple(Token.Type.NOTIS, lastPriority) { _, a, b -> ObjBool(!a.isInstanceOf(b)) },
Operator.simple(Token.Type.ELVIS, ++lastPriority) { _, a, b -> if (a == ObjNull) b else a }, Operator(Token.Type.ELVIS, ++lastPriority, 2) { _: Pos, a: Accessor, b: Accessor ->
Accessor {
val aa = a.getter(it).value
(
if (aa != ObjNull) aa
else b.getter(it).value
).asReadonly
}
},
// shuttle <=> 6 // shuttle <=> 6
Operator.simple(Token.Type.SHUTTLE, ++lastPriority) { c, a, b -> Operator.simple(Token.Type.SHUTTLE, ++lastPriority) { c, a, b ->
@@ -39,7 +39,6 @@ class CompilerContext(val tokens: List<Token>) {
fun next() = fun next() =
if (currentIndex < tokens.size) tokens[currentIndex++] if (currentIndex < tokens.size) tokens[currentIndex++]
else Token("", tokens.last().pos, Token.Type.EOF) else Token("", tokens.last().pos, Token.Type.EOF)
// throw IllegalStateException("No more tokens")
fun previous() = if (!hasPrevious()) throw IllegalStateException("No previous token") else tokens[--currentIndex] fun previous() = if (!hasPrevious()) throw IllegalStateException("No previous token") else tokens[--currentIndex]
@@ -131,6 +130,28 @@ class CompilerContext(val tokens: List<Token>) {
previous() previous()
} }
fun nextNonWhitespace(): Token {
while (true) {
val t = next()
if (t.type !in wstokens) return t
}
}
/**
* Find next non-whitespace token and return it. The token is not extracted,
* is will be returned on [next] call.
* @return next non-whitespace token without extracting it from tokens list
*/
fun peekNextNonWhitespace(): Token {
while (true) {
val t = next()
if (t.type !in wstokens) {
previous()
return t
}
}
}
inline fun ifNextIs(typeId: Token.Type, f: (Token) -> Unit): Boolean { inline fun ifNextIs(typeId: Token.Type, f: (Token) -> Unit): Boolean {
val t = next() val t = next()
@@ -207,7 +228,7 @@ class CompilerContext(val tokens: List<Token>) {
while (current().type in wstokens) { while (current().type in wstokens) {
next() next()
} }
return next() return current()
} }
companion object { companion object {
@@ -20,10 +20,10 @@ package net.sergeych.lyng
val digitsSet = ('0'..'9').toSet() val digitsSet = ('0'..'9').toSet()
val digits = { d: Char -> d in digitsSet } val digits = { d: Char -> d in digitsSet }
val hexDigits = digitsSet + ('a'..'f') + ('A'..'F') val hexDigits = digitsSet + ('a'..'f') + ('A'..'F')
val idNextChars = { d: Char -> d.isLetter() || d == '_' || d.isDigit() } val idNextChars = { d: Char -> d.isLetter() || d == '_' || d.isDigit() || d == '$' || d == '~' }
@Suppress("unused") @Suppress("unused")
val idFirstChars = { d: Char -> d.isLetter() || d == '_' } val idFirstChars = { d: Char -> d.isLetter() || d == '_' || d == '$' }
fun parseLyng(source: Source): List<Token> { fun parseLyng(source: Source): List<Token> {
val p = Parser(fromPos = source.startPos) val p = Parser(fromPos = source.startPos)
@@ -67,13 +67,16 @@ private class Parser(fromPos: Pos) {
pos.advance() pos.advance()
Token("===", from, Token.Type.REF_EQ) Token("===", from, Token.Type.REF_EQ)
} }
else -> Token("==", from, Token.Type.EQ) else -> Token("==", from, Token.Type.EQ)
} }
} else if (currentChar == '>') { } else if (currentChar == '>') {
pos.advance() pos.advance()
Token("=>", from, Token.Type.EQARROW) Token("=>", from, Token.Type.EQARROW)
} } else if (currentChar == '~') {
else pos.advance()
Token("=~", from, Token.Type.MATCH)
} else
Token("=", from, Token.Type.ASSIGN) Token("=", from, Token.Type.ASSIGN)
} }
@@ -227,6 +230,9 @@ private class Parser(fromPos: Pos) {
Token("!==", from, Token.Type.REF_NEQ) Token("!==", from, Token.Type.REF_NEQ)
} else } else
Token("!=", from, Token.Type.NEQ) Token("!=", from, Token.Type.NEQ)
} else if (currentChar == '~') {
pos.advance()
Token("!~", from, Token.Type.NOTMATCH)
} else } else
Token("!", from, Token.Type.NOT) Token("!", from, Token.Type.NOT)
} }
@@ -310,7 +316,7 @@ private class Parser(fromPos: Pos) {
// Labels processing is complicated! // Labels processing is complicated!
// some@ statement: label 'some', ID 'statement' // some@ statement: label 'some', ID 'statement'
// statement@some: ID 'statement', LABEL 'some'! // statement@some: ID 'statement', LABEL 'some'!
if (ch.isLetter() || ch == '_') { if (idNextChars(ch)) {
val text = ch + loadChars(idNextChars) val text = ch + loadChars(idNextChars)
if (currentChar == '@') { if (currentChar == '@') {
pos.advance() pos.advance()
@@ -404,8 +410,7 @@ private class Parser(fromPos: Pos) {
if (l.isBlank()) { if (l.isBlank()) {
sizes.add(-1) sizes.add(-1)
"" ""
} } else {
else {
val margin = leftMargin(l) val margin = leftMargin(l)
sizes += margin sizes += margin
" ".repeat(margin) + l.trim() " ".repeat(margin) + l.trim()
@@ -433,11 +438,30 @@ private class Parser(fromPos: Pos) {
'\\' -> { '\\' -> {
pos.advance() ?: raise("unterminated string") pos.advance() ?: raise("unterminated string")
when (currentChar) { when (currentChar) {
'n' -> sb.append('\n') 'n' -> {
'r' -> sb.append('\r') sb.append('\n'); pos.advance()
't' -> sb.append('\t') }
'"' -> sb.append('"')
else -> sb.append('\\').append(currentChar) 'r' -> {
sb.append('\r'); pos.advance()
}
't' -> {
sb.append('\t'); pos.advance()
}
'"' -> {
sb.append('"'); pos.advance()
}
'\\' -> {
sb.append('\\'); pos.advance()
}
else -> {
sb.append('\\').append(currentChar)
pos.advance()
}
} }
} }
@@ -136,11 +136,6 @@ open class Scope(
?: thisObj.objClass ?: thisObj.objClass
.getInstanceMemberOrNull(name) .getInstanceMemberOrNull(name)
) )
// ?.also {
// if( name == "predicate") {
// println("got predicate $it")
// }
// }
} }
fun copy(pos: Pos, args: Arguments = Arguments.EMPTY, newThisObj: Obj? = null): Scope = fun copy(pos: Pos, args: Arguments = Arguments.EMPTY, newThisObj: Obj? = null): Scope =
@@ -57,15 +57,15 @@ class Script(
ObjException.addExceptionsToContext(this) ObjException.addExceptionsToContext(this)
addFn("print") { addFn("print") {
for ((i, a) in args.withIndex()) { for ((i, a) in args.withIndex()) {
if (i > 0) print(' ' + a.asStr.value) if (i > 0) print(' ' + a.toString(this).value)
else print(a.asStr.value) else print(a.toString(this).value)
} }
ObjVoid ObjVoid
} }
addFn("println") { addFn("println") {
for ((i, a) in args.withIndex()) { for ((i, a) in args.withIndex()) {
if (i > 0) print(' ' + a.asStr.value) if (i > 0) print(' ' + a.toString(this).value)
else print(a.asStr.value) else print(a.toString(this).value)
} }
println() println()
ObjVoid ObjVoid
@@ -165,13 +165,13 @@ class Script(
val a = requiredArg<Obj>(0) val a = requiredArg<Obj>(0)
val b = requiredArg<Obj>(1) val b = requiredArg<Obj>(1)
if( a.compareTo(this, b) != 0 ) if( a.compareTo(this, b) != 0 )
raiseError(ObjAssertionFailedException(this,"Assertion failed: ${a.inspect()} == ${b.inspect()}")) raiseError(ObjAssertionFailedException(this,"Assertion failed: ${a.inspect(this)} == ${b.inspect(this)}"))
} }
addVoidFn("assertNotEquals") { addVoidFn("assertNotEquals") {
val a = requiredArg<Obj>(0) val a = requiredArg<Obj>(0)
val b = requiredArg<Obj>(1) val b = requiredArg<Obj>(1)
if( a.compareTo(this, b) == 0 ) if( a.compareTo(this, b) == 0 )
raiseError(ObjAssertionFailedException(this,"Assertion failed: ${a.inspect()} != ${b.inspect()}")) raiseError(ObjAssertionFailedException(this,"Assertion failed: ${a.inspect(this)} != ${b.inspect(this)}"))
} }
addFn("assertThrows") { addFn("assertThrows") {
val code = requireOnlyArg<Statement>() val code = requireOnlyArg<Statement>()
@@ -241,6 +241,8 @@ class Script(
addConst("CompletableDeferred", ObjCompletableDeferred.type) addConst("CompletableDeferred", ObjCompletableDeferred.type)
addConst("Mutex", ObjMutex.type) addConst("Mutex", ObjMutex.type)
addConst("Regex", ObjRegex.type)
addFn("launch") { addFn("launch") {
val callable = requireOnlyArg<Statement>() val callable = requireOnlyArg<Statement>()
ObjDeferred(globalDefer { ObjDeferred(globalDefer {
@@ -287,7 +289,7 @@ class Script(
is ObjInt -> delay(a.value * 1000) is ObjInt -> delay(a.value * 1000)
is ObjReal -> delay((a.value * 1000).roundToLong()) is ObjReal -> delay((a.value * 1000).roundToLong())
is ObjDuration -> delay(a.duration) is ObjDuration -> delay(a.duration)
else -> raiseIllegalArgument("Expected Duration, Int or Real, got ${a.inspect()}") else -> raiseIllegalArgument("Expected Duration, Int or Real, got ${a.inspect(this)}")
} }
ObjVoid ObjVoid
} }
@@ -33,6 +33,6 @@ open class ScriptError(val pos: Pos, val errorMessage: String, cause: Throwable?
class ScriptFlowIsNoMoreCollected: Exception() class ScriptFlowIsNoMoreCollected: Exception()
class ExecutionError(val errorObject: ObjException) : ScriptError(errorObject.scope.pos, errorObject.message) class ExecutionError(val errorObject: ObjException) : ScriptError(errorObject.scope.pos, errorObject.message.value)
class ImportException(pos: Pos, message: String) : ScriptError(pos, message) class ImportException(pos: Pos, message: String) : ScriptError(pos, message)
@@ -17,10 +17,14 @@
package net.sergeych.lyng package net.sergeych.lyng
import net.sergeych.lyng.obj.ObjString
class Source(val fileName: String, text: String) { class Source(val fileName: String, text: String) {
val lines = text.lines().map { it.trimEnd() } val lines = text.lines().map { it.trimEnd() }
val objSourceName by lazy { ObjString(fileName) }
companion object { companion object {
val builtIn: Source by lazy { Source("built-in", "") } val builtIn: Source by lazy { Source("built-in", "") }
val UNKNOWN: Source by lazy { Source("UNKNOWN", "") } val UNKNOWN: Source by lazy { Source("UNKNOWN", "") }
@@ -37,7 +37,7 @@ data class Token(val value: String, val pos: Pos, val type: Type) {
ASSIGN, PLUSASSIGN, MINUSASSIGN, STARASSIGN, SLASHASSIGN, PERCENTASSIGN, ASSIGN, PLUSASSIGN, MINUSASSIGN, STARASSIGN, SLASHASSIGN, PERCENTASSIGN,
PLUS2, MINUS2, PLUS2, MINUS2,
IN, NOTIN, IS, NOTIS, IN, NOTIN, IS, NOTIS,
EQ, NEQ, LT, LTE, GT, GTE, REF_EQ, REF_NEQ, EQ, NEQ, LT, LTE, GT, GTE, REF_EQ, REF_NEQ, MATCH, NOTMATCH,
SHUTTLE, SHUTTLE,
AND, BITAND, OR, BITOR, NOT, BITNOT, DOT, ARROW, EQARROW, QUESTION, COLONCOLON, AND, BITAND, OR, BITOR, NOT, BITNOT, DOT, ARROW, EQARROW, QUESTION, COLONCOLON,
SINLGE_LINE_COMMENT, MULTILINE_COMMENT, SINLGE_LINE_COMMENT, MULTILINE_COMMENT,
@@ -21,14 +21,11 @@ import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock import kotlinx.coroutines.sync.withLock
import kotlinx.serialization.SerialName import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable import kotlinx.serialization.Serializable
import net.sergeych.bintools.encodeToHex
import net.sergeych.lyng.* import net.sergeych.lyng.*
import net.sergeych.lynon.LynonDecoder import net.sergeych.lynon.LynonDecoder
import net.sergeych.lynon.LynonEncoder import net.sergeych.lynon.LynonEncoder
import net.sergeych.lynon.LynonType import net.sergeych.lynon.LynonType
import net.sergeych.synctools.ProtectedOp import net.sergeych.synctools.ProtectedOp
import net.sergeych.synctools.withLock
import kotlin.contracts.ExperimentalContracts
open class Obj { open class Obj {
@@ -49,7 +46,7 @@ open class Obj {
private val opInstances = ProtectedOp() private val opInstances = ProtectedOp()
open fun inspect(): String = toString() open suspend fun inspect(scope: Scope): String = toString(scope).value
/** /**
* Some objects are by-value, historically [ObjInt] and [ObjReal] are usually treated as such. * Some objects are by-value, historically [ObjInt] and [ObjReal] are usually treated as such.
@@ -84,14 +81,16 @@ open class Obj {
scope: Scope, scope: Scope,
name: String, name: String,
args: Arguments = Arguments.EMPTY, args: Arguments = Arguments.EMPTY,
onNotFoundResult: Obj?=null onNotFoundResult: (() -> Obj?)? = null
): Obj = ): Obj {
objClass.getInstanceMemberOrNull(name)?.value?.invoke( return objClass.getInstanceMemberOrNull(name)?.value?.invoke(
scope, scope,
this, this,
args) args
?: onNotFoundResult )
?: onNotFoundResult?.invoke()
?: scope.raiseSymbolNotFound(name) ?: scope.raiseSymbolNotFound(name)
}
open suspend fun getInstanceMethod( open suspend fun getInstanceMethod(
scope: Scope, scope: Scope,
@@ -113,8 +112,28 @@ open class Obj {
return invokeInstanceMethod(scope, "contains", other).toBool() return invokeInstanceMethod(scope, "contains", other).toBool()
} }
open val asStr: ObjString by lazy { /**
if (this is ObjString) this else ObjString(this.toString()) * Default toString implementation:
*
* - if the object is a string, returns it
* - otherwise, if not [calledFromLyng], calls Lyng override `toString()` if exists
* - otherwise, meaning either called from Lyng `toString`, or there is no
* Lyng override, returns the object's Kotlin variant of `toString()
*
* Note on kotlin's `toString()`: it is preferred to use this, 'scoped` version,
* as it can execute Lyng code using the scope and being suspending one.
*
* @param scope the scope where the string representation was requested
* @param calledFromLyng true if called from Lyng's `toString`. Normally this parameter should be ignored,
* but it is used to avoid endless recursion in [Obj.toString] base implementation
*/
suspend open fun toString(scope: Scope,calledFromLyng: Boolean=false): ObjString {
return if (this is ObjString) this
else if( !calledFromLyng ) {
invokeInstanceMethod(scope, "toString") {
ObjString(this.toString())
} as ObjString
} else { ObjString(this.toString()) }
} }
/** /**
@@ -159,6 +178,14 @@ open class Obj {
scope.raiseNotImplemented() scope.raiseNotImplemented()
} }
open suspend fun operatorMatch(scope: Scope, other: Obj): Obj {
scope.raiseNotImplemented()
}
open suspend fun operatorNotMatch(scope: Scope, other: Obj): Obj {
return operatorMatch(scope,other).logicalNot(scope)
}
open suspend fun assign(scope: Scope, other: Obj): Obj? = null open suspend fun assign(scope: Scope, other: Obj): Obj? = null
open fun getValue(scope: Scope) = this open fun getValue(scope: Scope) = this
@@ -282,14 +309,26 @@ open class Obj {
return scope return scope
} }
inline fun <reified R: Obj> cast(scope: Scope): R {
castOrNull<R>()?.let { return it }
scope.raiseClassCastError("can't cast ${this::class.simpleName} to ${R::class.simpleName}")
}
inline fun <reified R: Obj> castOrNull(): R? {
(this as? R)?.let { return it }
// todo: check for subclasses
return null
}
companion object { companion object {
val rootObjectType = ObjClass("Obj").apply { val rootObjectType = ObjClass("Obj").apply {
addFn("toString") { addFn("toString", true) {
thisObj.asStr thisObj.toString(this, true)
} }
addFn("inspect", true) { addFn("inspect", true) {
thisObj.inspect().toObj() thisObj.inspect(this).toObj()
} }
addFn("contains") { addFn("contains") {
ObjBool(thisObj.contains(this, args.firstAndOnly())) ObjBool(thisObj.contains(this, args.firstAndOnly()))
@@ -301,10 +340,8 @@ open class Obj {
addFn("apply") { addFn("apply") {
val body = args.firstAndOnly() val body = args.firstAndOnly()
(thisObj as? ObjInstance)?.let { (thisObj as? ObjInstance)?.let {
println("apply in ${thisObj is ObjInstance}, ${it.instanceScope}")
body.callOn(ApplyScope(this, it.instanceScope)) body.callOn(ApplyScope(this, it.instanceScope))
} ?: run { } ?: run {
println("apply on non-instance $thisObj")
body.callOn(this) body.callOn(this)
} }
thisObj thisObj
@@ -313,6 +350,9 @@ open class Obj {
args.firstAndOnly().callOn(copy(Arguments(thisObj))) args.firstAndOnly().callOn(copy(Arguments(thisObj)))
thisObj thisObj
} }
addFn("run") {
args.firstAndOnly().callOn(this)
}
addFn("getAt") { addFn("getAt") {
requireExactCount(1) requireExactCount(1)
thisObj.getAt(this, requiredArg<Obj>(0)) thisObj.getAt(this, requiredArg<Obj>(0))
@@ -387,9 +427,14 @@ object ObjNull : Obj() {
scope.raiseNPE() scope.raiseNPE()
} }
override suspend fun invokeInstanceMethod(scope: Scope, name: String, args: Arguments, onNotFoundResult: Obj?): Obj { // override suspend fun invokeInstanceMethod(
scope.raiseNPE() // scope: Scope,
} // name: String,
// args: Arguments,
// onNotFoundResult: (()->Obj?)?
// ): Obj {
// scope.raiseNPE()
// }
override suspend fun getAt(scope: Scope, index: Obj): Obj { override suspend fun getAt(scope: Scope, index: Obj): Obj {
scope.raiseNPE() scope.raiseNPE()
@@ -431,6 +476,9 @@ object ObjNull : Obj() {
} }
} }
/**
* TODO: get rid of it. Maybe we ise some Lyng inheritance instead
*/
interface Numeric { interface Numeric {
val longValue: Long val longValue: Long
val doubleValue: Double val doubleValue: Double
@@ -461,129 +509,11 @@ fun Obj.toBool(): Boolean =
data class ObjNamespace(val name: String) : Obj() { data class ObjNamespace(val name: String) : Obj() {
override val objClass by lazy { ObjClass(name) } override val objClass by lazy { ObjClass(name) }
override fun inspect(): String = "Ns[$name]" override suspend fun inspect(scope: Scope): String = "Ns[$name]"
override fun toString(): String { override fun toString(): String {
return "package $name" return "package $name"
} }
} }
open class ObjException(exceptionClass: ExceptionClass, val scope: Scope, val message: String) : Obj() {
constructor(name: String, scope: Scope, message: String) : this(
getOrCreateExceptionClass(name),
scope,
message
)
constructor(scope: Scope, message: String) : this(Root, scope, message)
fun raise(): Nothing {
throw ExecutionError(this)
}
override val objClass: ObjClass = exceptionClass
override fun toString(): String {
return "ObjException:${objClass.className}:${scope.pos}@${hashCode().encodeToHex()}"
}
companion object {
class ExceptionClass(val name: String, vararg parents: ObjClass) : ObjClass(name, *parents) {
override suspend fun callOn(scope: Scope): Obj {
val message = scope.args.getOrNull(0)?.toString() ?: name
return ObjException(this, scope, message)
}
override fun toString(): String = "ExceptionClass[$name]@${hashCode().encodeToHex()}"
}
val Root = ExceptionClass("Throwable").apply {
addConst("message", statement {
(thisObj as ObjException).message.toObj()
})
}
private val op = ProtectedOp()
private val existingErrorClasses = mutableMapOf<String, ExceptionClass>()
@OptIn(ExperimentalContracts::class)
protected fun getOrCreateExceptionClass(name: String): ExceptionClass {
return op.withLock {
existingErrorClasses.getOrPut(name) {
ExceptionClass(name, Root)
}
}
}
/**
* Get [ObjClass] for error class by name if exists.
*/
@OptIn(ExperimentalContracts::class)
fun getErrorClass(name: String): ObjClass? = op.withLock {
existingErrorClasses[name]
}
fun addExceptionsToContext(scope: Scope) {
scope.addConst("Exception", Root)
existingErrorClasses["Exception"] = Root
for (name in listOf(
"NullReferenceException",
"AssertionFailedException",
"ClassCastException",
"IndexOutOfBoundsException",
"IllegalArgumentException",
"NoSuchElementException",
"IllegalAssignmentException",
"SymbolNotDefinedException",
"IterationEndException",
"AccessException",
"UnknownException",
"NotFoundException"
)) {
scope.addConst(name, getOrCreateExceptionClass(name))
}
}
}
}
class ObjNullReferenceException(scope: Scope) : ObjException("NullReferenceException", scope, "object is null")
class ObjAssertionFailedException(scope: Scope, message: String) :
ObjException("AssertionFailedException", scope, message)
class ObjClassCastException(scope: Scope, message: String) : ObjException("ClassCastException", scope, message)
class ObjIndexOutOfBoundsException(scope: Scope, message: String = "index out of bounds") :
ObjException("IndexOutOfBoundsException", scope, message)
class ObjIllegalArgumentException(scope: Scope, message: String = "illegal argument") :
ObjException("IllegalArgumentException", scope, message)
class ObjIllegalStateException(scope: Scope, message: String = "illegal state") :
ObjException("IllegalStateException", scope, message)
@Suppress("unused")
class ObjNoSuchElementException(scope: Scope, message: String = "no such element") :
ObjException("IllegalArgumentException", scope, message)
class ObjIllegalAssignmentException(scope: Scope, message: String = "illegal assignment") :
ObjException("NoSuchElementException", scope, message)
class ObjSymbolNotDefinedException(scope: Scope, message: String = "symbol is not defined") :
ObjException("SymbolNotDefinedException", scope, message)
class ObjIterationFinishedException(scope: Scope) :
ObjException("IterationEndException", scope, "iteration finished")
class ObjAccessException(scope: Scope, message: String = "access not allowed error") :
ObjException("AccessException", scope, message)
class ObjUnknownException(scope: Scope, message: String = "access not allowed error") :
ObjException("UnknownException", scope, message)
class ObjIllegalOperationException(scope: Scope, message: String = "Operation is illegal") :
ObjException("IllegalOperationException", scope, message)
class ObjNotFoundException(scope: Scope, message: String = "not found") :
ObjException("NotFoundException", scope, message)
@@ -51,5 +51,25 @@ val ObjArray by lazy {
ObjRange(0.toObj(), thisObj.invokeInstanceMethod(this, "size"), false) ObjRange(0.toObj(), thisObj.invokeInstanceMethod(this, "size"), false)
} }
addFn("binarySearch") {
val target = args.firstAndOnly()
var low = 0
var high = thisObj.invokeInstanceMethod(this, "size").toInt() - 1
while (low <= high) {
val mid = (low + high) / 2
val midVal = thisObj.getAt(this, ObjInt(mid.toLong()))
val cmp = midVal.compareTo(this, target)
when {
cmp == 0 -> return@addFn (mid).toObj()
cmp > 0 -> high = mid - 1
else -> low = mid + 1
}
}
// Элемент не найден, возвращаем -(точка вставки) - 1
(-low - 1).toObj()
}
} }
} }
@@ -23,7 +23,6 @@ import net.sergeych.lynon.LynonEncoder
import net.sergeych.lynon.LynonType import net.sergeych.lynon.LynonType
data class ObjBool(val value: Boolean) : Obj() { data class ObjBool(val value: Boolean) : Obj() {
override val asStr by lazy { ObjString(value.toString()) }
override suspend fun compareTo(scope: Scope, other: Obj): Int { override suspend fun compareTo(scope: Scope, other: Obj): Int {
if (other !is ObjBool) return -2 if (other !is ObjBool) return -2
@@ -24,6 +24,7 @@ import net.sergeych.bintools.encodeToHex
import net.sergeych.bintools.toDump import net.sergeych.bintools.toDump
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.statement import net.sergeych.lyng.statement
import net.sergeych.lynon.BitArray
import net.sergeych.lynon.LynonDecoder import net.sergeych.lynon.LynonDecoder
import net.sergeych.lynon.LynonEncoder import net.sergeych.lynon.LynonEncoder
import net.sergeych.lynon.LynonType import net.sergeych.lynon.LynonType
@@ -86,7 +87,7 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
byteArray + other.toFlow(scope).map { it.toLong().toUByte() }.toList().toTypedArray() byteArray + other.toFlow(scope).map { it.toLong().toUByte() }.toList().toTypedArray()
.toUByteArray() .toUByteArray()
) )
} else scope.raiseIllegalArgument("can't concatenate buffer with ${other.inspect()}") } else scope.raiseIllegalArgument("can't concatenate buffer with ${other.inspect(scope)}")
} }
override fun toString(): String = base64 override fun toString(): String = base64
@@ -106,7 +107,7 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
encoder.encodeCachedBytes(byteArray.asByteArray()) encoder.encodeCachedBytes(byteArray.asByteArray())
} }
override fun inspect(): String = "Buf($base64)" override suspend fun inspect(scope: Scope): String = "Buf($base64)"
companion object { companion object {
private suspend fun createBufferFrom(scope: Scope, obj: Obj): ObjBuffer = private suspend fun createBufferFrom(scope: Scope, obj: Obj): ObjBuffer =
@@ -128,7 +129,7 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
) )
} else } else
scope.raiseIllegalArgument( scope.raiseIllegalArgument(
"can't construct buffer from ${obj.inspect()}" "can't construct buffer from ${obj.inspect(scope)}"
) )
} }
} }
@@ -148,7 +149,7 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
is ObjChar -> b.value.code.toUByte() is ObjChar -> b.value.code.toUByte()
is ObjInt -> b.value.toUByte() is ObjInt -> b.value.toUByte()
else -> scope.raiseIllegalArgument( else -> scope.raiseIllegalArgument(
"invalid byte value for buffer constructor at index $i: ${b.inspect()}" "invalid byte value for buffer constructor at index $i: ${b.inspect(scope)}"
) )
} }
data[i] = code data[i] = code
@@ -200,6 +201,9 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
thisAs<ObjBuffer>().byteArray.toByteArray().toDump() thisAs<ObjBuffer>().byteArray.toByteArray().toDump()
) )
} }
addFn("toBitInput") {
ObjBitBuffer(BitArray(thisAs<ObjBuffer>().byteArray, 8))
}
} }
} }
} }
@@ -28,7 +28,7 @@ class ObjChar(val value: Char): Obj() {
override fun toString(): String = value.toString() override fun toString(): String = value.toString()
override fun inspect(): String = "'$value'" override suspend fun inspect(scope: Scope): String = "'$value'"
override fun hashCode(): Int { override fun hashCode(): Int {
return value.hashCode() return value.hashCode()
@@ -68,6 +68,10 @@ open class ObjClass(
return instance return instance
} }
suspend fun callWithArgs(scope: Scope, vararg plainArgs: Obj): Obj {
return callOn(scope.copy(Arguments(*plainArgs)))
}
fun createField( fun createField(
name: String, name: String,
@@ -140,13 +144,16 @@ open class ObjClass(
?: super.writeField(scope, name, newValue) ?: super.writeField(scope, name, newValue)
} }
override suspend fun invokeInstanceMethod(scope: Scope, name: String, args: Arguments, override suspend fun invokeInstanceMethod(
onNotFoundResult: Obj?): Obj { scope: Scope, name: String, args: Arguments,
onNotFoundResult: (() -> Obj?)?
): Obj {
return classScope?.objects?.get(name)?.value?.invoke(scope, this, args) return classScope?.objects?.get(name)?.value?.invoke(scope, this, args)
?: super.invokeInstanceMethod(scope, name, args, onNotFoundResult) ?: super.invokeInstanceMethod(scope, name, args, onNotFoundResult)
} }
open suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj = scope.raiseNotImplemented() open suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj =
scope.raiseNotImplemented()
} }
@@ -18,8 +18,8 @@
package net.sergeych.lyng.obj package net.sergeych.lyng.obj
/** /**
* Collection is an iterator with `size`] * Collection is an iterator with `size`
*/ */
val ObjCollection = ObjClass("Collection", ObjIterable).apply { val ObjCollection = ObjClass("Collection", ObjIterable).apply {
} }
@@ -57,7 +57,7 @@ class ObjDuration(val duration: Duration) : Obj() {
override suspend fun callOn(scope: Scope): Obj { override suspend fun callOn(scope: Scope): Obj {
val args = scope.args val args = scope.args
if( args.list.size > 1 ) if( args.list.size > 1 )
scope.raiseIllegalArgument("can't construct Duration(${args.inspect()})") scope.raiseIllegalArgument("can't construct Duration(${args.inspect(scope)})")
val a0 = args.list.getOrNull(0) val a0 = args.list.getOrNull(0)
return ObjDuration( return ObjDuration(
@@ -66,7 +66,7 @@ class ObjDuration(val duration: Duration) : Obj() {
is ObjInt -> a0.value.seconds is ObjInt -> a0.value.seconds
is ObjReal -> a0.value.seconds is ObjReal -> a0.value.seconds
else -> { else -> {
scope.raiseIllegalArgument("can't construct Instant(${args.inspect()})") scope.raiseIllegalArgument("can't construct Instant(${args.inspect(scope)})")
} }
} }
) )
@@ -0,0 +1,221 @@
/*
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.obj
import net.sergeych.bintools.encodeToHex
import net.sergeych.lyng.*
import net.sergeych.lynon.LynonDecoder
import net.sergeych.lynon.LynonEncoder
import net.sergeych.lynon.LynonType
import net.sergeych.mptools.CachedExpression
import net.sergeych.synctools.ProtectedOp
import net.sergeych.synctools.withLock
import kotlin.contracts.ExperimentalContracts
/**
* note on [getStackTrace]. If [useStackTrace] is not null, it is used instead. Otherwise, it is calculated
* from the current scope which is treated as exception scope. It is used to restore serialized
* exception with stack trace; the scope of the de-serialized exception is not valid
* for stack unwinding.
*/
open class ObjException(
val exceptionClass: ExceptionClass,
val scope: Scope,
val message: ObjString,
@Suppress("unused") val extraData: Obj = ObjNull,
val useStackTrace: ObjList? = null
) : Obj() {
constructor(name: String, scope: Scope, message: String) : this(
getOrCreateExceptionClass(name),
scope,
ObjString(message)
)
private val cachedStackTrace = CachedExpression(initialValue = useStackTrace)
suspend fun getStackTrace(): ObjList {
return cachedStackTrace.get {
val result = ObjList()
val cls = scope.get("StackTraceEntry")!!.value as ObjClass
var s: Scope? = scope
var lastPos: Pos? = null
while (s != null) {
val pos = s.pos
if (pos != lastPos && !pos.currentLine.isEmpty()) {
result.list += cls.callWithArgs(
scope,
pos.source.objSourceName,
ObjInt(pos.line.toLong()),
ObjInt(pos.column.toLong()),
ObjString(pos.currentLine)
)
}
s = s.parent
lastPos = pos
}
result
}
}
constructor(scope: Scope, message: String) : this(Root, scope, ObjString(message))
fun raise(): Nothing {
throw ExecutionError(this)
}
override val objClass: ObjClass = exceptionClass
override suspend fun toString(scope: Scope, calledFromLyng: Boolean): ObjString {
val at = getStackTrace().list.firstOrNull()?.toString(scope)
?: ObjString("(unknown)")
return ObjString("${objClass.className}: $message at $at")
}
override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
encoder.encodeAny(scope, exceptionClass.classNameObj)
encoder.encodeAny(scope, message)
encoder.encodeAny(scope, extraData)
encoder.encodeAny(scope, getStackTrace())
}
companion object {
class ExceptionClass(val name: String, vararg parents: ObjClass) : ObjClass(name, *parents) {
override suspend fun callOn(scope: Scope): Obj {
val message = scope.args.getOrNull(0)?.toString(scope) ?: ObjString(name)
return ObjException(this, scope, message)
}
override fun toString(): String = "ExceptionClass[$name]@${hashCode().encodeToHex()}"
override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj {
return try {
val lyngClass = decoder.decodeAnyAs<ObjString>(scope).value.let {
((scope[it] ?: scope.raiseIllegalArgument("Unknown exception class: $it"))
.value as? ExceptionClass)
?: scope.raiseIllegalArgument("Not an exception class: $it")
}
ObjException(
lyngClass,
scope,
decoder.decodeAnyAs<ObjString>(scope),
decoder.decodeAny(scope),
decoder.decodeAnyAs<ObjList>(scope)
)
} catch (e: ScriptError) {
throw e
} catch (e: Exception) {
e.printStackTrace()
scope.raiseIllegalArgument("Failed to deserialize exception: ${e.message}")
}
}
}
val Root = ExceptionClass("Throwable").apply {
addConst("message", statement {
(thisObj as ObjException).message.toObj()
})
addFn("stackTrace") {
(thisObj as ObjException).getStackTrace()
}
}
private val op = ProtectedOp()
private val existingErrorClasses = mutableMapOf<String, ExceptionClass>()
@OptIn(ExperimentalContracts::class)
protected fun getOrCreateExceptionClass(name: String): ExceptionClass {
return op.withLock {
existingErrorClasses.getOrPut(name) {
ExceptionClass(name, Root)
}
}
}
/**
* Get [ObjClass] for error class by name if exists.
*/
@OptIn(ExperimentalContracts::class)
fun getErrorClass(name: String): ObjClass? = op.withLock {
existingErrorClasses[name]
}
fun addExceptionsToContext(scope: Scope) {
scope.addConst("Exception", Root)
existingErrorClasses["Exception"] = Root
for (name in listOf(
"NullReferenceException",
"AssertionFailedException",
"ClassCastException",
"IndexOutOfBoundsException",
"IllegalArgumentException",
"NoSuchElementException",
"IllegalAssignmentException",
"SymbolNotDefinedException",
"IterationEndException",
"AccessException",
"UnknownException",
"NotFoundException"
)) {
scope.addConst(name, getOrCreateExceptionClass(name))
}
}
}
}
class ObjNullReferenceException(scope: Scope) : ObjException("NullReferenceException", scope, "object is null")
class ObjAssertionFailedException(scope: Scope, message: String) :
ObjException("AssertionFailedException", scope, message)
class ObjClassCastException(scope: Scope, message: String) : ObjException("ClassCastException", scope, message)
class ObjIndexOutOfBoundsException(scope: Scope, message: String = "index out of bounds") :
ObjException("IndexOutOfBoundsException", scope, message)
class ObjIllegalArgumentException(scope: Scope, message: String = "illegal argument") :
ObjException("IllegalArgumentException", scope, message)
class ObjIllegalStateException(scope: Scope, message: String = "illegal state") :
ObjException("IllegalStateException", scope, message)
@Suppress("unused")
class ObjNoSuchElementException(scope: Scope, message: String = "no such element") :
ObjException("IllegalArgumentException", scope, message)
class ObjIllegalAssignmentException(scope: Scope, message: String = "illegal assignment") :
ObjException("NoSuchElementException", scope, message)
class ObjSymbolNotDefinedException(scope: Scope, message: String = "symbol is not defined") :
ObjException("SymbolNotDefinedException", scope, message)
class ObjIterationFinishedException(scope: Scope) :
ObjException("IterationEndException", scope, "iteration finished")
class ObjAccessException(scope: Scope, message: String = "access not allowed error") :
ObjException("AccessException", scope, message)
class ObjUnknownException(scope: Scope, message: String = "access not allowed error") :
ObjException("UnknownException", scope, message)
class ObjIllegalOperationException(scope: Scope, message: String = "Operation is illegal") :
ObjException("IllegalOperationException", scope, message)
class ObjNotFoundException(scope: Scope, message: String = "not found") :
ObjException("NotFoundException", scope, message)
@@ -48,7 +48,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
} }
override suspend fun invokeInstanceMethod(scope: Scope, name: String, args: Arguments, override suspend fun invokeInstanceMethod(scope: Scope, name: String, args: Arguments,
onNotFoundResult: Obj?): Obj = onNotFoundResult: (()->Obj?)?): Obj =
instanceScope[name]?.let { instanceScope[name]?.let {
if (it.visibility.isPublic) if (it.visibility.isPublic)
it.value.invoke( it.value.invoke(
@@ -35,7 +35,14 @@ class ObjInstanceClass(val name: String) : ObjClass(name) {
val newScope = scope.copy(args = Arguments(args)) val newScope = scope.copy(args = Arguments(args))
return (callOn(newScope) as ObjInstance).apply { return (callOn(newScope) as ObjInstance).apply {
deserializeStateVars(scope, decoder) deserializeStateVars(scope, decoder)
invokeInstanceMethod(scope, "onDeserialized", onNotFoundResult = ObjVoid) invokeInstanceMethod(scope, "onDeserialized") { ObjVoid }
}
}
init {
addFn("toString", true) {
println("-------------- tos! --------------")
ObjString(thisObj.toString())
} }
} }
@@ -117,7 +117,7 @@ class ObjInstant(val instant: Instant,val truncateMode: LynonSettings.InstantTru
is ObjInstant -> a0.instant is ObjInstant -> a0.instant
else -> { else -> {
scope.raiseIllegalArgument("can't construct Instant(${args.inspect()})") scope.raiseIllegalArgument("can't construct Instant(${args.inspect(scope)})")
} }
} }
) )
@@ -23,7 +23,6 @@ import net.sergeych.lynon.LynonEncoder
import net.sergeych.lynon.LynonType import net.sergeych.lynon.LynonType
class ObjInt(var value: Long, override val isConst: Boolean = false) : Obj(), Numeric { 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 longValue get() = value
override val doubleValue get() = value.toDouble() override val doubleValue get() = value.toDouble()
override val toObjInt get() = this override val toObjInt get() = this
@@ -62,7 +61,7 @@ class ObjInt(var value: Long, override val isConst: Boolean = false) : Obj(), Nu
override fun toString(): String = value.toString() override fun toString(): String = value.toString()
override val objClass: ObjClass = type override val objClass: ObjClass by lazy { type }
override suspend fun plus(scope: Scope, other: Obj): Obj = override suspend fun plus(scope: Scope, other: Obj): Obj =
if (other is ObjInt) if (other is ObjInt)
@@ -119,12 +119,6 @@ val ObjIterable by lazy {
ObjList(result) ObjList(result)
} }
// addFn("drop" ) {
// var n = requireOnlyArg<ObjInt>().value.toInt()
// if( n < 0 ) raiseIllegalArgument("drop($n): should be positive")
// val it = callMethod<>()
// }
addFn("isEmpty") { addFn("isEmpty") {
ObjBool( ObjBool(
thisObj.invokeInstanceMethod(this, "iterator") thisObj.invokeInstanceMethod(this, "iterator")
@@ -132,5 +126,20 @@ val ObjIterable by lazy {
.not() .not()
) )
} }
addFn("sortedWith") {
val list = thisObj.callMethod<ObjList>(this, "toList")
val comparator = requireOnlyArg<Statement>()
list.quicksort { a, b ->
comparator.call(this, a, b).toInt()
}
list
}
addFn("reversed") {
val list = thisObj.callMethod<ObjList>(this, "toList")
list.list.reverse()
list
}
} }
} }
@@ -95,5 +95,5 @@ suspend fun Obj.enumerate(scope: Scope,callback: suspend (Obj)->Boolean) {
} }
} }
if (closeIt) if (closeIt)
iterator.invokeInstanceMethod(scope, "cancelIteration", onNotFoundResult = ObjVoid) iterator.invokeInstanceMethod(scope, "cancelIteration") { ObjVoid }
} }
@@ -18,6 +18,7 @@
package net.sergeych.lyng.obj package net.sergeych.lyng.obj
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.Statement
import net.sergeych.lyng.statement import net.sergeych.lyng.statement
import net.sergeych.lynon.LynonDecoder import net.sergeych.lynon.LynonDecoder
import net.sergeych.lynon.LynonEncoder import net.sergeych.lynon.LynonEncoder
@@ -25,10 +26,6 @@ import net.sergeych.lynon.LynonType
class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() { class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
override fun toString(): String = "[${
list.joinToString(separator = ", ") { it.inspect() }
}]"
override suspend fun getAt(scope: Scope, index: Obj): Obj { override suspend fun getAt(scope: Scope, index: Obj): Obj {
return when (index) { return when (index) {
is ObjInt -> { is ObjInt -> {
@@ -65,7 +62,7 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
} }
} }
else -> scope.raiseIllegalArgument("Illegal index object for a list: ${index.inspect()}") else -> scope.raiseIllegalArgument("Illegal index object for a list: ${index.inspect(scope)}")
} }
} }
@@ -131,6 +128,33 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
return list.map { it.toKotlin(scope) } return list.map { it.toKotlin(scope) }
} }
suspend fun quicksort(compare: suspend (Obj, Obj) -> Int) = quicksort(compare, 0, list.size - 1)
suspend fun quicksort(compare: suspend (Obj, Obj) -> Int, left: Int, right: Int) {
if (left >= right) return
var i = left
var j = right
val pivot = list[left]
while (i < j) {
// Сдвигаем j влево, пока элемент меньше pivot
while (i < j && compare(list[j], pivot) >= 0) {
j--
}
// Сдвигаем i вправо, пока элемент больше pivot
while (i < j && compare(list[i], pivot) <= 0) {
i++
}
if (i < j) {
list.swap(i, j)
}
}
// После завершения i == j, ставим pivot на своё место
list.swap(left, i)
// Рекурсивно сортируем левую и правую части
quicksort(compare, left, i - 1)
quicksort(compare, i + 1, right)
}
override fun hashCode(): Int { override fun hashCode(): Int {
// check? // check?
return list.hashCode() return list.hashCode()
@@ -239,8 +263,27 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
} }
self self
} }
addFn("sortWith") {
val comparator = requireOnlyArg<Statement>()
thisAs<ObjList>().quicksort { a, b -> comparator.call(this, a, b).toInt() }
ObjVoid
}
addFn("shuffle") {
thisAs<ObjList>().list.shuffle()
ObjVoid
}
} }
} }
} }
// Расширение MutableList для удобного обмена элементами
fun <T>MutableList<T>.swap(i: Int, j: Int) {
if (i in indices && j in indices) {
val temp = this[i]
this[i] = this[j]
this[j] = temp
}
}
@@ -28,7 +28,7 @@ class ObjMutableBuffer(byteArray: UByteArray) : ObjBuffer(byteArray) {
is ObjInt -> newValue.value.toUByte() is ObjInt -> newValue.value.toUByte()
is ObjChar -> newValue.value.code.toUByte() is ObjChar -> newValue.value.code.toUByte()
else -> scope.raiseIllegalArgument( else -> scope.raiseIllegalArgument(
"invalid byte value for buffer at index ${index.inspect()}: ${newValue.inspect()}" "invalid byte value for buffer at index ${index.inspect(scope)}: ${newValue.inspect(scope)}"
) )
} }
} }
@@ -54,7 +54,7 @@ class ObjMutableBuffer(byteArray: UByteArray) : ObjBuffer(byteArray) {
) )
} else } else
scope.raiseIllegalArgument( scope.raiseIllegalArgument(
"can't construct buffer from ${obj.inspect()}" "can't construct buffer from ${obj.inspect(scope)}"
) )
} }
} }
@@ -74,7 +74,7 @@ class ObjMutableBuffer(byteArray: UByteArray) : ObjBuffer(byteArray) {
is ObjChar -> b.value.code.toUByte() is ObjChar -> b.value.code.toUByte()
is ObjInt -> b.value.toUByte() is ObjInt -> b.value.toUByte()
else -> scope.raiseIllegalArgument( else -> scope.raiseIllegalArgument(
"invalid byte value for buffer constructor at index $i: ${b.inspect()}" "invalid byte value for buffer constructor at index $i: ${b.inspect(scope)}"
) )
} }
data[i] = code data[i] = code
@@ -26,12 +26,12 @@ class ObjRange(val start: Obj?, val end: Obj?, val isEndInclusive: Boolean) : Ob
override val objClass: ObjClass = type override val objClass: ObjClass = type
override fun toString(): String { override suspend fun toString(scope: Scope,calledFromLyng: Boolean): ObjString {
val result = StringBuilder() val result = StringBuilder()
result.append("${start?.inspect() ?: '∞'} ..") result.append("${start?.inspect(scope) ?: '∞'} ..")
if (!isEndInclusive) result.append('<') if (!isEndInclusive) result.append('<')
result.append(" ${end?.inspect() ?: '∞'}") result.append(" ${end?.inspect(scope) ?: '∞'}")
return result.toString() return ObjString(result.toString())
} }
/** /**
@@ -52,11 +52,11 @@ class ObjRange(val start: Obj?, val end: Obj?, val isEndInclusive: Boolean) : Ob
* if start is not ObjInt, raises [ObjIllegalArgumentException] * if start is not ObjInt, raises [ObjIllegalArgumentException]
* otherwise returns start.value.toInt() * otherwise returns start.value.toInt()
*/ */
fun startInt(scope: Scope): Int = suspend fun startInt(scope: Scope): Int =
if( start == null || start is ObjNull) 0 if( start == null || start is ObjNull) 0
else { else {
if( start is ObjInt) start.value.toInt() if( start is ObjInt) start.value.toInt()
else scope.raiseIllegalArgument("start is not Int: ${start.inspect()}") else scope.raiseIllegalArgument("start is not Int: ${start.inspect(scope)}")
} }
suspend fun containsRange(scope: Scope, other: ObjRange): Boolean { suspend fun containsRange(scope: Scope, other: ObjRange): Boolean {
@@ -27,7 +27,6 @@ import kotlin.math.floor
import kotlin.math.roundToLong import kotlin.math.roundToLong
data class ObjReal(val value: Double) : Obj(), Numeric { data class ObjReal(val value: Double) : Obj(), Numeric {
override val asStr by lazy { ObjString(value.toString()) }
override val longValue: Long by lazy { floor(value).toLong() } override val longValue: Long by lazy { floor(value).toLong() }
override val doubleValue: Double by lazy { value } override val doubleValue: Double by lazy { value }
override val toObjInt: ObjInt by lazy { ObjInt(longValue) } override val toObjInt: ObjInt by lazy { ObjInt(longValue) }
@@ -0,0 +1,112 @@
/*
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.obj
import net.sergeych.lyng.Scope
class ObjRegex(val regex: Regex) : Obj() {
override val objClass = type
override suspend fun operatorMatch(scope: Scope, other: Obj): Obj {
return regex.find(other.cast<ObjString>(scope).value)?.let {
scope.addConst("$~", ObjRegexMatch(it))
ObjTrue
} ?: ObjFalse
}
fun find(s: ObjString): Obj =
regex.find(s.value)?.let { ObjRegexMatch(it) } ?: ObjNull
companion object {
val type by lazy {
object : ObjClass("Regex") {
override suspend fun callOn(scope: Scope): Obj {
return ObjRegex(
scope.requireOnlyArg<ObjString>().value.toRegex()
)
}
}.apply {
addFn("matches") {
ObjBool(args.firstAndOnly().toString().matches(thisAs<ObjRegex>().regex))
}
addFn("find") {
thisAs<ObjRegex>().find(requireOnlyArg<ObjString>())
}
addFn("findAll") {
val s = requireOnlyArg<ObjString>().value
ObjList(thisAs<ObjRegex>().regex.findAll(s).map { ObjRegexMatch(it) }.toMutableList())
}
}
}
}
}
class ObjRegexMatch(val match: MatchResult) : Obj() {
override val objClass = type
val objGroups: ObjList by lazy {
ObjList(
match.groups.map { it?.let { ObjString(it.value) } ?: ObjNull }.toMutableList()
)
}
val objValue by lazy { ObjString(match.value) }
val objRange: ObjRange by lazy {
val r = match.range
ObjRange(
ObjInt(r.first.toLong()),
ObjInt(r.last.toLong()),
false
)
}
override suspend fun toString(scope: Scope,calledFromLyng: Boolean): ObjString {
return ObjString("RegexMath(${objRange.toString(scope)},${objGroups.toString(scope)})")
}
override suspend fun getAt(scope: Scope, index: Obj): Obj {
return objGroups.getAt(scope, index)
}
override suspend fun compareTo(scope: Scope, other: Obj): Int {
if( other === this) return 0
return -2
}
companion object {
val type by lazy {
object : ObjClass("RegexMatch") {
override suspend fun callOn(scope: Scope): Obj {
scope.raiseError("RegexMatch can't be constructed directly")
}
}.apply {
addFn("groups") {
thisAs<ObjRegexMatch>().objGroups
}
addFn("value") {
thisAs<ObjRegexMatch>().objValue
}
addFn("range") {
thisAs<ObjRegexMatch>().objRange
}
}
}
}
}
@@ -44,9 +44,7 @@ data class ObjString(val value: String) : Obj() {
override fun toString(): String = value override fun toString(): String = value
override val asStr: ObjString by lazy { this } override suspend fun inspect(scope: Scope): String {
override fun inspect(): String {
return "\"$value\"" return "\"$value\""
} }
@@ -54,12 +52,13 @@ data class ObjString(val value: String) : Obj() {
get() = type get() = type
override suspend fun plus(scope: Scope, other: Obj): Obj { override suspend fun plus(scope: Scope, other: Obj): Obj {
return ObjString(value + other.asStr.value) return ObjString(value + other.toString(scope).value)
} }
override suspend fun getAt(scope: Scope, index: Obj): Obj { override suspend fun getAt(scope: Scope, index: Obj): Obj {
if (index is ObjInt) return ObjChar(value[index.toInt()]) when (index) {
if (index is ObjRange) { is ObjInt -> return ObjChar(value[index.toInt()])
is ObjRange -> {
val start = if (index.start == null || index.start.isNull) 0 else index.start.toInt() 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 end = if (index.end == null || index.end.isNull) value.length else {
val e = index.end.toInt() val e = index.end.toInt()
@@ -67,7 +66,13 @@ data class ObjString(val value: String) : Obj() {
} }
return ObjString(value.substring(start, end)) return ObjString(value.substring(start, end))
} }
scope.raiseIllegalArgument("String index must be Int or Range")
is ObjRegex -> {
return index.find(this)
}
else -> scope.raiseIllegalArgument("String index must be Int, Regex or Range")
}
} }
override fun hashCode(): Int { override fun hashCode(): Int {
@@ -98,6 +103,11 @@ data class ObjString(val value: String) : Obj() {
return value == other.value return value == other.value
} }
override suspend fun operatorMatch(scope: Scope, other: Obj): Obj {
val re = other.cast<ObjRegex>(scope)
return re.operatorMatch(scope, this)
}
override suspend fun lynonType(): LynonType = LynonType.String override suspend fun lynonType(): LynonType = LynonType.String
override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) { override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
@@ -110,7 +120,8 @@ data class ObjString(val value: String) : Obj() {
ObjString(decoder.unpackBinaryData().decodeToString()) ObjString(decoder.unpackBinaryData().decodeToString())
}.apply { }.apply {
addFn("toInt") { addFn("toInt") {
ObjInt(thisAs<ObjString>().value.toLongOrNull() ObjInt(
thisAs<ObjString>().value.toLongOrNull()
?: raiseIllegalArgument("can't convert to int: $thisObj") ?: raiseIllegalArgument("can't convert to int: $thisObj")
) )
} }
@@ -159,6 +170,25 @@ data class ObjString(val value: String) : Obj() {
addFn("toReal") { addFn("toReal") {
ObjReal(thisAs<ObjString>().value.toDouble()) ObjReal(thisAs<ObjString>().value.toDouble())
} }
addFn("trim") {
thisAs<ObjString>().value.trim().let(::ObjString)
}
addFn("matches") {
val s = requireOnlyArg<Obj>()
val self = thisAs<ObjString>().value
ObjBool(
when (s) {
is ObjRegex -> self.matches(s.regex)
is ObjString -> {
if (s.value == ".*") true
else self.matches(s.value.toRegex())
}
else ->
raiseIllegalArgument("can't match ${s.objClass.className}: required Regex or String")
}
)
}
} }
} }
} }
@@ -77,9 +77,8 @@ fun Iterable.dropLast(n) {
} }
fun Iterable.takeLast(n) { fun Iterable.takeLast(n) {
val list = this
val buffer = RingBuffer(n) val buffer = RingBuffer(n)
for( item in list ) buffer += item for( item in this ) buffer += item
buffer buffer
} }
@@ -104,5 +103,70 @@ fun Iterable.all(predicate): Bool {
!any { !predicate(it) } !any { !predicate(it) }
} }
fun Iterable.sum() {
val i = iterator()
if( i.hasNext() ) {
var result = i.next()
while( i.hasNext() ) result += i.next()
result
}
else null
}
fun Iterable.sumOf(f) {
val i = iterator()
if( i.hasNext() ) {
var result = f(i.next())
while( i.hasNext() ) result += f(i.next())
result
}
else null
}
fun Iterable.sorted() {
sortedWith { a, b -> a <=> b }
}
fun Iterable.sortedBy(predicate) {
sortedWith { a, b -> predicate(a) <=> predicate(b) }
}
fun Iterable.shuffled() {
toList().apply { shuffle() }
}
fun List.toString() {
"[" + joinToString(",") + "]"
}
fun List.sortBy(predicate) {
sortWith { a, b -> predicate(a) <=> predicate(b) }
}
fun List.sort() {
sortWith { a, b -> a <=> b }
}
class StackTraceEntry(
val sourceName: String,
val line: Int,
val column: Int,
val sourceString: String
) {
fun toString() {
"%s:%d:%d: %s"(sourceName, line, column, sourceString.trim())
}
}
fun Exception.printStackTrace() {
println(this)
for( entry in stackTrace() ) {
println("\tat "+entry)
}
}
fun String.re() { Regex(this) }
""".trimIndent() """.trimIndent()
@@ -101,7 +101,6 @@ interface BitOutput {
val compressed = LZW.compress(source.asUByteArray()) val compressed = LZW.compress(source.asUByteArray())
// check that compression is effective including header bits size: // check that compression is effective including header bits size:
if( compressed.size + 2 < source.size * 8L) { if( compressed.size + 2 < source.size * 8L) {
println("write compressed")
putBit(1) putBit(1)
// LZW algorithm // LZW algorithm
putBits(0, 2) putBits(0, 2)
@@ -63,6 +63,19 @@ open class LynonDecoder(val bin: BitInput, val settings: LynonSettings = LynonSe
} }
} }
/**
* Decode any object with [decodeAny] and cast it to [T] or raise Lyng's class cast error
* with [Scope.raiseClassCastError].
*
* @return T typed Lyng object
*/
suspend inline fun <reified T : Obj> decodeAnyAs(scope: Scope): T {
val x = decodeAny(scope)
return (x as? T) ?: scope.raiseClassCastError(
"Expected ${T::class.simpleName} but got $x"
)
}
private suspend fun decodeClassObj(scope: Scope): ObjClass { private suspend fun decodeClassObj(scope: Scope): ObjClass {
val className = decodeObject(scope, ObjString.type, null) as ObjString val className = decodeObject(scope, ObjString.type, null) as ObjString
return scope.get(className.value)?.value?.let { return scope.get(className.value)?.value?.let {
@@ -1,16 +0,0 @@
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
}
}
+11
View File
@@ -106,4 +106,15 @@ class OOTest {
} }
""".trimIndent()) """.trimIndent())
} }
@Test
fun testMultilineConstructor() = runTest {
eval("""
class Point(
x,
y
)
assertEquals(Point(1,2), Point(1,2) )
""".trimIndent())
}
} }
+372 -12
View File
@@ -1184,6 +1184,35 @@ class ScriptTest {
) )
} }
@Test
fun testOpenEndRanges2() = runTest {
eval(
"""
var r = 5..; var r2 = 6..
val r3 = 7.. // open end
assert( r::class == Range)
assert( r.end == null)
assert( r.start == 5)
assert( r3::class == Range)
assertEquals( r3.end, null)
assert( r3.start == 7)
""".trimIndent()
)
}
@Test
fun testOpenEndRanges3() = runTest {
eval(
"""
val r3 = 7.. // open end with comment
assert( r3::class == Range)
assertEquals( r3.end, null)
assert( r3.start == 7)
""".trimIndent()
)
}
@Test @Test
fun testCharacterRange() = runTest { fun testCharacterRange() = runTest {
eval( eval(
@@ -2006,7 +2035,7 @@ class ScriptTest {
@Test @Test
fun testThrowFromKotlin() = runTest { fun testThrowFromKotlin() = runTest {
val c = Scope() val c = Script.newScope()
c.addFn("callThrow") { c.addFn("callThrow") {
raiseIllegalArgument("fromKotlin") raiseIllegalArgument("fromKotlin")
} }
@@ -2213,6 +2242,45 @@ class ScriptTest {
) )
} }
@Test
fun testParseSpecialVars() {
val l = parseLyng("$~".toSource("test$~"))
println(l)
assertEquals(Token.Type.ID, l[0].type)
assertEquals("$~", l[0].value)
}
@Test
fun testMatchOperator() = runTest {
eval("""
assert( "abc123".matches(".*\d{3}") )
assert( ".*\d{3}".re =~ "abc123" )
assert( "abc123" =~ ".*\d{3}".re )
assert( "abc123" !~ ".*\d{4}".re )
"abc123" =~ ".*(\d)(\d)(\d)$".re
println($~)
assertEquals("1", $~[1])
assertEquals("2", $~[2])
assertEquals("3", $~[3])
assertEquals("abc123", $~[0])
""".trimIndent())
}
// @Test
// fun testWhenMatch() = runTest {
// eval(
// """
// when("abc123") {
// ".*(\d)(\d)(\d)".re -> { x ->
// assertEquals("123", x[0])
// }
// else -> assert(false)
// }
// """.trimIndent()
// )
// }
@Test @Test
fun testWhenSample1() = runTest { fun testWhenSample1() = runTest {
eval( eval(
@@ -2632,7 +2700,8 @@ class ScriptTest {
@Test @Test
fun testBufferEncodings() = runTest { fun testBufferEncodings() = runTest {
eval(""" eval(
"""
import lyng.buffer import lyng.buffer
val b = Buffer("hello") val b = Buffer("hello")
@@ -2647,7 +2716,8 @@ class ScriptTest {
println(b.inspect()) println(b.inspect())
""".trimIndent()) """.trimIndent()
)
} }
@Test @Test
@@ -2871,7 +2941,8 @@ class ScriptTest {
@Test @Test
fun tesFunAnnotation() = runTest { fun tesFunAnnotation() = runTest {
eval(""" eval(
"""
val exportedSymbols = Map() val exportedSymbols = Map()
@@ -2890,7 +2961,8 @@ class ScriptTest {
assert( exportedSymbols["getBalance"] != null ) assert( exportedSymbols["getBalance"] != null )
assertEquals(122, getBalance(1)) assertEquals(122, getBalance(1))
""".trimIndent()) """.trimIndent()
)
} }
@Test @Test
@@ -2910,12 +2982,14 @@ class ScriptTest {
assertEquals( Color.valueOf("GREEN"), Color.GREEN ) assertEquals( Color.valueOf("GREEN"), Color.GREEN )
""".trimIndent()) """.trimIndent()
)
} }
@Test @Test
fun enumSerializationTest() = runTest { fun enumSerializationTest() = runTest {
eval(""" eval(
"""
import lyng.serialization import lyng.serialization
enum Color { enum Color {
@@ -2931,12 +3005,14 @@ class ScriptTest {
assert( e1.size / 1000.0 < 6) assert( e1.size / 1000.0 < 6)
println(Lynon.encode( (1..100).map { "RED" } ).toDump() ) println(Lynon.encode( (1..100).map { "RED" } ).toDump() )
""".trimIndent()) """.trimIndent()
)
} }
@Test @Test
fun cachedTest() = runTest { fun cachedTest() = runTest {
eval( """ eval(
"""
var counter = 0 var counter = 0
var value = cached { var value = cached {
@@ -2949,17 +3025,301 @@ class ScriptTest {
assertEquals(1, counter) assertEquals(1, counter)
assertEquals("ok", value()) assertEquals("ok", value())
assertEquals(1, counter) assertEquals(1, counter)
""".trimIndent()) """.trimIndent()
)
} }
@Test @Test
fun testJoinToString() = runTest { fun testJoinToString() = runTest {
eval(""" eval(
"""
assertEquals( (1..3).joinToString(), "1 2 3") assertEquals( (1..3).joinToString(), "1 2 3")
assertEquals( (1..3).joinToString(":"), "1:2:3") assertEquals( (1..3).joinToString(":"), "1:2:3")
assertEquals( (1..3).joinToString { it * 10 }, "10 20 30") assertEquals( (1..3).joinToString { it * 10 }, "10 20 30")
""".trimIndent()) """.trimIndent()
)
}
@Test
fun testElvisAndThrow() = runTest {
eval(
"""
val x = assertThrows {
null ?: throw "test" + "x"
}
assertEquals( "testx", x.message)
""".trimIndent()
)
}
@Test
fun testElvisAndThrow2() = runTest {
eval(
"""
val t = "112"
val x = t ?: run { throw "testx" }
}
assertEquals( "112", x)
""".trimIndent()
)
}
@Test
fun testElvisAndRunThrow() = runTest {
eval(
"""
val x = assertThrows {
null ?: run { throw "testx" }
}
assertEquals( "testx", x.message)
""".trimIndent()
)
}
@Test
fun testNewlinesAnsCommentsInExpressions() = runTest {
assertEquals(
2, (Scope().eval(
"""
val e = 1 + 4 -
3
""".trimIndent()
)).toInt()
)
eval(
"""
val x = [1,2,3]
.map { it * 10 }
.map { it + 1 }
assertEquals( [11,21,31], x)
""".trimIndent()
)
}
@Test
fun testNotExpressionWithoutWs() = runTest {
eval(
"""
fun test() { false }
class T(value)
assert( !false )
assert( !test() )
assert( !test() )
val t = T(false)
assert( !t.value )
assert( !if( true ) false else true )
""".trimIndent()
)
}
@Test
fun testMultilineFnDeclaration() = runTest {
eval(
"""
fun test(
x = 1,
y = 2
) {
x * y
}
assertEquals( 10, test(5) )
assertEquals( 42, test(
6,
7
) )
""".trimIndent()
)
}
@Test
fun testOverridenListToString() = runTest {
eval(
"""
val x = [1,2,3]
assertEquals( "[1,2,3]", x.toString() )
""".trimIndent()
)
}
@Test
fun testExceptionSerialization() = runTest {
eval(
"""
import lyng.serialization
val x = [1,2,3]
assertEquals( "[1,2,3]", x.toString() )
try {
require(false)
}
catch (e) {
println(e.stackTrace)
e.printStackTrace()
val coded = Lynon.encode(e)
val decoded = Lynon.decode(coded)
assertEquals( e::class, decoded::class )
assertEquals( e.stackTrace, decoded.stackTrace )
assertEquals( e.message, decoded.message )
println("-------------------- e")
println(e.toString())
println("-------------------- dee")
println(decoded.toString())
assertEquals( e.toString(), decoded.toString() )
}
""".trimIndent()
)
}
@Test
fun testThisInClosure() = runTest {
eval(
"""
fun Iterable.sum2by(f) {
var acc = null
for( x in this ) {
println(x)
println(f(x))
acc = acc?.let { acc + f(x) } ?: f(x)
}
}
class T(val coll, val factor) {
fun sum() {
// here we use ths::T and it must be available:
coll.sum2by { it * factor }
}
}
assertEquals(60, T([1,2,3], 10).sum())
""".trimIndent()
)
}
@Test
fun testThisInFlowClosure() = runTest {
eval(
"""
class T(val coll, val factor) {
fun seq() {
flow {
for( x in coll ) {
emit(x*factor)
}
}
}
}
assertEquals([10,20,30], T([1,2,3], 10).seq().toList())
""".trimIndent()
)
}
@Test
fun testSum() = runTest {
eval(
"""
assertEquals(1, [1].sum())
assertEquals(null, [].sum())
assertEquals(6, [1,2,3].sum())
assertEquals(30, [3].sumOf { it * 10 })
assertEquals(null, [].sumOf { it * 10 })
assertEquals(60, [1,2,3].sumOf { it * 10 })
""".trimIndent()
)
}
@Test
fun testSort() = runTest {
eval(
"""
val coll = [5,4,1,7]
assertEquals( [1,4,5,7], coll.sortedWith { a,b -> a <=> b })
assertEquals( [1,4,5,7], coll.sorted())
assertEquals( [7,5,4,1], coll.sortedBy { -it })
assertEquals( [1,4,5,7], coll.sortedBy { -it }.reversed())
""".trimIndent()
)
}
@Test
fun testListSortInPlace() = runTest {
eval(
"""
val l1 = [6,3,1,9]
l1.sort()
assertEquals( [1,3,6,9], l1)
l1.sortBy { -it }
assertEquals( [1,3,6,9].reversed(), l1)
l1.sort()
l1.sortBy { it % 4 }
// 1,3,6,9
// 1 3 2 1
// we hope we got it also stable:
assertEquals( [1,9,6,3], l1)
"""
)
}
@Test
fun binarySearchTest() = runTest {
eval(
"""
val coll = [1,2,3,4,5]
assertEquals( 2, coll.binarySearch(3) )
assertEquals( 0, coll.binarySearch(1) )
assertEquals( 4, coll.binarySearch(5) )
""".trimIndent()
)
}
@Test
fun binarySearchTest2() = runTest {
eval(
"""
val src = (1..50).toList().shuffled()
val result = []
for( x in src ) {
val i = result.binarySearch(x)
assert( i < 0 )
result.insertAt(-i-1, x)
}
assertEquals( src.sorted(), result )
""".trimIndent()
)
} }
// @Test
fun testMinimumOptimization() = runTest {
val x = Scope().eval(
"""
fun naiveCountHappyNumbers() {
var count = 0
for( n1 in 0..9 )
for( n2 in 0..9 )
for( n3 in 0..9 )
for( n4 in 0..9 )
for( n5 in 0..9 )
for( n6 in 0..9 )
if( n1 + n2 + n3 == n4 + n5 + n6 ) count++
count
}
naiveCountHappyNumbers()
""".trimIndent()
).toInt()
assertEquals(55252, x)
}
@Test
fun testRegex1() = runTest {
eval(
"""
assert( ! "123".re.matches("abs123def") )
assert( ".*123.*".re.matches("abs123def") )
// assertEquals( "123", "123".re.find("abs123def")?.value )
// assertEquals( "123", "[0-9]{3}".re.find("abs123def")?.value )
assertEquals( "123", "\d{3}".re.find("abs123def")?.value )
assertEquals( "123", "\\d{3}".re.find("abs123def")?.value )
assertEquals( [1,2,3], "\d".re.findAll("abs123def").map { it.value.toInt() } )
"""
.trimIndent()
)
}
} }
+17 -3
View File
@@ -177,11 +177,11 @@ suspend fun DocTest.test(_scope: Scope? = null) {
scope.apply { scope.apply {
addFn("println") { addFn("println") {
if( bookMode ) { if( bookMode ) {
println("${currentTest.fileNamePart}:${currentTest.line}> ${args.joinToString(" "){it.asStr.value}}") println("${currentTest.fileNamePart}:${currentTest.line}> ${args.map{it.toString(this).value}.joinToString(" ")}")
} }
else { else {
for ((i, a) in args.withIndex()) { for ((i, a) in args.withIndex()) {
if (i > 0) collectedOutput.append(' '); collectedOutput.append(a.asStr.value) if (i > 0) collectedOutput.append(' '); collectedOutput.append(a.toString(this).value)
collectedOutput.append('\n') collectedOutput.append('\n')
} }
} }
@@ -194,7 +194,7 @@ suspend fun DocTest.test(_scope: Scope? = null) {
} catch (e: Throwable) { } catch (e: Throwable) {
error = e error = e
null null
}?.inspect()?.replace(Regex("@\\d+"), "@...") }?.inspect(scope)?.replace(Regex("@\\d+"), "@...")
if (bookMode) { if (bookMode) {
if (error != null) { if (error != null) {
@@ -322,4 +322,18 @@ class BookTest {
runDocTests("../docs/Iterable.md") runDocTests("../docs/Iterable.md")
} }
@Test
fun testSerialization() = runBlocking {
runDocTests("../docs/serialization.md")
}
@Test
fun testArray() = runBlocking {
runDocTests("../docs/Array.md")
}
@Test
fun testRegex() = runBlocking {
runDocTests("../docs/Regex.md")
}
} }
+42
View File
@@ -649,6 +649,48 @@ class LynonTests {
""".trimIndent()) """.trimIndent())
} }
@Test
fun testTokenFailure() = runTest {
val s = Scope()
val t = s.eval(
"""
import lyng.serialization
import lyng.buffer
import lyng.time
class Wallet( id, ownerKey, balance=0, createdAt=Instant.now().truncateToSecond(), isBlocked=false) {
/*
Create new key for the given owner multikey
*/
static fun new( ownerKey ) {
// this is per-contract unique id generated and approved by the network.
// it is not random, but it _is_ unique, and we use it as a walletId.
val newId = Buffer("testid")
val w = Wallet(newId, ownerKey)
println(w)
println(w.balance)
val x = Lynon.encode(Wallet(newId, ownerKey) ).toBuffer()
val t = Lynon.decode(x.toBitInput())
println(x)
println(t)
assertEquals(w.balance, t.balance)
w
}
}
Wallet.new(Buffer("1234"))
""".trimIndent())
println(t)
// val bb = lynonEncodeAny(s, t)
// val t2 = lynonDecodeAny(s, bb)
// println(t2.readField(s, "balance"))
}
} }