Compare commits
15
Commits
eefecae7b4
...
0.8.15
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
80735f032d | ||
|
|
dc837e2095 | ||
|
|
0ec0ed96ee | ||
|
|
a5e51a3f90 | ||
|
|
cf79163802 | ||
|
|
c8e8bdc466 | ||
|
|
4b613fda7c | ||
|
|
8d1cafae80 | ||
|
|
0526cdfb38 | ||
|
|
cad6ba936d | ||
|
|
cb333ab6bd | ||
|
|
23737f9b5c | ||
|
|
fb6e2aa49e | ||
|
|
95c1da60ed | ||
|
|
835333dfad |
No files matched your search
@@ -158,6 +158,7 @@ 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:
|
||||||
|
|
||||||
@@ -165,7 +166,6 @@ Ready features:
|
|||||||
- [ ] 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+
|
## v1.1+
|
||||||
|
|
||||||
|
|||||||
@@ -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
@@ -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,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
@@ -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
@@ -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
@@ -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
|
||||||
|
|||||||
@@ -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
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
@@ -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
@@ -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)
|
||||||
|
//}
|
||||||
@@ -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)
|
||||||
+30
-9
@@ -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:
|
||||||
@@ -475,7 +489,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 +514,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 +765,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 +1139,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 +1155,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
|
||||||
|
|
||||||
@@ -1253,6 +1270,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 |
|
||||||
@@ -1292,7 +1310,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 +1330,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 +1362,5 @@ 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
|
||||||
@@ -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.8.15-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")
|
||||||
@@ -971,7 +1008,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 +1221,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 +1364,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)
|
||||||
@@ -1347,7 +1384,13 @@ class Compiler(
|
|||||||
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 +1400,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 +1427,7 @@ class Compiler(
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
if (!breakCaught && elseStatement != null) {
|
if (!breakCaught && elseStatement != null) {
|
||||||
result = elseStatement.execute(ctx)
|
result = elseStatement.execute(cxt)
|
||||||
}
|
}
|
||||||
result
|
result
|
||||||
}
|
}
|
||||||
@@ -1968,7 +2011,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 {
|
||||||
|
|||||||
@@ -433,10 +433,10 @@ private class Parser(fromPos: Pos) {
|
|||||||
'\\' -> {
|
'\\' -> {
|
||||||
pos.advance() ?: raise("unterminated string")
|
pos.advance() ?: raise("unterminated string")
|
||||||
when (currentChar) {
|
when (currentChar) {
|
||||||
'n' -> sb.append('\n')
|
'n' -> {sb.append('\n'); pos.advance()}
|
||||||
'r' -> sb.append('\r')
|
'r' -> {sb.append('\r'); pos.advance()}
|
||||||
't' -> sb.append('\t')
|
't' -> {sb.append('\t'); pos.advance()}
|
||||||
'"' -> sb.append('"')
|
'"' -> {sb.append('"'); pos.advance()}
|
||||||
else -> sb.append('\\').append(currentChar)
|
else -> sb.append('\\').append(currentChar)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -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>()
|
||||||
@@ -287,7 +287,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", "") }
|
||||||
|
|||||||
@@ -26,6 +26,7 @@ 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.mptools.CachedExpression
|
||||||
import net.sergeych.synctools.ProtectedOp
|
import net.sergeych.synctools.ProtectedOp
|
||||||
import net.sergeych.synctools.withLock
|
import net.sergeych.synctools.withLock
|
||||||
import kotlin.contracts.ExperimentalContracts
|
import kotlin.contracts.ExperimentalContracts
|
||||||
@@ -49,7 +50,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 +85,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 +116,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()) }
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
@@ -285,11 +308,11 @@ open class Obj {
|
|||||||
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 +324,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 +334,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 +411,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 +460,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,21 +493,59 @@ 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() {
|
/**
|
||||||
|
* 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(
|
constructor(name: String, scope: Scope, message: String) : this(
|
||||||
getOrCreateExceptionClass(name),
|
getOrCreateExceptionClass(name),
|
||||||
scope,
|
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 {
|
fun raise(): Nothing {
|
||||||
throw ExecutionError(this)
|
throw ExecutionError(this)
|
||||||
@@ -483,25 +553,60 @@ open class ObjException(exceptionClass: ExceptionClass, val scope: Scope, val me
|
|||||||
|
|
||||||
override val objClass: ObjClass = exceptionClass
|
override val objClass: ObjClass = exceptionClass
|
||||||
|
|
||||||
override fun toString(): String {
|
override suspend fun toString(scope: Scope,calledFromLyng: Boolean): ObjString {
|
||||||
return "ObjException:${objClass.className}:${scope.pos}@${hashCode().encodeToHex()}"
|
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 {
|
companion object {
|
||||||
|
|
||||||
class ExceptionClass(val name: String, vararg parents: ObjClass) : ObjClass(name, *parents) {
|
class ExceptionClass(val name: String, vararg parents: ObjClass) : ObjClass(name, *parents) {
|
||||||
override suspend fun callOn(scope: Scope): Obj {
|
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)
|
return ObjException(this, scope, message)
|
||||||
}
|
}
|
||||||
|
|
||||||
override fun toString(): String = "ExceptionClass[$name]@${hashCode().encodeToHex()}"
|
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 {
|
val Root = ExceptionClass("Throwable").apply {
|
||||||
addConst("message", statement {
|
addConst("message", statement {
|
||||||
(thisObj as ObjException).message.toObj()
|
(thisObj as ObjException).message.toObj()
|
||||||
})
|
})
|
||||||
|
addFn("stackTrace") {
|
||||||
|
(thisObj as ObjException).getStackTrace()
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
private val op = ProtectedOp()
|
private val op = ProtectedOp()
|
||||||
|
|||||||
@@ -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)})")
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
)
|
)
|
||||||
|
|||||||
@@ -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) }
|
||||||
|
|||||||
@@ -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,7 +52,7 @@ 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 {
|
||||||
@@ -159,6 +157,9 @@ 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)
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -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,68 @@ 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)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
""".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
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -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())
|
||||||
|
}
|
||||||
}
|
}
|
||||||
@@ -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")
|
||||||
}
|
}
|
||||||
@@ -2632,7 +2661,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 +2677,8 @@ class ScriptTest {
|
|||||||
|
|
||||||
println(b.inspect())
|
println(b.inspect())
|
||||||
|
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
@@ -2871,7 +2902,8 @@ class ScriptTest {
|
|||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun tesFunAnnotation() = runTest {
|
fun tesFunAnnotation() = runTest {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
|
|
||||||
val exportedSymbols = Map()
|
val exportedSymbols = Map()
|
||||||
|
|
||||||
@@ -2890,7 +2922,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 +2943,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 +2966,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 +2986,263 @@ 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()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@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())
|
""".trimIndent())
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
}
|
}
|
||||||
@@ -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,14 @@ 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")
|
||||||
|
}
|
||||||
|
|
||||||
}
|
}
|
||||||
@@ -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"))
|
||||||
|
}
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
Reference in new issue
Block a user