Compare commits

...
17 Commits
Author SHA1 Message Date
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
sergeych eefecae7b4 more Buffer encodings 2025-08-17 19:26:15 +03:00
sergeych 2ac92a1d09 more elegant Iterable.all 2025-08-17 18:21:52 +03:00
48 changed files with 1193 additions and 243 deletions

No files matched your search

+1 -1
View File
@@ -158,6 +158,7 @@ Ready features:
- [x] compression/decompression (integrated in serialization)
- [x] dynamic fields
- [x] function annotations
- [x] better stack reporting
### Under way:
@@ -165,7 +166,6 @@ Ready features:
- [ ] multiple inheritance for user classes
- [ ] site with integrated interpreter to give a try
- [ ] kotlin part public API good docs, integration focused
- [ ] better stack reporting
## v1.1+
+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
+36 -6
View File
@@ -102,20 +102,50 @@ As with [List], it is possible to use ranges as indexes to slice a Buffer:
>>> void
## Encoding
You can encode `String` to buffer using buffer constructor, as was shown. Also, buffer supports out of the box base64 (
which is used in `toString`) and hex encoding:
import lyng.buffer
// to UTF8 and back:
val b = Buffer("hello")
assertEquals( "hello", b.decodeUtf8() )
// to base64 and back:
assertEquals( b, Buffer.decodeBase64(b.base64) )
assertEquals( b, Buffer.decodeHex(b.hex) )
>>> void
## Members
| name | meaning | type |
|---------------|------------------------------------|---------------|
| `size` | size | Int |
| `decodeUtf8` | decodee to String using UTF8 rules | Any |
| `+` | buffer concatenation | Any |
| `toMutable()` | create a mutable copy | MutableBuffer |
| name | meaning | type |
|----------------------------|-----------------------------------------|---------------|
| `size` | size | Int |
| `decodeUtf8` | decode to String using UTF8 rules | Any |
| `+` | buffer concatenation | Any |
| `toMutable()` | create a mutable copy | MutableBuffer |
| `hex` | encode to hex strign | String |
| `Buffer.decodeHex(hexStr) | decode hex string | Buffer |
| `base64` | encode to base64 (url flavor) (2) | String |
| `Buffer.decodeBase64(str)` | decode base64 to new Buffer (2) | Buffer |
| `toBitInput()` | create bit input from a byte buffer (3) | |
(1)
: optimized implementation that override `Iterable` one
(2)
: base64url alphabet is used without trailing '=', which allows string to be used in URI without escaping. Note that
decoding supports both traditional and URL alphabets automatically, and ignores filling `=` characters. Base64URL is
well known and mentioned in the internet, for example, [here](https://base64.guru/standards/base64url).
(3)
: `BitInput` is a bit buffer that is used, for example, in [Lynon.decode](serialization.md)
Also, it inherits methods from [Iterable] and [Array].
[Range]: Range.md
[Iterable]: Iterable.md
+6
View File
@@ -6,6 +6,12 @@ Is a [Iterable] with known `size`, a finite [Iterable]:
val size
}
| name | description |
|------------------------|------------------------------------------------------|
(1)
: `comparator(a,b)` should return -1 if `a < b`, +1 if `a > b` or zero.
See [List], [Set] and [Iterable]
[Iterable]: Iterable.md
+60 -27
View File
@@ -1,9 +1,13 @@
# 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.
Please see also [Collection] interface: many iterables are also collections, and it adds important features.
## Definition:
Iterable is a class that provides function that creates _the iterator_:
@@ -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.
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!
assertEquals( [9,10], r.takeLast(2).toList() )
@@ -34,12 +39,13 @@ Having `Iterable` in base classes allows to use it in for loop. Also, each `Iter
## 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)
- if `Iterable` `isEmpty`, the empty string `""` is returned.
- `suffix` is inserted between items when there are more than one.
- `suffix` is inserted between items when there are more than one.
- `transform` of specified is applied to each element, otherwise its `toString()` method is used.
Here is the sample:
@@ -49,34 +55,57 @@ Here is the sample:
assertEquals( (1..3).joinToString { it * 10 }, "10 20 30")
>>> void
## `sum` and `sumBy`
These, again, does the thing:
assertEquals( 6, [1,2,3].sum() )
assertEquals( 12, [1,2,3].sumOf { it*2 } )
// sum of empty collections is null:
assertEquals( null, [].sum() )
assertEquals( null, [].sumOf { 2*it } )
>>> void
## Instance methods:
| fun/method | description |
|-------------------|---------------------------------------------------------------------------|
| toList() | create a list from iterable |
| toSet() | create a set from iterable |
| contains(i) | check that iterable contains `i` |
| `i in iterator` | same as `contains(i)` |
| isEmpty() | check iterable is empty |
| forEach(f) | call f for each element |
| toMap() | create a map from list of key-value pairs (arrays of 2 items or like) |
| map(f) | create a list of values returned by `f` called for each element of the iterable |
| indexOf(i) | return index if the first encounter of i or a negative value if not found |
| associateBy(kf) | create a map where keys are returned by kf that will be called for each element |
| first | first element (1) |
| last | last element (1) |
| take(n) | return [Iterable] of up to n first elements |
| taleLast(n) | return [Iterable] of up to n last elements |
| drop(n) | return new [Iterable] without first n elements |
| dropLast(n) | return new [Iterable] without last n elements |
| joinToString(s,t) | convert iterable to string, see (2) |
| fun/method | description |
|------------------------|---------------------------------------------------------------------------------|
| toList() | create a list from iterable |
| toSet() | create a set from iterable |
| contains(i) | check that iterable contains `i` |
| `i in iterator` | same as `contains(i)` |
| isEmpty() | check iterable is empty |
| forEach(f) | call f for each element |
| toMap() | create a map from list of key-value pairs (arrays of 2 items or like) |
| map(f) | create a list of values returned by `f` called for each element of the iterable |
| indexOf(i) | return index if the first encounter of i or a negative value if not found |
| associateBy(kf) | create a map where keys are returned by kf that will be called for each element |
| first | first element (1) |
| last | last element (1) |
| take(n) | return [Iterable] of up to n first elements |
| taleLast(n) | return [Iterable] of up to n last elements |
| drop(n) | return new [Iterable] without first n elements |
| dropLast(n) | return new [Iterable] without last n elements |
| sum() | return sum of the collection applying `+` to its elements (3) |
| sumOf(predicate) | sum of the modified collection items (3) |
| sorted() | return [List] with collection items sorted naturally |
| sortedWith(comparator) | sort using a comparator that compares elements (1) |
| sortedBy(predicate) | sort by comparing results of the predicate function |
| joinToString(s,t) | convert iterable to string, see (2) |
| reversed() | create a list containing items from this in reverse order |
| shuffled() | create a listof shiffled elements |
(1)
: throws `NoSuchElementException` if there is no such element
: throws `NoSuchElementException` if there is no such element
(2)
: `joinToString(suffix=" ",transform=null)`: suffix is inserted between items if there are more than one, trasnfom is optional function applied to each item that must return result string for an item, otherwise `item.toString()` is used.
: `joinToString(suffix=" ",transform=null)`: suffix is inserted between items if there are more than one, trasnfom is
optional function applied to each item that must return result string for an item, otherwise `item.toString()` is used.
(3)
: sum of empty collection is `null`
fun Iterable.toList(): List
fun Iterable.toSet(): Set
@@ -86,7 +115,6 @@ Here is the sample:
fun Iterable.forEach(block: (Any?)->Void ): Void
fun Iterable.map(block: (Any?)->Void ): List
fun Iterable.associateBy( keyMaker: (Any?)->Any): Map
## Abstract methods:
@@ -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]
[Collection]: Collection.md
[List]: List.md
[Range]: Range.md
[Set]: Set.md
[RingBuffer]: RingBuffer.md
+49 -16
View File
@@ -24,7 +24,7 @@ There is a shortcut for the last:
val list = [10, 20, 30]
[list.last, list.lastIndex]
>>> [30, 2]
>>> [30,2]
__Important__ negative indexes works wherever indexes are used, e.g. in insertion and removal methods too.
@@ -92,22 +92,45 @@ Open end ranges remove head and tail elements:
assert( [1, 2, 3] !== [1, 2, 3])
>>> void
## In-place sort
List could be sorted in place, just like [Collection] provide sorted copies, in a very like way:
val l1 = [6,3,1,9]
l1.sort()
assertEquals( [1,3,6,9], l1)
l1.sortBy { -it }
assertEquals( [1,3,6,9].reversed(), l1)
l1.sort() // 1 3 6 9
l1.sortBy { it % 4 }
// 1,3,6,9 gives, mod 4:
// 1 3 2 1
// we hope we got it also stable:
assertEquals( [1,9,6,3], l1)
>>> void
## Members
| name | meaning | type |
|-------------------------------|---------------------------------------|-------------|
| `size` | current size | Int |
| `add(elements...)` | add one or more elements to the end | Any |
| `insertAt(index,elements...)` | insert elements at position | Int, Any |
| `removeAt(index)` | remove element at position | Int |
| `remove(from,toNonInclusive)` | remove range from (incl) to (nonincl) | Int, Int |
| `remove(Range)` | remove range | Range |
| `removeLast()` | remove last element | |
| `removeLast(n)` | remove n last elements | Int |
| `contains(element)` | check the element is in the list (1) | |
| `[index]` | get or set element at index | Int |
| `[Range]` | get slice of the array (copy) | Range |
| `+=` | append element(s) | List or Obj |
| name | meaning | type |
|-------------------------------|----------------------------------------------|-------------|
| `size` | current size | Int |
| `add(elements...)` | add one or more elements to the end | Any |
| `insertAt(index,elements...)` | insert elements at position | Int, Any |
| `removeAt(index)` | remove element at position | Int |
| `remove(from,toNonInclusive)` | remove range from (incl) to (nonincl) | Int, Int |
| `remove(Range)` | remove range | Range |
| `removeLast()` | remove last element | |
| `removeLast(n)` | remove n last elements | Int |
| `contains(element)` | check the element is in the list (1) | |
| `[index]` | get or set element at index | Int |
| `[Range]` | get slice of the array (copy) | Range |
| `+=` | append element(s) (2) | List or Obj |
| `sort()` | in-place sort, natural order | void |
| `sortBy(predicate)` | in-place sort bu `predicate` call result (3) | void |
| `sortWith(comparator)` | in-place sort using `comarator` function (4) | void |
| `shiffle()` | in-place shiffle contents | |
(1)
: optimized implementation that override `Array` one
@@ -116,7 +139,16 @@ Open end ranges remove head and tail elements:
: `+=` append either a single element, or all elements if the List or other Iterable
instance is appended. If you want to append an Iterable object itself, use `add` instead.
It inherits from [Iterable] too.
(3)
: predicate is called on each element, and the returned values are used to sort in natural
order, e.g. is same as `list.sortWith { a,b -> predicate(a) <=> predicate(b) }`
(4)
: comparator callable takes tho arguments and must return: negative value when first is less,
positive if first is greater, and zero if they are equal. For example, the equvalent comparator
for `sort()` will be `sort { a, b -> a <=> b }
It inherits from [Iterable] too and thus all iterable methods are applicable to any list.
## Member inherited from Array
@@ -134,4 +166,5 @@ It inherits from [Iterable] too.
[Range]: Range.md
[Iterable]: Iterable.md
+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:
('a'..<'c').toList
>>> ['a', 'b']
>>> [a,b]
# Instance members
+3 -3
View File
@@ -71,7 +71,7 @@ destructuring arrays when calling functions and lambdas:
[ first, last ]
}
getFirstAndLast( ...(1..10) ) // see "splats" section below
>>> [1, 10]
>>> [1,10]
# Splats
@@ -83,7 +83,7 @@ or whatever implementing [Iterable], is called _splats_. Here is how we use it:
}
val array = [1,2,3]
testSplat("start", ...array, "end")
>>> ["start", 1, 2, 3, "end"]
>>> [start,1,2,3,end]
>>> void
There could be any number of splats at any positions. You can splat any other [Iterable] type:
@@ -93,7 +93,7 @@ There could be any number of splats at any positions. You can splat any other [I
}
val range = 1..3
testSplat("start", ...range, "end")
>>> ["start", 1, 2, 3, "end"]
>>> [start,1,2,3,end]
>>> void
+27 -1
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
most often not enough.
# Exception class
Serializable class that conveys information about the exception. Important members and methods are:
| name | description |
|-------------------|--------------------------------------------------------|
| message | String message |
| stackTrace | lyng stack trace, list of `StackTraceEntry`, see below |
| printStackTrace() | format and print stack trace using println() |
## StackTraceEntry
A simple structire that stores single entry in Lyng stack, it is created automatically on exception creation:
```kotlin
class StackTraceEntry(
val sourceName: String,
val line: Int,
val column: Int,
val sourceString: String
)
```
- `sourceString` is a line extracted from sources. Note that it _is serialized and printed_, so if you want to conceal it, catch all exceptions and filter out sensitive information.
# Custom error classes
_this functionality is not yet released_
@@ -131,7 +157,7 @@ _this functionality is not yet released_
| class | notes |
|----------------------------|-------------------------------------------------------|
| Exception | root of al throwable objects |
| NullReferenceException | |
| NullReferenceException | |
| AssertionFailedException | |
| ClassCastException | |
| IndexOutOfBoundsException | |
+2 -2
View File
@@ -183,8 +183,8 @@ Important difference from the channels or like, every time you collect the flow,
// and again:
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
Notice that flow's lambda is not called until actual collection is started. Cold flows are
+9 -3
View File
@@ -16,9 +16,15 @@ fun naiveCountHappyNumbers() {
count
}
import lyng.time
//
// After all optimizations it takes ~120ms.
//
val found = naiveCountHappyNumbers()
println("Found happy numbers: "+found)
assert( found == 55252 )
//for( r in 1..100 ) {
// val start = Instant.now()
val found = naiveCountHappyNumbers()
// println("Found happy numbers: %d time %s"(found, Instant.now() - start))
assert( found == 55252 )
// delay(0.01)
//}
+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)
+44 -23
View File
@@ -16,7 +16,8 @@ __Other documents to read__ maybe after this one:
- [math in Lyng](math.md)
- [time](time.md) and [parallelism](parallelism.md)
- [parallelism] - multithreaded code, coroutines, etc.
- Some class references: [List], [Set], [Map], [Real], [Range], [Iterable], [Iterator], [time manipulation](time.md), [RingBuffer], [Buffer].
- Some class
references: [List], [Set], [Map], [Real], [Range], [Iterable], [Iterator], [time manipulation](time.md), [Array], [RingBuffer], [Buffer].
- Some samples: [combinatorics](samples/combinatorics.lyng.md), national vars and
loops: [сумма ряда](samples/сумма_ряда.lyng.md). More at [samples folder](samples)
@@ -225,6 +226,19 @@ It works much like `also`, but is executed in the context of the source object:
assertEquals(p, Point(2,3))
>>> void
## run
Executes a block after it returning the value passed by the block. for example, can be used with elvis operator:
var someVar = null
val result = someVar ?: run {
someVar = 121
"reset"
}
assertEquals("reset", result)
assertEquals(121, someVar)
>>> void
## Math
It is rather simple, like everywhere else:
@@ -475,7 +489,8 @@ Lyng has built-in mutable array class `List` with simple literals:
[1, "two", 3.33].size
>>> 3
[List] is an implementation of the type `Array`, and through it `Collection` and [Iterable]. 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:
@@ -492,21 +507,21 @@ Notice usage of indexing. You can use negative indexes to offset from the end of
When you want to "flatten" it to single array, you can use splat syntax:
[1, ...[2,3], 4]
>>> [1, 2, 3, 4]
>>> [1,2,3,4]
Of course, you can splat from anything that is List (or list-like, but it will be defined later):
val a = ["one", "two"]
val b = [10.1, 20.2]
["start", ...b, ...a, "end"]
>>> ["start", 10.1, 20.2, "one", "two", "end"]
>>> [start,10.1,20.2,one,two,end]
Of course, you can set any list element:
val a = [1, 2, 3]
a[1] = 200
a
>>> [1, 200, 3]
>>> [1,200,3]
Lists are comparable, and it works well as long as their respective elements are:
@@ -596,20 +611,20 @@ Using splat arguments can simplify inserting list in list:
val x = [1, 2, 3]
x.insertAt( 1, ...[0,100,0])
x
>>> [1, 0, 100, 0, 2, 3]
>>> [1,0,100,0,2,3]
Note that to add to the end you still need to use `add` or positive index of the after-last element:
val x = [1,2,3]
x.insertAt(3, 10)
x
>>> [1, 2, 3, 10]
>>> [1,2,3,10]
but it is much simpler, and we recommend to use '+='
val x = [1,2,3]
x += 10
>>> [1, 2, 3, 10]
>>> [1,2,3,10]
## Removing list items
@@ -749,15 +764,15 @@ thrown.
Typical builtin types that are containers (e.g. support `contains`):
| class | notes |
|------------|------------------------------------------------|
| Collection | contains an element (1) |
| Array | faster maybe that Collection's |
| List | faster than Array's |
| String | character in string or substring in string (3) |
| Range | object is included in the range (2) |
| Buffer | byte is in buffer |
| RingBuffer | object is in buffer |
| class | notes |
|--------------|------------------------------------------------|
| [Collection] | contains an element (1) |
| Array | faster maybe that Collection's |
| List | faster than Array's |
| String | character in string or substring in string (3) |
| Range | object is included in the range (2) |
| Buffer | byte is in buffer |
| RingBuffer | object is in buffer |
(1)
: Iterable is not the container as it can be infinite
@@ -1124,7 +1139,8 @@ See [more docs on time manipulation](time.md)
# Enums
For the moment, only simple enums are implemented. Enum is a list of constants, represented also by their _ordinal_ - [Int] value.
For the moment, only simple enums are implemented. Enum is a list of constants, represented also by their
_ordinal_ - [Int] value.
enum Color {
RED, GREEN, BLUE
@@ -1139,7 +1155,8 @@ For the moment, only simple enums are implemented. Enum is a list of constants,
assertEquals( Color.valueOf("GREEN"), Color.GREEN )
>>> void
Enums are serialized as ordinals. Please note that due to caching, serialized string arrays could be even more compact than enum arrays, until `Lynon.encodeTyped` will be implemented.
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
@@ -1253,6 +1270,7 @@ Typical set of String functions includes:
|--------------------|------------------------------------------------------------|
| lower() | change case to unicode upper |
| upper() | change case to unicode lower |
| trim() | trim space chars from both ends |
| startsWith(prefix) | true if starts with a prefix |
| endsWith(prefix) | true if ends with a prefix |
| take(n) | get a new string from up to n first characters |
@@ -1280,7 +1298,7 @@ String literal could be multiline:
"Hello
World"
In this case, it will be passed literally ot "hello\n World". But, if there are
In this case, it will be passed literally ot "hello\n World". But, if there are
several lines with common left indent, it will be removed, also, forst and last lines,
if blank, will be removed too, for example:
@@ -1292,7 +1310,8 @@ if blank, will be removed too, for example:
>>> This is a second line.
>>> void
- as expected, empty lines and common indent were removed. It is much like kotlin's `""" ... """.trimIndent()` technique, but simpler ;)
- as expected, empty lines and common indent were removed. It is much like kotlin's `""" ... """.trimIndent()`
technique, but simpler ;)
# Built-in functions
@@ -1311,7 +1330,7 @@ See [math functions](math.md). Other general purpose functions are:
| flow {} | create flow sequence, see [parallelism] |
| delay, launch, yield | see [parallelism] |
| cached(builder) | remembers builder() on first invocation and return it then |
| let, also, apply, run | see above, flow controls |
# Built-in constants
@@ -1342,4 +1361,6 @@ See [math functions](math.md). Other general purpose functions are:
[parallelism]: parallelism.md
[RingBuffer]: RingBuffer.md
[RingBuffer]: RingBuffer.md
[Collection]: Collection.md
+2 -1
View File
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
import org.jetbrains.kotlin.gradle.dsl.JvmTarget
group = "net.sergeych"
version = "0.8.11-SNAPSHOT"
version = "0.8.15-SNAPSHOT"
buildscript {
repositories {
@@ -138,6 +138,7 @@ publishing {
}
}
//mavenPublishing {
// 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) }
}
fun inspect(): String = list.joinToString(", ") { it.inspect() }
suspend fun inspect(scope: Scope): String = list.map{ it.inspect(scope)}.joinToString(",")
companion object {
val EMPTY = Arguments(emptyList())
@@ -47,7 +47,7 @@ class Compiler(
private val codeContexts = mutableListOf<CodeContext>(CodeContext.Module(null))
private suspend fun <T>inCodeContext(context: CodeContext,f: suspend ()->T): T {
private suspend fun <T> inCodeContext(context: CodeContext, f: suspend () -> T): T {
return try {
codeContexts.add(context)
f()
@@ -211,11 +211,32 @@ class Compiler(
private suspend fun parseTerm(): Accessor? {
var operand: Accessor? = null
// newlines _before_
cc.skipWsTokens()
while (true) {
val t = cc.next()
val startPos = t.pos
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()
return operand
}
@@ -376,6 +397,13 @@ class Compiler(
}
"throw" -> {
val s = parseThrowStatement()
operand = Accessor {
s.execute(it).asReadonly
}
}
else -> operand?.let { left ->
// selector: <lvalue>, '.' , <id>
// we replace operand with selector code, that
@@ -461,7 +489,14 @@ class Compiler(
// range operator
val isEndInclusive = t.type == Token.Type.DOTDOT
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 {
ObjRange(
left?.getter?.invoke(it)?.value ?: ObjNull,
@@ -588,6 +623,8 @@ class Compiler(
var endTokenType: Token.Type? = null
val startPos = cc.savePos()
cc.skipWsTokens()
while (endTokenType == null) {
var t = cc.next()
when (t.type) {
@@ -645,7 +682,7 @@ class Compiler(
// important: valid argument list continues with ',' and ends with '->' or ')'
// otherwise it is not an argument list:
when (val tt = cc.next().type) {
when (val tt = cc.nextNonWhitespace().type) {
Token.Type.RPAREN -> {
// end of arguments
endTokenType = tt
@@ -857,7 +894,7 @@ class Compiler(
suspend fun parseAnnotation(t: Token): (suspend (Scope, ObjString, Statement) -> Statement) {
val extraArgs = parseArgsOrNull()
println("annotation ${t.value}: args: $extraArgs")
// println("annotation ${t.value}: args: $extraArgs")
return { scope, name, body ->
val extras = extraArgs?.first?.toArguments(scope, extraArgs.second)?.list
val required = listOf(name, body)
@@ -948,7 +985,7 @@ class Compiler(
private suspend fun parseWhenStatement(): Statement {
// has a value, when(value) ?
var t = cc.skipWsTokens()
var t = cc.nextNonWhitespace()
return if (t.type == Token.Type.LPAREN) {
// when(value)
val value = parseStatement() ?: throw ScriptError(cc.currentPos(), "when(value) expected")
@@ -971,7 +1008,7 @@ class Compiler(
// loop conditions
while (true) {
t = cc.skipWsTokens()
t = cc.nextNonWhitespace()
when (t.type) {
Token.Type.IN,
@@ -1184,11 +1221,11 @@ class Compiler(
cc.skipTokenOfType(Token.Type.LBRACE)
do {
val t = cc.skipWsTokens()
val t = cc.nextNonWhitespace()
when (t.type) {
Token.Type.ID -> {
names += t.value
val t1 = cc.skipWsTokens()
val t1 = cc.nextNonWhitespace()
when (t1.type) {
Token.Type.COMMA ->
continue
@@ -1327,8 +1364,8 @@ class Compiler(
}
return statement(body.pos) { ctx ->
val forContext = ctx.copy(start)
return statement(body.pos) { cxt ->
val forContext = cxt.copy(start)
// loop var: StoredObject
val loopSO = forContext.addItem(tVar.value, true, ObjNull)
@@ -1347,7 +1384,13 @@ class Compiler(
loopIterable(forContext, sourceObj, loopSO, body, elseStatement, label, canBreak)
} else {
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 breakCaught = false
@@ -1357,7 +1400,7 @@ class Compiler(
.getOrElse {
throw ScriptError(
tOp.pos,
"object is not enumerable: no index access for ${sourceObj.inspect()}",
"object is not enumerable: no index access for ${sourceObj.inspect(cxt)}",
it
)
}
@@ -1384,7 +1427,7 @@ class Compiler(
}
}
if (!breakCaught && elseStatement != null) {
result = elseStatement.execute(ctx)
result = elseStatement.execute(cxt)
}
result
}
@@ -1692,7 +1735,7 @@ class Compiler(
if (cc.current().type == Token.Type.COLON) parseTypeDeclaration()
return inCodeContext(CodeContext.Function(name)) {
return inCodeContext(CodeContext.Function(name)) {
// Here we should be at open body
val fnStatements = if (isExtern)
@@ -1721,7 +1764,7 @@ class Compiler(
val fnCreateStatement = statement(start) { context ->
// we added fn in the context. now we must save closure
// for the function, unless we're in the class scope:
if( isStatic || parentContext !is CodeContext.ClassBody)
if (isStatic || parentContext !is CodeContext.ClassBody)
closure = context
val annotatedFnBody = annotation?.invoke(context, ObjString(name), fnBody)
@@ -1968,7 +2011,15 @@ class Compiler(
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.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
Operator.simple(Token.Type.SHUTTLE, ++lastPriority) { c, a, b ->
@@ -39,7 +39,6 @@ class CompilerContext(val tokens: List<Token>) {
fun next() =
if (currentIndex < tokens.size) tokens[currentIndex++]
else Token("", tokens.last().pos, Token.Type.EOF)
// throw IllegalStateException("No more tokens")
fun previous() = if (!hasPrevious()) throw IllegalStateException("No previous token") else tokens[--currentIndex]
@@ -131,6 +130,28 @@ class CompilerContext(val tokens: List<Token>) {
previous()
}
fun nextNonWhitespace(): Token {
while (true) {
val t = next()
if (t.type !in wstokens) return t
}
}
/**
* Find next non-whitespace token and return it. The token is not extracted,
* is will be returned on [next] call.
* @return next non-whitespace token without extracting it from tokens list
*/
fun peekNextNonWhitespace(): Token {
while (true) {
val t = next()
if (t.type !in wstokens) {
previous()
return t
}
}
}
inline fun ifNextIs(typeId: Token.Type, f: (Token) -> Unit): Boolean {
val t = next()
@@ -207,7 +228,7 @@ class CompilerContext(val tokens: List<Token>) {
while (current().type in wstokens) {
next()
}
return next()
return current()
}
companion object {
@@ -433,10 +433,10 @@ private class Parser(fromPos: Pos) {
'\\' -> {
pos.advance() ?: raise("unterminated string")
when (currentChar) {
'n' -> sb.append('\n')
'r' -> sb.append('\r')
't' -> sb.append('\t')
'"' -> sb.append('"')
'n' -> {sb.append('\n'); pos.advance()}
'r' -> {sb.append('\r'); pos.advance()}
't' -> {sb.append('\t'); pos.advance()}
'"' -> {sb.append('"'); pos.advance()}
else -> sb.append('\\').append(currentChar)
}
}
@@ -57,15 +57,15 @@ class Script(
ObjException.addExceptionsToContext(this)
addFn("print") {
for ((i, a) in args.withIndex()) {
if (i > 0) print(' ' + a.asStr.value)
else print(a.asStr.value)
if (i > 0) print(' ' + a.toString(this).value)
else print(a.toString(this).value)
}
ObjVoid
}
addFn("println") {
for ((i, a) in args.withIndex()) {
if (i > 0) print(' ' + a.asStr.value)
else print(a.asStr.value)
if (i > 0) print(' ' + a.toString(this).value)
else print(a.toString(this).value)
}
println()
ObjVoid
@@ -165,13 +165,13 @@ class Script(
val a = requiredArg<Obj>(0)
val b = requiredArg<Obj>(1)
if( a.compareTo(this, b) != 0 )
raiseError(ObjAssertionFailedException(this,"Assertion failed: ${a.inspect()} == ${b.inspect()}"))
raiseError(ObjAssertionFailedException(this,"Assertion failed: ${a.inspect(this)} == ${b.inspect(this)}"))
}
addVoidFn("assertNotEquals") {
val a = requiredArg<Obj>(0)
val b = requiredArg<Obj>(1)
if( a.compareTo(this, b) == 0 )
raiseError(ObjAssertionFailedException(this,"Assertion failed: ${a.inspect()} != ${b.inspect()}"))
raiseError(ObjAssertionFailedException(this,"Assertion failed: ${a.inspect(this)} != ${b.inspect(this)}"))
}
addFn("assertThrows") {
val code = requireOnlyArg<Statement>()
@@ -287,7 +287,7 @@ class Script(
is ObjInt -> delay(a.value * 1000)
is ObjReal -> delay((a.value * 1000).roundToLong())
is ObjDuration -> delay(a.duration)
else -> raiseIllegalArgument("Expected Duration, Int or Real, got ${a.inspect()}")
else -> raiseIllegalArgument("Expected Duration, Int or Real, got ${a.inspect(this)}")
}
ObjVoid
}
@@ -33,6 +33,6 @@ open class ScriptError(val pos: Pos, val errorMessage: String, cause: Throwable?
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)
@@ -17,10 +17,14 @@
package net.sergeych.lyng
import net.sergeych.lyng.obj.ObjString
class Source(val fileName: String, text: String) {
val lines = text.lines().map { it.trimEnd() }
val objSourceName by lazy { ObjString(fileName) }
companion object {
val builtIn: Source by lazy { Source("built-in", "") }
val UNKNOWN: Source by lazy { Source("UNKNOWN", "") }
@@ -26,6 +26,7 @@ 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
@@ -49,7 +50,7 @@ open class Obj {
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.
@@ -84,14 +85,16 @@ open class Obj {
scope: Scope,
name: String,
args: Arguments = Arguments.EMPTY,
onNotFoundResult: Obj?=null
): Obj =
objClass.getInstanceMemberOrNull(name)?.value?.invoke(
onNotFoundResult: (() -> Obj?)? = null
): Obj {
return objClass.getInstanceMemberOrNull(name)?.value?.invoke(
scope,
this,
args)
?: onNotFoundResult
args
)
?: onNotFoundResult?.invoke()
?: scope.raiseSymbolNotFound(name)
}
open suspend fun getInstanceMethod(
scope: Scope,
@@ -113,8 +116,28 @@ open class Obj {
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()) }
}
/**
@@ -274,9 +297,9 @@ open class Obj {
scope.raiseNotImplemented()
}
fun autoInstanceScope(parent: Scope): Scope {
val scope = parent.copy(newThisObj = this, args = parent.args)
for( m in objClass.members) {
fun autoInstanceScope(parent: Scope): Scope {
val scope = parent.copy(newThisObj = this, args = parent.args)
for (m in objClass.members) {
scope.objects[m.key] = m.value
}
return scope
@@ -285,8 +308,11 @@ open class Obj {
companion object {
val rootObjectType = ObjClass("Obj").apply {
addFn("toString") {
thisObj.asStr
addFn("toString", true) {
thisObj.toString(this, true)
}
addFn("inspect", true) {
thisObj.inspect(this).toObj()
}
addFn("contains") {
ObjBool(thisObj.contains(this, args.firstAndOnly()))
@@ -298,10 +324,8 @@ open class Obj {
addFn("apply") {
val body = args.firstAndOnly()
(thisObj as? ObjInstance)?.let {
println("apply in ${thisObj is ObjInstance}, ${it.instanceScope}")
body.callOn(ApplyScope(this, it.instanceScope))
} ?: run {
println("apply on non-instance $thisObj")
body.callOn(this)
}
thisObj
@@ -310,6 +334,9 @@ open class Obj {
args.firstAndOnly().callOn(copy(Arguments(thisObj)))
thisObj
}
addFn("run") {
args.firstAndOnly().callOn(this)
}
addFn("getAt") {
requireExactCount(1)
thisObj.getAt(this, requiredArg<Obj>(0))
@@ -384,9 +411,14 @@ object ObjNull : Obj() {
scope.raiseNPE()
}
override suspend fun invokeInstanceMethod(scope: Scope, name: String, args: Arguments, onNotFoundResult: Obj?): Obj {
scope.raiseNPE()
}
// override suspend fun invokeInstanceMethod(
// scope: Scope,
// name: String,
// args: Arguments,
// onNotFoundResult: (()->Obj?)?
// ): Obj {
// scope.raiseNPE()
// }
override suspend fun getAt(scope: Scope, index: Obj): Obj {
scope.raiseNPE()
@@ -428,6 +460,9 @@ object ObjNull : Obj() {
}
}
/**
* TODO: get rid of it. Maybe we ise some Lyng inheritance instead
*/
interface Numeric {
val longValue: Long
val doubleValue: Double
@@ -458,21 +493,59 @@ fun Obj.toBool(): Boolean =
data class ObjNamespace(val name: String) : Obj() {
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 {
return "package $name"
}
}
open class ObjException(exceptionClass: ExceptionClass, val scope: Scope, val message: String) : Obj() {
/**
* 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,
message
ObjString(message)
)
constructor(scope: Scope, message: String) : this(Root, scope, 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)
@@ -480,25 +553,60 @@ open class ObjException(exceptionClass: ExceptionClass, val scope: Scope, val me
override val objClass: ObjClass = exceptionClass
override fun toString(): String {
return "ObjException:${objClass.className}:${scope.pos}@${hashCode().encodeToHex()}"
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() ?: name
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()
@@ -51,5 +51,25 @@ val ObjArray by lazy {
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
data class ObjBool(val value: Boolean) : Obj() {
override val asStr by lazy { ObjString(value.toString()) }
override suspend fun compareTo(scope: Scope, other: Obj): Int {
if (other !is ObjBool) return -2
@@ -19,19 +19,26 @@ package net.sergeych.lyng.obj
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.toList
import net.sergeych.bintools.decodeHex
import net.sergeych.bintools.encodeToHex
import net.sergeych.bintools.toDump
import net.sergeych.lyng.Scope
import net.sergeych.lyng.statement
import net.sergeych.lynon.BitArray
import net.sergeych.lynon.LynonDecoder
import net.sergeych.lynon.LynonEncoder
import net.sergeych.lynon.LynonType
import net.sergeych.mp_tools.decodeBase64Url
import net.sergeych.mp_tools.encodeToBase64Url
import kotlin.math.min
open class ObjBuffer(val byteArray: UByteArray) : Obj() {
override val objClass: ObjClass = type
val hex by lazy { byteArray.encodeToHex("")}
val base64 by lazy { byteArray.toByteArray().encodeToBase64Url()}
fun checkIndex(scope: Scope, index: Obj): Int {
if (index !is ObjInt)
scope.raiseIllegalArgument("index must be Int")
@@ -80,12 +87,10 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
byteArray + other.toFlow(scope).map { it.toLong().toUByte() }.toList().toTypedArray()
.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 {
return "Buffer(${byteArray.encodeToHex()})"
}
override fun toString(): String = base64
override fun equals(other: Any?): Boolean {
if (this === other) return true
@@ -102,6 +107,8 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
encoder.encodeCachedBytes(byteArray.asByteArray())
}
override suspend fun inspect(scope: Scope): String = "Buf($base64)"
companion object {
private suspend fun createBufferFrom(scope: Scope, obj: Obj): ObjBuffer =
when (obj) {
@@ -122,7 +129,7 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
)
} else
scope.raiseIllegalArgument(
"can't construct buffer from ${obj.inspect()}"
"can't construct buffer from ${obj.inspect(scope)}"
)
}
}
@@ -142,7 +149,7 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
is ObjChar -> b.value.code.toUByte()
is ObjInt -> b.value.toUByte()
else -> scope.raiseIllegalArgument(
"invalid byte value for buffer constructor at index $i: ${b.inspect()}"
"invalid byte value for buffer constructor at index $i: ${b.inspect(scope)}"
)
}
data[i] = code
@@ -158,11 +165,27 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
})
}.apply {
addClassFn("decodeBase64") {
ObjBuffer(requireOnlyArg<Obj>().toString().decodeBase64Url().asUByteArray())
}
addClassFn("decodeHex") {
ObjBuffer(requireOnlyArg<Obj>().toString().decodeHex().asUByteArray())
}
createField("size",
statement {
(thisObj as ObjBuffer).byteArray.size.toObj()
}
)
createField("hex",
statement {
thisAs<ObjBuffer>().hex.toObj()
}
)
createField("base64",
statement {
thisAs<ObjBuffer>().base64.toObj()
}
)
addFn("decodeUtf8") {
ObjString(
thisAs<ObjBuffer>().byteArray.toByteArray().decodeToString()
@@ -178,6 +201,9 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
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 inspect(): String = "'$value'"
override suspend fun inspect(scope: Scope): String = "'$value'"
override fun hashCode(): Int {
return value.hashCode()
@@ -61,13 +61,17 @@ open class ObjClass(
override suspend fun callOn(scope: Scope): Obj {
val instance = ObjInstance(this)
instance.instanceScope = scope.copy(newThisObj = instance,args = scope.args)
instance.instanceScope = scope.copy(newThisObj = instance, args = scope.args)
if (instanceConstructor != null) {
instanceConstructor!!.execute(instance.instanceScope)
}
return instance
}
suspend fun callWithArgs(scope: Scope, vararg plainArgs: Obj): Obj {
return callOn(scope.copy(Arguments(*plainArgs)))
}
fun createField(
name: String,
@@ -77,13 +81,13 @@ open class ObjClass(
pos: Pos = Pos.builtIn
) {
val existing = members[name] ?: allParentsSet.firstNotNullOfOrNull { it.members[name] }
if( existing?.isMutable == false)
if (existing?.isMutable == false)
throw ScriptError(pos, "$name is already defined in $objClass or one of its supertypes")
members[name] = ObjRecord(initialValue, isMutable, visibility)
}
private fun initClassScope(): Scope {
if( classScope == null ) classScope = Scope()
if (classScope == null) classScope = Scope()
return classScope!!
}
@@ -96,7 +100,7 @@ open class ObjClass(
) {
initClassScope()
val existing = classScope!!.objects[name]
if( existing != null)
if (existing != null)
throw ScriptError(pos, "$name is already defined in $objClass or one of its supertypes")
classScope!!.addItem(name, isMutable, initialValue, visibility)
}
@@ -127,26 +131,29 @@ open class ObjClass(
override suspend fun readField(scope: Scope, name: String): ObjRecord {
classScope?.objects?.get(name)?.let {
if( it.visibility.isPublic ) return it
if (it.visibility.isPublic) return it
}
return super.readField(scope, name)
}
override suspend fun writeField(scope: Scope, name: String, newValue: Obj) {
initClassScope().objects[name]?.let {
if( it.isMutable) it.value = newValue
if (it.isMutable) it.value = newValue
else scope.raiseIllegalAssignment("can't assign $name is not mutable")
}
?: super.writeField(scope, name, newValue)
}
override suspend fun invokeInstanceMethod(scope: Scope, name: String, args: Arguments,
onNotFoundResult: Obj?): Obj {
override suspend fun invokeInstanceMethod(
scope: Scope, name: String, args: Arguments,
onNotFoundResult: (() -> Obj?)?
): Obj {
return classScope?.objects?.get(name)?.value?.invoke(scope, this, args)
?: super.invokeInstanceMethod(scope, name, args, onNotFoundResult)
}
open suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj = scope.raiseNotImplemented()
open suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj =
scope.raiseNotImplemented()
}
@@ -18,8 +18,8 @@
package net.sergeych.lyng.obj
/**
* Collection is an iterator with `size`]
* Collection is an iterator with `size`
*/
val ObjCollection = ObjClass("Collection", ObjIterable).apply {
}
}
@@ -57,7 +57,7 @@ class ObjDuration(val duration: Duration) : Obj() {
override suspend fun callOn(scope: Scope): Obj {
val args = scope.args
if( args.list.size > 1 )
scope.raiseIllegalArgument("can't construct Duration(${args.inspect()})")
scope.raiseIllegalArgument("can't construct Duration(${args.inspect(scope)})")
val a0 = args.list.getOrNull(0)
return ObjDuration(
@@ -66,7 +66,7 @@ class ObjDuration(val duration: Duration) : Obj() {
is ObjInt -> a0.value.seconds
is ObjReal -> a0.value.seconds
else -> {
scope.raiseIllegalArgument("can't construct Instant(${args.inspect()})")
scope.raiseIllegalArgument("can't construct Instant(${args.inspect(scope)})")
}
}
)
@@ -48,7 +48,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
}
override suspend fun invokeInstanceMethod(scope: Scope, name: String, args: Arguments,
onNotFoundResult: Obj?): Obj =
onNotFoundResult: (()->Obj?)?): Obj =
instanceScope[name]?.let {
if (it.visibility.isPublic)
it.value.invoke(
@@ -30,12 +30,19 @@ class ObjInstanceClass(val name: String) : ObjClass(name) {
override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj {
val args = decoder.decodeAnyList(scope)
val actualSize = constructorMeta?.params?.size ?: 0
if( args.size > actualSize )
if (args.size > actualSize)
scope.raiseIllegalArgument("constructor $name has only $actualSize but serialized version has ${args.size}")
val newScope = scope.copy(args = Arguments(args))
return (callOn(newScope) as ObjInstance).apply {
deserializeStateVars(scope,decoder)
invokeInstanceMethod(scope, "onDeserialized", onNotFoundResult = ObjVoid)
deserializeStateVars(scope, decoder)
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
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
class ObjInt(var value: Long, override val isConst: Boolean = false) : Obj(), Numeric {
override val asStr get() = ObjString(value.toString())
override val longValue get() = value
override val doubleValue get() = value.toDouble()
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 val objClass: ObjClass = type
override val objClass: ObjClass by lazy { type }
override suspend fun plus(scope: Scope, other: Obj): Obj =
if (other is ObjInt)
@@ -119,12 +119,6 @@ val ObjIterable by lazy {
ObjList(result)
}
// addFn("drop" ) {
// var n = requireOnlyArg<ObjInt>().value.toInt()
// if( n < 0 ) raiseIllegalArgument("drop($n): should be positive")
// val it = callMethod<>()
// }
addFn("isEmpty") {
ObjBool(
thisObj.invokeInstanceMethod(this, "iterator")
@@ -132,5 +126,20 @@ val ObjIterable by lazy {
.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
}
}
}
@@ -82,18 +82,18 @@ fun Obj.toFlow(scope: Scope): Flow<Obj> = flow {
*
* IF callback returns false, iteration is stopped.
*/
suspend fun Obj.enumerate(scope: Scope,callback: suspend (Obj)->Boolean) {
suspend fun Obj.enumerate(scope: Scope, callback: suspend (Obj) -> Boolean) {
val iterator = invokeInstanceMethod(scope, "iterator")
val hasNext = iterator.getInstanceMethod(scope, "hasNext")
val next = iterator.getInstanceMethod(scope, "next")
var closeIt = false
while (hasNext.invoke(scope, iterator).toBool()) {
val nextValue = next.invoke(scope, iterator)
if( !callback(nextValue) ) {
if (!callback(nextValue)) {
closeIt = true
break
}
}
if( closeIt )
iterator.invokeInstanceMethod(scope, "cancelIteration", onNotFoundResult = ObjVoid)
if (closeIt)
iterator.invokeInstanceMethod(scope, "cancelIteration") { ObjVoid }
}
@@ -18,6 +18,7 @@
package net.sergeych.lyng.obj
import net.sergeych.lyng.Scope
import net.sergeych.lyng.Statement
import net.sergeych.lyng.statement
import net.sergeych.lynon.LynonDecoder
import net.sergeych.lynon.LynonEncoder
@@ -25,10 +26,6 @@ import net.sergeych.lynon.LynonType
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 {
return when (index) {
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) }
}
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 {
// check?
return list.hashCode()
@@ -239,8 +263,27 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
}
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 ObjChar -> newValue.value.code.toUByte()
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
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 ObjInt -> b.value.toUByte()
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
@@ -26,12 +26,12 @@ class ObjRange(val start: Obj?, val end: Obj?, val isEndInclusive: Boolean) : Ob
override val objClass: ObjClass = type
override fun toString(): String {
override suspend fun toString(scope: Scope,calledFromLyng: Boolean): ObjString {
val result = StringBuilder()
result.append("${start?.inspect() ?: '∞'} ..")
result.append("${start?.inspect(scope) ?: '∞'} ..")
if (!isEndInclusive) result.append('<')
result.append(" ${end?.inspect() ?: '∞'}")
return result.toString()
result.append(" ${end?.inspect(scope) ?: '∞'}")
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]
* otherwise returns start.value.toInt()
*/
fun startInt(scope: Scope): Int =
suspend fun startInt(scope: Scope): Int =
if( start == null || start is ObjNull) 0
else {
if( start is ObjInt) start.value.toInt()
else scope.raiseIllegalArgument("start is not Int: ${start.inspect()}")
else scope.raiseIllegalArgument("start is not Int: ${start.inspect(scope)}")
}
suspend fun containsRange(scope: Scope, other: ObjRange): Boolean {
@@ -27,7 +27,6 @@ import kotlin.math.floor
import kotlin.math.roundToLong
data class ObjReal(val value: Double) : Obj(), Numeric {
override val asStr by lazy { ObjString(value.toString()) }
override val longValue: Long by lazy { floor(value).toLong() }
override val doubleValue: Double by lazy { value }
override val toObjInt: ObjInt by lazy { ObjInt(longValue) }
@@ -44,9 +44,7 @@ data class ObjString(val value: String) : Obj() {
override fun toString(): String = value
override val asStr: ObjString by lazy { this }
override fun inspect(): String {
override suspend fun inspect(scope: Scope): String {
return "\"$value\""
}
@@ -54,7 +52,7 @@ data class ObjString(val value: String) : Obj() {
get() = type
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 {
@@ -159,6 +157,9 @@ data class ObjString(val value: String) : Obj() {
addFn("toReal") {
ObjReal(thisAs<ObjString>().value.toDouble())
}
addFn("trim") {
thisAs<ObjString>().value.trim().let(::ObjString)
}
}
}
}
@@ -77,9 +77,8 @@ fun Iterable.dropLast(n) {
}
fun Iterable.takeLast(n) {
val list = this
val buffer = RingBuffer(n)
for( item in list ) buffer += item
for( item in this ) buffer += item
buffer
}
@@ -95,21 +94,77 @@ fun Iterable.joinToString(prefix=" ", transformer=null) {
fun Iterable.any(predicate): Bool {
for( i in this ) {
if( predicate(i) ) {
break true
// todo: add cancelIteration() in for loop!
}
if( predicate(i) )
break true
} else false
}
fun Iterable.all(predicate): Bool {
for( i in this ) {
if( !predicate(i) ) {
break false
}
}
else true
!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)
}
}
""".trimIndent()
@@ -101,7 +101,6 @@ interface BitOutput {
val compressed = LZW.compress(source.asUByteArray())
// check that compression is effective including header bits size:
if( compressed.size + 2 < source.size * 8L) {
println("write compressed")
putBit(1)
// LZW algorithm
putBits(0, 2)
@@ -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 {
val className = decodeObject(scope, ObjString.type, null) as ObjString
return scope.get(className.value)?.value?.let {
@@ -72,7 +85,7 @@ open class LynonDecoder(val bin: BitInput, val settings: LynonSettings = LynonSe
} ?: scope.raiseSymbolNotFound("can't deserialize: not found type $className")
}
suspend fun decodeAnyList(scope: Scope,fixedSize: Int?=null): MutableList<Obj> {
suspend fun decodeAnyList(scope: Scope, fixedSize: Int? = null): MutableList<Obj> {
return if (bin.getBit() == 1) {
// homogenous
val type = LynonType.entries[getBitsAsInt(4)]
@@ -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())
}
@Test
fun testMultilineConstructor() = runTest {
eval("""
class Point(
x,
y
)
assertEquals(Point(1,2), Point(1,2) )
""".trimIndent())
}
}
+315 -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
fun testCharacterRange() = runTest {
eval(
@@ -1760,7 +1789,7 @@ class ScriptTest {
"e="+e+"f="+f()
}
assertEquals("e=[]f=xx", f { "xx" })
assertEquals("e=[1, 2]f=xx", f(1,2) { "xx" })
assertEquals("e=[1,2]f=xx", f(1,2) { "xx" })
""".trimIndent()
)
@@ -1795,7 +1824,7 @@ class ScriptTest {
}
val f = Foo()
assertEquals("e=[]f=xx", f.f { "xx" })
assertEquals("e=[1, 2]f=xx", f.f(1,2) { "xx" })
assertEquals("e=[1,2]f=xx", f.f(1,2) { "xx" })
""".trimIndent()
)
@@ -2006,7 +2035,7 @@ class ScriptTest {
@Test
fun testThrowFromKotlin() = runTest {
val c = Scope()
val c = Script.newScope()
c.addFn("callThrow") {
raiseIllegalArgument("fromKotlin")
}
@@ -2630,6 +2659,28 @@ class ScriptTest {
)
}
@Test
fun testBufferEncodings() = runTest {
eval(
"""
import lyng.buffer
val b = Buffer("hello")
println(b.toDump())
assertEquals( "hello", b.decodeUtf8() )
println(b.base64)
println(b.hex)
assertEquals( b, Buffer.decodeBase64(b.base64) )
assertEquals( b, Buffer.decodeHex(b.hex) )
println(b.inspect())
""".trimIndent()
)
}
@Test
fun testBufferCompare() = runTest {
eval(
@@ -2851,7 +2902,8 @@ class ScriptTest {
@Test
fun tesFunAnnotation() = runTest {
eval("""
eval(
"""
val exportedSymbols = Map()
@@ -2870,7 +2922,8 @@ class ScriptTest {
assert( exportedSymbols["getBalance"] != null )
assertEquals(122, getBalance(1))
""".trimIndent())
""".trimIndent()
)
}
@Test
@@ -2890,12 +2943,14 @@ class ScriptTest {
assertEquals( Color.valueOf("GREEN"), Color.GREEN )
""".trimIndent())
""".trimIndent()
)
}
@Test
fun enumSerializationTest() = runTest {
eval("""
eval(
"""
import lyng.serialization
enum Color {
@@ -2911,12 +2966,14 @@ class ScriptTest {
assert( e1.size / 1000.0 < 6)
println(Lynon.encode( (1..100).map { "RED" } ).toDump() )
""".trimIndent())
""".trimIndent()
)
}
@Test
fun cachedTest() = runTest {
eval( """
eval(
"""
var counter = 0
var value = cached {
@@ -2929,17 +2986,263 @@ class ScriptTest {
assertEquals(1, counter)
assertEquals("ok", value())
assertEquals(1, counter)
""".trimIndent())
""".trimIndent()
)
}
@Test
fun testJoinToString() = runTest {
eval("""
eval(
"""
assertEquals( (1..3).joinToString(), "1 2 3")
assertEquals( (1..3).joinToString(":"), "1:2:3")
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())
}
}
+13 -3
View File
@@ -177,11 +177,11 @@ suspend fun DocTest.test(_scope: Scope? = null) {
scope.apply {
addFn("println") {
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 {
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')
}
}
@@ -194,7 +194,7 @@ suspend fun DocTest.test(_scope: Scope? = null) {
} catch (e: Throwable) {
error = e
null
}?.inspect()?.replace(Regex("@\\d+"), "@...")
}?.inspect(scope)?.replace(Regex("@\\d+"), "@...")
if (bookMode) {
if (error != null) {
@@ -322,4 +322,14 @@ class BookTest {
runDocTests("../docs/Iterable.md")
}
@Test
fun testSerialization() = runBlocking {
runDocTests("../docs/serialization.md")
}
@Test
fun testArray() = runBlocking {
runDocTests("../docs/Array.md")
}
}
+42
View File
@@ -649,6 +649,48 @@ class LynonTests {
""".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"))
}
}