Compare commits

...
30 Commits
Author SHA1 Message Date
sergeych f168e9f6ed version bump 2026-04-02 13:01:51 +03:00
sergeych a051280e0c fix in site search and more tests on evalSession cancellation 2026-04-02 03:02:46 +03:00
sergeych fc01016a74 Added EvalSession way of controlling all coroutines started from a script 2026-04-02 02:05:14 +03:00
sergeych 446c8d9a6e minor additions 2026-04-01 02:51:00 +03:00
sergeych c140567e0c made last changes KMP compliant 2026-04-01 02:51:00 +03:00
sergeych 311cf6ee44 Add Lyng deferred cancellation support 2026-03-31 22:50:46 +03:00
sergeych 3e338f3d53 Fix sqrt type inference and add regression coverage 2026-03-31 22:26:58 +03:00
sergeych c097464750 - fixed CLI -x mode
- fixed a wrong error message when global symbol is not found
2026-03-31 20:52:31 +03:00
sergeych 6e9333844e support for Decimal.isInfitite and isNan 2026-03-31 19:13:45 +03:00
sergeych a976702caf support for Real.isInfitite and isNan 2026-03-31 19:08:11 +03:00
sergeych 850efedb72 Handle non-finite real/decimal arithmetic 2026-03-31 16:57:18 +03:00
sergeych f845213332 fixed Decima/Complex interop bug 2026-03-30 09:25:29 +03:00
sergeych cdd48ec871 Improved instance method resolution logic and added test for Decimal overloading. 2026-03-30 08:53:07 +03:00
sergeych 286ec30422 Added Decimal support for complex number 2026-03-30 08:20:55 +03:00
sergeych 8a560f5417 fixed interpolation bug 2026-03-29 12:35:10 +03:00
sergeych 966b6a31ae extended inference of fun return type 2026-03-29 03:57:02 +03:00
sergeych c3c0a3292b fixed Decimal conversion bug 2026-03-29 03:35:53 +03:00
sergeych aa9565b40b fixed Decimal (and other such classes ) comparison 2026-03-29 01:29:48 +03:00
sergeych 05d7432b37 fixes on Decimals and bound kotlin classes 2026-03-29 01:20:20 +03:00
sergeych c7c333b71a fixed some issues with Decimals 2026-03-29 00:39:48 +03:00
sergeych e55d9c835a another snapshot release, configs for matrix operations 2026-03-28 23:28:28 +03:00
sergeych 83d8c8b71f Added Vectors and Matrics operations, slicing, docs. 2026-03-28 22:25:40 +03:00
sergeych a72991d1b7 debug stuff cleanup and simplify 2026-03-28 17:50:53 +03:00
sergeych cd007050a8 added complext number support 2026-03-28 17:44:43 +03:00
sergeych 418b1ae2b6 Fix captured bound global writes in nested bytecode blocks 2026-03-28 00:47:08 +03:00
sergeych b0fb65a036 Fix bound property captures and property slot resolution 2026-03-28 00:00:59 +03:00
sergeych 86e8b2e2bc site upgrades 2026-03-27 22:36:23 +03:00
sergeych a98fe51983 version bump 2026-03-27 21:49:53 +03:00
sergeych f8d36beae1 Merge branch 'bigdecimals' 2026-03-27 21:32:25 +03:00
sergeych 5ab074ba9e readme updated 2026-03-27 21:30:21 +03:00
92 changed files with 5393 additions and 598 deletions

No files matched your search

+1
View File
@@ -27,3 +27,4 @@ debug.log
/compile_jvm_output.txt /compile_jvm_output.txt
/compile_metadata_output.txt /compile_metadata_output.txt
test_output*.txt test_output*.txt
/site/src/version-template/lyng-version.js
+24 -15
View File
@@ -93,21 +93,25 @@ import net.sergeych.lyng.*
// we need a coroutine to start, as Lyng // we need a coroutine to start, as Lyng
// is a coroutine based language, async topdown // is a coroutine based language, async topdown
runBlocking { runBlocking {
assert(5 == eval(""" 3*3 - 4 """).toInt()) val session = EvalSession()
eval(""" println("Hello, Lyng!") """) assert(5 == session.eval(""" 3*3 - 4 """).toInt())
session.eval(""" println("Hello, Lyng!") """)
} }
``` ```
### Exchanging information ### Exchanging information
Script is executed over some `Scope`. Create instance, The preferred host runtime is `EvalSession`. It owns the script scope and any coroutines
add your specific vars and functions to it, and call: started with `launch { ... }`. Create a session, grab its scope when you need low-level
binding APIs, then execute scripts through the session:
```kotlin ```kotlin
import net.sergeych.lyng.* import net.sergeych.lyng.*
runBlocking {
val session = EvalSession()
val scope = session.getScope().apply {
// simple function // simple function
val scope = Script.newScope().apply {
addFn("sumOf") { addFn("sumOf") {
var sum = 0.0 var sum = 0.0
for (a in args) sum += a.toDouble() for (a in args) sum += a.toDouble()
@@ -125,10 +129,13 @@ val scope = Script.newScope().apply {
doSomeWork(args[0]).toObj() doSomeWork(args[0]).toObj()
} }
} }
// adding constant:
scope.eval("sumOf(1,2,3)") // <- 6 // execute through the session:
session.eval("sumOf(1,2,3)") // <- 6
}
``` ```
Note that the scope stores all changes in it so you can make calls on a single scope to preserve state between calls. Note that the session reuses one scope, so state persists across `session.eval(...)` calls.
Use raw `Scope.eval(...)` only when you intentionally want low-level control without session-owned coroutine lifecycle.
## IntelliJ IDEA plugin: Lightweight autocompletion (experimental) ## IntelliJ IDEA plugin: Lightweight autocompletion (experimental)
@@ -221,17 +228,15 @@ All of this is documented in the [language site](https://lynglang.com) and local
- [x] site with integrated interpreter to give a try - [x] site with integrated interpreter to give a try
- [x] kotlin part public API good docs, integration focused - [x] kotlin part public API good docs, integration focused
- [ ] type specifications - [x] type specifications
- [x] Textmate Bundle - [x] Textmate Bundle
- [x] IDEA plugin - [x] IDEA plugin
- [ ] source docs and maybe lyng.md to a standard - [x] source docs and maybe lyng.md to a standard
- [ ] metadata first class access from lyng
- [x] aggressive optimizations - [x] aggressive optimizations
- [ ] compile to JVM bytecode optimization
## After 1.5 "Ideal scripting" ## After 1.5 "Ideal scripting"
Estimated summer 2026 * __we are here now ;)__
- propose your feature! - propose your feature!
@@ -239,8 +244,12 @@ Estimated summer 2026
@-links are for contacting authors on [project home](https://gitea.sergeych.net/SergeychWorks/lyng): this simplest s to open issue for the person you need to convey any information about this project. @-links are for contacting authors on [project home](https://gitea.sergeych.net/SergeychWorks/lyng): this simplest s to open issue for the person you need to convey any information about this project.
__Sergey Chernov__ @sergeych: Initial idea and architecture, language concept, design, implementation. <img src="https://www.gravatar.com/avatar/7e3a56ff8a090fc9ffbd1909dea94904?s=32&d=identicon" alt="Sergey Chernov" width="32" height="32" style="vertical-align: middle; margin-right: 0.5em;" /> <b>Sergey Chernov</b> @sergeych, real.sergeych@gmail.com: Initial idea and architecture, language concept, design, implementation.
<br/>
<img src="https://www.gravatar.com/avatar/53a90bca30c85a81db8f0c0d8dea43a1?s=32&d=identicon" alt="Yulia Nezhinskaya" width="32" height="32" style="vertical-align: middle; margin-right: 0.5em;" /> <b>Yulia Nezhinskaya</b> @AlterEgoJuliaN, neleka88@gmail.com: System analysis, math and feature design.
__Yulia Nezhinskaya__ @AlterEgoJuliaN: System analysis, math and features design.
[parallelism]: docs/parallelism.md [parallelism]: docs/parallelism.md
-7
View File
@@ -1,7 +0,0 @@
# Bytecode Migration Plan (Archived)
Status: completed.
Historical reference:
- `notes/archive/bytecode_migration_plan.md` (full plan)
- `notes/archive/bytecode_migration_plan_completed.md` (summary)
+7
View File
@@ -4,6 +4,13 @@ It's an interface if the [Collection] that provides indexing access, like `array
Array therefore implements [Iterable] too. Well known implementations of `Array` are Array therefore implements [Iterable] too. Well known implementations of `Array` are
[List] and [ImmutableList]. [List] and [ImmutableList].
The language-level bracket syntax supports one or more selectors:
- `value[i]`
- `value[i, j]`
Concrete array-like types decide what selectors they accept. Built-in list-like arrays use one selector at a time; custom types such as matrices may interpret multiple selectors.
Array adds the following methods: Array adds the following methods:
## Binary search ## Binary search
+82
View File
@@ -0,0 +1,82 @@
# Complex Numbers (`lyng.complex`)
`lyng.complex` adds a pure-Lyng `Complex` type backed by `Real` components.
Import it when you want ordinary complex arithmetic:
```lyng
import lyng.complex
```
## Construction
Use any of these:
```lyng
import lyng.complex
val a = Complex(1.0, 2.0)
val b = complex(1.0, 2.0)
val c = 2.i
val d = 3.re
assertEquals(Complex(1.0, 2.0), 1 + 2.i)
```
Convenience extensions:
- `Int.re`, `Real.re`: embed a real value into the complex plane
- `Int.i`, `Real.i`: create a pure imaginary value
- `cis(angle)`: shorthand for `cos(angle) + i sin(angle)`
## Core Operations
`Complex` supports:
- `+`
- `-`
- `*`
- `/`
- unary `-`
- `conjugate`
- `magnitude`
- `phase`
Mixed arithmetic with `Int` and `Real` is enabled through `lyng.operators`, so both sides work naturally:
```lyng
import lyng.complex
assertEquals(Complex(1.0, 2.0), 1 + 2.i)
assertEquals(Complex(1.5, 2.0), 1.5 + 2.i)
assertEquals(Complex(2.0, 2.0), 2.i + 2)
```
Mixed equality with built-in numeric types is intentionally not promised yet. Keep equality checks in the `Complex` domain for now.
## Transcendental Functions
For now, use member-style calls:
```lyng
import lyng.complex
val z = 1 + π.i
val w = z.exp()
val s = z.sin()
val r = z.sqrt()
```
This is deliberate. Lyng already has built-in top-level real-valued functions such as `exp(x)` and `sin(x)`, and imported modules do not currently replace those root bindings. So plain `exp(z)` is not yet the right extension mechanism for complex math.
## Design Scope
This module intentionally uses `Complex` with `Real` parts, not `Complex<T>`.
Reasons:
- the existing math runtime is `Real`-centric
- the operator interop registry works with concrete runtime classes
- transcendental functions (`exp`, `sin`, `ln`, `sqrt`) are defined over the `Real` math backend here
If Lyng later gets a more general numeric-trait or callable-overload registry, a generic algebraic `Complex<T>` can be revisited on firmer ground.
+84 -9
View File
@@ -8,9 +8,9 @@ Import it when you need decimal arithmetic that should not inherit `Real`'s bina
import lyng.decimal import lyng.decimal
``` ```
## What `BigDecimal` Is For ## What `Decimal` Is For
Use `BigDecimal` when values are fundamentally decimal: Use `Decimal` when values are fundamentally decimal:
- money - money
- human-entered quantities - human-entered quantities
@@ -38,8 +38,8 @@ assertEquals("2.2", c.toStringExpanded())
The three forms mean different things: The three forms mean different things:
- `1.d`: convert `Int -> BigDecimal` - `1.d`: convert `Int -> Decimal`
- `2.2.d`: convert `Real -> BigDecimal` - `2.2.d`: convert `Real -> Decimal`
- `"2.2".d`: parse exact decimal text - `"2.2".d`: parse exact decimal text
That distinction is intentional. That distinction is intentional.
@@ -67,16 +67,36 @@ The explicit factory methods are:
```lyng ```lyng
import lyng.decimal import lyng.decimal
BigDecimal.fromInt(10) Decimal.fromInt(10)
BigDecimal.fromReal(2.5) Decimal.fromReal(2.5)
BigDecimal.fromString("12.34") Decimal.fromString("12.34")
``` ```
These are equivalent to the conversion-property forms, but sometimes clearer in APIs or generated code. These are equivalent to the conversion-property forms, but sometimes clearer in APIs or generated code.
## From Kotlin
If you already have an ionspin `BigDecimal` on the host side, the simplest supported way to create a Lyng `Decimal` is:
```kotlin
import com.ionspin.kotlin.bignum.decimal.BigDecimal
import net.sergeych.lyng.EvalSession
import net.sergeych.lyng.asFacade
import net.sergeych.lyng.newDecimal
val scope = EvalSession().getScope()
val decimal = scope.asFacade().newDecimal(BigDecimal.parseStringWithMode("12.34"))
```
Notes:
- `newDecimal(...)` loads `lyng.decimal` if needed
- it returns a real Lyng `Decimal` object instance
- this is the preferred Kotlin-side construction path when you already hold a host `BigDecimal`
## Core Operations ## Core Operations
`BigDecimal` supports: `Decimal` supports:
- `+` - `+`
- `-` - `-`
@@ -115,7 +135,7 @@ assert(2 == 2.d)
assert(3 > 2.d) assert(3 > 2.d)
``` ```
Without this registration mechanism, only the cases directly implemented on the left-hand class would work. The bridge fills the gap for expressions such as `Int + BigDecimal` and `Real + BigDecimal`. Without this registration mechanism, only the cases directly implemented on the left-hand class would work. The bridge fills the gap for expressions such as `Int + Decimal` and `Real + Decimal`.
See [OperatorInterop.md](OperatorInterop.md) for the generic mechanism behind that. See [OperatorInterop.md](OperatorInterop.md) for the generic mechanism behind that.
@@ -146,6 +166,17 @@ assertEquals(2.9, "2.9".d.toReal())
Use `toReal()` only when you are willing to return to binary floating-point semantics. Use `toReal()` only when you are willing to return to binary floating-point semantics.
## Non-Finite Checks
`Decimal` values are always finite, so these helpers exist for API symmetry with `Real` and always return `false`:
```lyng
import lyng.decimal
assertEquals(false, "2.9".d.isInfinite())
assertEquals(false, "2.9".d.isNaN())
```
## Division Context ## Division Context
Division is the operation where precision and rounding matter most. Division is the operation where precision and rounding matter most.
@@ -223,6 +254,50 @@ assertEquals("-0.12", withDecimalContext(2, DecimalRounding.HalfTowardsZero) { (
## Recommended Usage Rules ## Recommended Usage Rules
## Decimal With Stdlib Math Functions
Core math helpers such as `abs`, `floor`, `ceil`, `round`, `sin`, `exp`, `ln`, `sqrt`, `log10`, `log2`, and `pow`
now also accept `Decimal`.
Current behavior is intentionally split:
- exact decimal implementation:
- `abs(x)`
- `floor(x)`
- `ceil(x)`
- `round(x)`
- `pow(x, y)` when `x` is `Decimal` and `y` is an integral exponent
- temporary bridge through `Real`:
- `sin`, `cos`, `tan`
- `asin`, `acos`, `atan`
- `sinh`, `cosh`, `tanh`
- `asinh`, `acosh`, `atanh`
- `exp`, `ln`, `log10`, `log2`
- `sqrt`
- `pow` for the remaining non-integral decimal exponent cases
The temporary bridge is:
```lyng
Decimal -> Real -> host math -> Decimal
```
This is a compatibility step, not the long-term design. Native decimal implementations will replace these bridge-based
paths over time.
Examples:
```lyng
import lyng.decimal
assertEquals("2.5", (abs("-2.5".d) as Decimal).toStringExpanded())
assertEquals("2", (floor("2.9".d) as Decimal).toStringExpanded())
// Temporary Real bridge:
assertEquals((exp(1.25) as Real).d.toStringExpanded(), (exp("1.25".d) as Decimal).toStringExpanded())
assertEquals((sqrt(2.0) as Real).d.toStringExpanded(), (sqrt("2".d) as Decimal).toStringExpanded())
```
If you care about exact decimal source text: If you care about exact decimal source text:
```lyng ```lyng
+7
View File
@@ -30,6 +30,13 @@ There is a shortcut for the last:
__Important__ negative indexes works wherever indexes are used, e.g. in insertion and removal methods too. __Important__ negative indexes works wherever indexes are used, e.g. in insertion and removal methods too.
The language also allows multi-selector indexing syntax such as `value[i, j]`, but `List` itself uses a single selector only:
- `list[index]` for one element
- `list[range]` for a slice copy
Multi-selector indexing is intended for custom indexers such as `Matrix`.
## Concatenation ## Concatenation
You can concatenate lists or iterable objects: You can concatenate lists or iterable objects:
+192
View File
@@ -0,0 +1,192 @@
# Matrix (`lyng.matrix`)
`lyng.matrix` adds dense immutable `Matrix` and `Vector` types for linear algebra.
Import it when you need matrix or vector arithmetic:
```lyng
import lyng.matrix
```
## Construction
Create vectors from a flat list and matrices from nested row lists:
```lyng
import lyng.matrix
val v: Vector = vector([1, 2, 3])
val m: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
assertEquals([1.0, 2.0, 3.0], v.toList())
assertEquals([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], m.toList())
```
Factory methods are also available:
```lyng
import lyng.matrix
val z: Vector = Vector.zeros(3)
val i: Matrix = Matrix.identity(3)
val m: Matrix = Matrix.zeros(2, 4)
```
All elements are standard double-precision numeric values internally.
## Shapes
Matrices may have any rectangular geometry:
```lyng
import lyng.matrix
val a: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
assertEquals(2, a.rows)
assertEquals(3, a.cols)
assertEquals([2, 3], a.shape)
assertEquals(false, a.isSquare)
```
Vectors expose:
- `size`
- `length` as an alias of `size`
## Matrix Operations
Supported matrix operations:
- `+` and `-` for element-wise matrix arithmetic
- `*` for matrix-matrix product
- `*` and `/` by a scalar
- `transpose()`
- `trace()`
- `rank()`
- `determinant()`
- `inverse()`
- `solve(rhs)` for `Vector` or `Matrix` right-hand sides
Example:
```lyng
import lyng.matrix
val a: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
val b: Matrix = matrix([[7, 8], [9, 10], [11, 12]])
val product: Matrix = a * b
assertEquals([[58.0, 64.0], [139.0, 154.0]], product.toList())
assertEquals([[1.0, 4.0], [2.0, 5.0], [3.0, 6.0]], a.transpose().toList())
```
Inverse and solve:
```lyng
import lyng.matrix
val a: Matrix = matrix([[4, 7], [2, 6]])
val rhs: Vector = vector([1, 0])
val inv: Matrix = a.inverse()
val x: Vector = a.solve(rhs)
assert(abs(a.determinant() - 10.0) < 1e-9)
assert(abs(inv.get(0, 0) - 0.6) < 1e-9)
assert(abs(x.get(0) - 0.6) < 1e-9)
```
## Vector Operations
Supported vector operations:
- `+` and `-`
- scalar `*` and `/`
- `dot(other)`
- `norm()`
- `normalize()`
- `cross(other)` for 3D vectors
- `outer(other)` producing a matrix
```lyng
import lyng.matrix
val a: Vector = vector([1, 2, 3])
val b: Vector = vector([2, 0, 0])
assertEquals(2.0, a.dot(b))
assertEquals([0.2672612419124244, 0.5345224838248488, 0.8017837257372732], a.normalize().toList())
```
## Indexing and Slicing
`Matrix` supports both method-style indexing and bracket syntax.
Scalar access:
```lyng
import lyng.matrix
val m: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
assertEquals(6.0, m.get(1, 2))
assertEquals(6.0, m[1, 2])
```
Bracket indexing accepts two selectors: `[row, col]`.
Each selector may be either:
- an `Int`
- a `Range`
Examples:
```lyng
import lyng.matrix
val m: Matrix = matrix([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
assertEquals(7.0, m[1, 2])
val columnSlice: Matrix = m[0..2, 2]
val topLeft: Matrix = m[0..1, 0..1]
val tail: Matrix = m[1.., 1..]
assertEquals([[3.0], [7.0], [11.0]], columnSlice.toList())
assertEquals([[1.0, 2.0], [5.0, 6.0]], topLeft.toList())
assertEquals([[6.0, 7.0, 8.0], [10.0, 11.0, 12.0]], tail.toList())
```
Shape rules:
- `m[Int, Int]` returns a `Real`
- `m[Range, Int]` returns an `Nx1` `Matrix`
- `m[Int, Range]` returns a `1xM` `Matrix`
- `m[Range, Range]` returns a submatrix
Open-ended ranges are supported:
- `m[..1, ..1]`
- `m[1.., 1..]`
- `m[.., 2]`
Stepped ranges are not supported in matrix slicing.
Slices currently return new matrices, not views.
## Rows and Columns
If you want plain lists instead of a sliced matrix:
```lyng
import lyng.matrix
val a: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
assertEquals([4.0, 5.0, 6.0], a.row(1))
assertEquals([2.0, 5.0], a.column(1))
```
## Backend Notes
The matrix module uses a platform-specific backend where available and falls back to pure Kotlin where needed.
The public Lyng API stays the same across platforms.
+18 -2
View File
@@ -1183,8 +1183,24 @@ collection's sugar won't work with it:
assertEquals("buzz", x[0]) assertEquals("buzz", x[0])
>>> void >>> void
If you want dynamic to function like an array, create a [feature Multiple selectors are packed into one list index object:
request](https://gitea.sergeych.net/SergeychWorks/lyng/issues).
val x = dynamic {
get {
if( it == [1, 2] ) "hit"
else null
}
}
assertEquals("hit", x[1, 2])
>>> void
So:
- `x[i]` passes `i`
- `x[i, j]` passes `[i, j]`
- `x[i, j, k]` passes `[i, j, k]`
This is the same rule used by Kotlin-backed `getAt` / `putAt` indexers in embedding.
# Theory # Theory
+5 -5
View File
@@ -160,15 +160,15 @@ import lyng.decimal
3 > 2.d 3 > 2.d
``` ```
work naturally even though `Int` and `Real` themselves were not edited to know `BigDecimal`. work naturally even though `Int` and `Real` themselves were not edited to know `Decimal`.
The shape is: The shape is:
- `leftClass = Int` or `Real` - `leftClass = Int` or `Real`
- `rightClass = BigDecimal` - `rightClass = Decimal`
- `commonClass = BigDecimal` - `commonClass = Decimal`
- convert built-ins into `BigDecimal` - convert built-ins into `Decimal`
- leave `BigDecimal` values unchanged - leave `Decimal` values unchanged
## Step-By-Step Pattern For Your Own Type ## Step-By-Step Pattern For Your Own Type
+2
View File
@@ -19,6 +19,8 @@ you can use it's class to ensure type:
|-----------------|-------------------------------------------------------------|------| |-----------------|-------------------------------------------------------------|------|
| `.roundToInt()` | round to nearest int like round(x) | Int | | `.roundToInt()` | round to nearest int like round(x) | Int |
| `.toInt()` | convert integer part of real to `Int` dropping decimal part | Int | | `.toInt()` | convert integer part of real to `Int` dropping decimal part | Int |
| `.isInfinite()` | true when the value is `Infinity` or `-Infinity` | Bool |
| `.isNaN()` | true when the value is `NaN` | Bool |
| `.clamp(range)` | clamp value within range boundaries | Real | | `.clamp(range)` | clamp value within range boundaries | Real |
| | | | | | | |
| | | | | | | |
+6 -1
View File
@@ -82,11 +82,16 @@ Primary sources used: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/{Parser,T
- Type/containment: `is`, `!is`, `in`, `!in`, `as`, `as?`. - Type/containment: `is`, `!is`, `in`, `!in`, `as`, `as?`.
- Null-safe family: - Null-safe family:
- member access: `?.` - member access: `?.`
- safe index: `?[i]` - safe index: `?[i]`, `?[i, j]`
- safe invoke: `?(...)` - safe invoke: `?(...)`
- safe block invoke: `?{ ... }` - safe block invoke: `?{ ... }`
- elvis: `?:` and `??`. - elvis: `?:` and `??`.
- Increment/decrement: prefix and postfix `++`, `--`. - Increment/decrement: prefix and postfix `++`, `--`.
- Indexing syntax:
- single selector: `a[i]`
- multiple selectors: `a[i, j, k]`
- language-level indexing with multiple selectors is passed to `getAt`/`putAt` as one list-like index object, not as multiple method arguments.
- example: `m[0..2, 2]`.
## 5. Declarations ## 5. Declarations
- Variables: - Variables:
+15 -1
View File
@@ -14,7 +14,13 @@ Sources: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt`, `lynglib/s
- Assertions/tests: `assert`, `assertEquals`/`assertEqual`, `assertNotEquals`, `assertThrows`. - Assertions/tests: `assert`, `assertEquals`/`assertEqual`, `assertNotEquals`, `assertThrows`.
- Preconditions: `require`, `check`. - Preconditions: `require`, `check`.
- Async/concurrency: `launch`, `yield`, `flow`, `delay`. - Async/concurrency: `launch`, `yield`, `flow`, `delay`.
- `Deferred.cancel()` cancels an active task.
- `Deferred.await()` throws `CancellationException` if that task was cancelled.
- Math: `floor`, `ceil`, `round`, `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `sinh`, `cosh`, `tanh`, `asinh`, `acosh`, `atanh`, `exp`, `ln`, `log10`, `log2`, `pow`, `sqrt`, `abs`, `clamp`. - Math: `floor`, `ceil`, `round`, `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `sinh`, `cosh`, `tanh`, `asinh`, `acosh`, `atanh`, `exp`, `ln`, `log10`, `log2`, `pow`, `sqrt`, `abs`, `clamp`.
- These helpers also accept `lyng.decimal.Decimal`.
- Exact Decimal path today: `abs`, `floor`, `ceil`, `round`, and `pow` with integral exponent.
- Temporary Decimal path for the rest: convert `Decimal -> Real`, compute, then convert back to `Decimal`.
- Treat that bridge as temporary; prefer native Decimal implementations when they become available.
## 3. Core Global Constants/Types ## 3. Core Global Constants/Types
- Values: `Unset`, `π`. - Values: `Unset`, `π`.
@@ -22,13 +28,14 @@ Sources: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt`, `lynglib/s
- Collections/types: `Iterable`, `Iterator`, `Collection`, `Array`, `List`, `ImmutableList`, `Set`, `ImmutableSet`, `Map`, `ImmutableMap`, `MapEntry`, `Range`, `RingBuffer`. - Collections/types: `Iterable`, `Iterator`, `Collection`, `Array`, `List`, `ImmutableList`, `Set`, `ImmutableSet`, `Map`, `ImmutableMap`, `MapEntry`, `Range`, `RingBuffer`.
- Random: singleton `Random` and class `SeededRandom`. - Random: singleton `Random` and class `SeededRandom`.
- Async types: `Deferred`, `CompletableDeferred`, `Mutex`, `Flow`, `FlowBuilder`. - Async types: `Deferred`, `CompletableDeferred`, `Mutex`, `Flow`, `FlowBuilder`.
- Async exception: `CancellationException`.
- Delegation types: `Delegate`, `DelegateContext`. - Delegation types: `Delegate`, `DelegateContext`.
- Regex types: `Regex`, `RegexMatch`. - Regex types: `Regex`, `RegexMatch`.
- Also present: `Math.PI` namespace constant. - Also present: `Math.PI` namespace constant.
## 4. `lyng.stdlib` Module Surface (from `root.lyng`) ## 4. `lyng.stdlib` Module Surface (from `root.lyng`)
### 4.1 Extern class declarations ### 4.1 Extern class declarations
- Exceptions/delegation base: `Exception`, `IllegalArgumentException`, `NotImplementedException`, `Delegate`. - Exceptions/delegation base: `Exception`, `CancellationException`, `IllegalArgumentException`, `NotImplementedException`, `Delegate`.
- Collections and iterables: `Iterable<T>`, `Iterator<T>`, `Collection<T>`, `Array<T>`, `List<T>`, `ImmutableList<T>`, `Set<T>`, `ImmutableSet<T>`, `Map<K,V>`, `ImmutableMap<K,V>`, `MapEntry<K,V>`, `RingBuffer<T>`. - Collections and iterables: `Iterable<T>`, `Iterator<T>`, `Collection<T>`, `Array<T>`, `List<T>`, `ImmutableList<T>`, `Set<T>`, `ImmutableSet<T>`, `Map<K,V>`, `ImmutableMap<K,V>`, `MapEntry<K,V>`, `RingBuffer<T>`.
- Host iterator bridge: `KotlinIterator<T>`. - Host iterator bridge: `KotlinIterator<T>`.
- Random APIs: `extern object Random`, `extern class SeededRandom`. - Random APIs: `extern object Random`, `extern class SeededRandom`.
@@ -56,6 +63,13 @@ Sources: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt`, `lynglib/s
## 5. Additional Built-in Modules (import explicitly) ## 5. Additional Built-in Modules (import explicitly)
- `import lyng.observable` - `import lyng.observable`
- `Observable`, `Subscription`, `ObservableList`, `ListChange` and change subtypes, `ChangeRejectionException`. - `Observable`, `Subscription`, `ObservableList`, `ListChange` and change subtypes, `ChangeRejectionException`.
- `import lyng.decimal`
- `Decimal`, `DecimalContext`, `DecimalRounding`, `withDecimalContext(...)`.
- Kotlin host helper: `ScopeFacade.newDecimal(BigDecimal)` wraps an ionspin host decimal as a Lyng `Decimal`.
- `import lyng.complex`
- `Complex`, `complex(re, im)`, `cis(angle)`, and numeric embedding extensions such as `2.i` / `3.re`.
- `import lyng.matrix`
- `Matrix`, `Vector`, `matrix(rows)`, `vector(values)`, dense linear algebra, inversion, solving, and matrix slicing with `m[row, col]`.
- `import lyng.buffer` - `import lyng.buffer`
- `Buffer`, `MutableBuffer`. - `Buffer`, `MutableBuffer`.
- `import lyng.serialization` - `import lyng.serialization`
+156 -27
View File
@@ -36,21 +36,60 @@ dependencies {
If you use Kotlin Multiplatform, add the dependency in the `commonMain` source set (and platform‑specific sets if you need platform APIs). If you use Kotlin Multiplatform, add the dependency in the `commonMain` source set (and platform‑specific sets if you need platform APIs).
### 2) Create a runtime (Scope) and execute scripts ### 2) Preferred runtime: `EvalSession`
The easiest way to get a ready‑to‑use scope with standard packages is via `Script.newScope()`. For host applications, prefer `EvalSession` as the main way to run scripts.
It owns one reusable Lyng scope, serializes `eval(...)` calls, and governs coroutines started from Lyng `launch { ... }`.
Main entrypoints:
- `session.eval(code)` / `session.eval(source)`
- `session.getScope()` when you need low-level binding APIs
- `session.cancel()` to cancel active session-owned coroutines
- `session.join()` to wait for active session-owned coroutines
```kotlin
fun main() = kotlinx.coroutines.runBlocking {
val session = EvalSession()
// Evaluate a one‑liner
val result = session.eval("1 + 2 * 3")
println("Lyng result: $result") // ObjReal/ObjInt etc.
// Optional lifecycle management
session.join()
}
```
The session creates its underlying scope lazily. If you need raw low-level APIs, get the scope explicitly:
```kotlin
val session = EvalSession()
val scope = session.getScope()
```
Use `cancel()` / `join()` to govern async work started by scripts:
```kotlin
val session = EvalSession()
session.eval("""launch { delay(1000); println("done") }""")
session.cancel()
session.join()
```
### 2.1) Low-level runtime: `Scope`
Use `Scope` directly when you intentionally want lower-level control.
```kotlin ```kotlin
fun main() = kotlinx.coroutines.runBlocking { fun main() = kotlinx.coroutines.runBlocking {
val scope = Script.newScope() // suspends on first init val scope = Script.newScope() // suspends on first init
// Evaluate a one‑liner
val result = scope.eval("1 + 2 * 3") val result = scope.eval("1 + 2 * 3")
println("Lyng result: $result") // ObjReal/ObjInt etc. println("Lyng result: $result")
} }
``` ```
You can also pre‑compile a script and execute it multiple times: You can also pre‑compile a script and execute it multiple times on the same scope:
```kotlin ```kotlin
val script = Compiler.compile(""" val script = Compiler.compile("""
@@ -63,7 +102,8 @@ val run1 = script.execute(scope)
val run2 = script.execute(scope) val run2 = script.execute(scope)
``` ```
`Scope.eval("...")` is a shortcut that compiles and executes on the given scope. `Scope.eval("...")` is the low-level shortcut that compiles and executes on the given scope.
For most embedding use cases, prefer `session.eval("...")`.
### 3) Preferred: bind extern globals from Kotlin ### 3) Preferred: bind extern globals from Kotlin
@@ -85,6 +125,8 @@ import net.sergeych.lyng.bridge.*
import net.sergeych.lyng.obj.ObjInt import net.sergeych.lyng.obj.ObjInt
import net.sergeych.lyng.obj.ObjString import net.sergeych.lyng.obj.ObjString
val session = EvalSession()
val scope = session.getScope()
val im = Script.defaultImportManager.copy() val im = Script.defaultImportManager.copy()
im.addPackage("my.api") { module -> im.addPackage("my.api") { module ->
module.eval(""" module.eval("""
@@ -149,6 +191,9 @@ binder.bindGlobalFunRaw("echoRaw") { _, args ->
Use this when you intentionally want raw `Scope` APIs. For most module APIs, prefer section 3. Use this when you intentionally want raw `Scope` APIs. For most module APIs, prefer section 3.
```kotlin ```kotlin
val session = EvalSession()
val scope = session.getScope()
// A function returning value // A function returning value
scope.addFn<ObjInt>("inc") { scope.addFn<ObjInt>("inc") {
val x = args.firstAndOnly() as ObjInt val x = args.firstAndOnly() as ObjInt
@@ -167,7 +212,7 @@ scope.addVoidFn("log") {
// } // }
// Call them from Lyng // Call them from Lyng
scope.eval("val y = inc(41); log('Answer:', y)") session.eval("val y = inc(41); log('Answer:', y)")
``` ```
You can register multiple names (aliases) at once: `addFn<ObjInt>("inc", "increment") { ... }`. You can register multiple names (aliases) at once: `addFn<ObjInt>("inc", "increment") { ... }`.
@@ -183,11 +228,79 @@ Scope-backed Kotlin lambdas receive a `ScopeFacade` (not a full `Scope`). For mi
If you truly need the full `Scope` (e.g., for low-level interop), use `requireScope()` explicitly. If you truly need the full `Scope` (e.g., for low-level interop), use `requireScope()` explicitly.
### 4.5) Indexers from Kotlin: `getAt` and `putAt`
Lyng bracket syntax is dispatched through `getAt` and `putAt`.
That means:
- `x[i]` calls `getAt(index)`
- `x[i] = value` calls `putAt(index, value)` or `setAt(index, value)`
- field-like `x["name"]` also uses the same index path unless you expose a real field/property
For Kotlin-backed classes, bind indexers as ordinary methods named `getAt` and `putAt`:
```kotlin
moduleScope.eval("""
extern class Grid {
override fun getAt(index: List<Int>): Int
override fun putAt(index: List<Int>, value: Int): void
}
""".trimIndent())
moduleScope.bind("Grid") {
init { _ -> data = IntArray(4) }
addFun("getAt") {
val index = args.requiredArg<ObjList>(0)
val row = (index.list[0] as ObjInt).value.toInt()
val col = (index.list[1] as ObjInt).value.toInt()
val data = (thisObj as ObjInstance).data as IntArray
ObjInt.of(data[row * 2 + col].toLong())
}
addFun("putAt") {
val index = args.requiredArg<ObjList>(0)
val value = args.requiredArg<ObjInt>(1).value.toInt()
val row = (index.list[0] as ObjInt).value.toInt()
val col = (index.list[1] as ObjInt).value.toInt()
val data = (thisObj as ObjInstance).data as IntArray
data[row * 2 + col] = value
ObjVoid
}
}
```
Usage from Lyng:
```lyng
val g = Grid()
g[0, 1] = 42
assertEquals(42, g[0, 1])
```
Important rule: multiple selectors inside brackets are packed into one index object.
So:
- `x[i]` passes `i`
- `x[i, j]` passes a `List` containing `[i, j]`
- `x[i, j, k]` passes `[i, j, k]`
This applies equally to:
- Kotlin-backed classes
- Lyng classes overriding `getAt`
- `dynamic { get { ... } set { ... } }`
If you want multi-axis slicing semantics, decode that list yourself in `getAt`.
### 5) Add Kotlin‑backed fields ### 5) Add Kotlin‑backed fields
If you need a simple field (with a value) instead of a computed property, use `createField`. This adds a field to the class that will be present in all its instances. If you need a simple field (with a value) instead of a computed property, use `createField`. This adds a field to the class that will be present in all its instances.
```kotlin ```kotlin
val session = EvalSession()
val scope = session.getScope()
val myClass = ObjClass("MyClass") val myClass = ObjClass("MyClass")
// Add a read-only field (constant) // Add a read-only field (constant)
@@ -215,6 +328,8 @@ println(instance.count) // -> 5
Properties in Lyng are pure accessors (getters and setters) and do not have automatic backing fields. You can add them to a class using `addProperty`. Properties in Lyng are pure accessors (getters and setters) and do not have automatic backing fields. You can add them to a class using `addProperty`.
```kotlin ```kotlin
val session = EvalSession()
val scope = session.getScope()
val myClass = ObjClass("MyClass") val myClass = ObjClass("MyClass")
var internalValue: Long = 10 var internalValue: Long = 10
@@ -381,8 +496,9 @@ For Kotlin code that needs dynamic access to Lyng variables, functions, or membe
It provides explicit, cached handles and predictable lookup rules. It provides explicit, cached handles and predictable lookup rules.
```kotlin ```kotlin
val scope = Script.newScope() val session = EvalSession()
scope.eval(""" val scope = session.getScope()
session.eval("""
val x = 40 val x = 40
fun add(a, b) = a + b fun add(a, b) = a + b
class Box { var value = 1 } class Box { var value = 1 }
@@ -397,7 +513,7 @@ val x = resolver.resolveVal("x").get(scope)
val sum = (resolver as BridgeCallByName).callByName(scope, "add", Arguments(ObjInt(1), ObjInt(2))) val sum = (resolver as BridgeCallByName).callByName(scope, "add", Arguments(ObjInt(1), ObjInt(2)))
// Member access // Member access
val box = scope.eval("Box()") val box = session.eval("Box()")
val valueHandle = resolver.resolveMemberVar(box, "value") val valueHandle = resolver.resolveMemberVar(box, "value")
valueHandle.set(scope, ObjInt(10)) valueHandle.set(scope, ObjInt(10))
val value = valueHandle.get(scope) val value = valueHandle.get(scope)
@@ -408,12 +524,14 @@ val value = valueHandle.get(scope)
The simplest approach: evaluate an expression that yields the value and convert it. The simplest approach: evaluate an expression that yields the value and convert it.
```kotlin ```kotlin
val kotlinAnswer = scope.eval("(1 + 2) * 3").toKotlin(scope) // -> 9 (Int) val session = EvalSession()
val scope = session.getScope()
val kotlinAnswer = session.eval("(1 + 2) * 3").toKotlin(scope) // -> 9 (Int)
// After scripts manipulate your vars: // After scripts manipulate your vars:
scope.addOrUpdateItem("name", ObjString("Lyng")) scope.addOrUpdateItem("name", ObjString("Lyng"))
scope.eval("name = name + ' rocks!'") session.eval("name = name + ' rocks!'")
val kotlinName = scope.eval("name").toKotlin(scope) // -> "Lyng rocks!" val kotlinName = session.eval("name").toKotlin(scope) // -> "Lyng rocks!"
``` ```
Advanced: you can also grab a variable record directly via `scope.get(name)` and work with its `Obj` value, but evaluating `"name"` is often clearer and enforces Lyng semantics consistently. Advanced: you can also grab a variable record directly via `scope.get(name)` and work with its `Obj` value, but evaluating `"name"` is often clearer and enforces Lyng semantics consistently.
@@ -426,16 +544,20 @@ There are two convenient patterns.
```kotlin ```kotlin
// Suppose Lyng defines: fun add(a, b) = a + b // Suppose Lyng defines: fun add(a, b) = a + b
scope.eval("fun add(a, b) = a + b") val session = EvalSession()
val scope = session.getScope()
session.eval("fun add(a, b) = a + b")
val sum = scope.eval("add(20, 22)").toKotlin(scope) // -> 42 val sum = session.eval("add(20, 22)").toKotlin(scope) // -> 42
``` ```
2) Call a Lyng function by name via a prepared call scope: 2) Call a Lyng function by name via a prepared call scope:
```kotlin ```kotlin
// Ensure the function exists in the scope // Ensure the function exists in the scope
scope.eval("fun add(a, b) = a + b") val session = EvalSession()
val scope = session.getScope()
session.eval("fun add(a, b) = a + b")
// Look up the function object // Look up the function object
val addFn = scope.get("add")!!.value as Statement val addFn = scope.get("add")!!.value as Statement
@@ -466,7 +588,8 @@ Register a Kotlin‑built package:
import net.sergeych.lyng.bridge.* import net.sergeych.lyng.bridge.*
import net.sergeych.lyng.obj.ObjInt import net.sergeych.lyng.obj.ObjInt
val scope = Script.newScope() val session = EvalSession()
val scope = session.getScope()
// Access the import manager behind this scope // Access the import manager behind this scope
val im: ImportManager = scope.importManager val im: ImportManager = scope.importManager
@@ -497,12 +620,12 @@ im.addPackage("my.tools") { module: ModuleScope ->
} }
// Use it from Lyng // Use it from Lyng
scope.eval(""" session.eval("""
import my.tools.* import my.tools.*
val v = triple(14) val v = triple(14)
status = "busy" status = "busy"
""") """)
val v = scope.eval("v").toKotlin(scope) // -> 42 val v = session.eval("v").toKotlin(scope) // -> 42
``` ```
Register a package from Lyng source text: Register a package from Lyng source text:
@@ -516,24 +639,27 @@ val pkgText = """
scope.importManager.addTextPackages(pkgText) scope.importManager.addTextPackages(pkgText)
scope.eval(""" session.eval("""
import math.extra.* import math.extra.*
val s = sqr(12) val s = sqr(12)
""") """)
val s = scope.eval("s").toKotlin(scope) // -> 144 val s = session.eval("s").toKotlin(scope) // -> 144
``` ```
You can also register from parsed `Source` instances via `addSourcePackages(source)`. You can also register from parsed `Source` instances via `addSourcePackages(source)`.
### 10) Executing from files, security, and isolation ### 10) Executing from files, security, and isolation
- To run code from a file, read it and pass to `scope.eval(text)` or compile with `Compiler.compile(Source(fileName, text))`. - To run code from a file, read it and pass to `session.eval(text)` or compile with `Compiler.compile(Source(fileName, text))`.
- `ImportManager` takes an optional `SecurityManager` if you need to restrict what packages or operations are available. By default, `Script.defaultImportManager` allows everything suitable for embedded use; clamp it down in sandboxed environments. - `ImportManager` takes an optional `SecurityManager` if you need to restrict what packages or operations are available. By default, `Script.defaultImportManager` allows everything suitable for embedded use; clamp it down in sandboxed environments.
- For isolation, create fresh modules/scopes via `Scope.new()` or `Script.newScope()` when you need a clean environment per request. - For isolation, prefer a fresh `EvalSession()` per request. Use `Scope.new()` / `Script.newScope()` when you specifically need low-level raw scopes or modules.
```kotlin ```kotlin
// Fresh module based on the default manager, without the standard prelude // Preferred per-request runtime:
val isolated = net.sergeych.lyng.Scope.new() val isolatedSession = EvalSession()
// Low-level fresh module based on the default manager, without the standard prelude:
val isolatedScope = net.sergeych.lyng.Scope.new()
``` ```
### 11) Tips and troubleshooting ### 11) Tips and troubleshooting
@@ -568,8 +694,11 @@ To simplify handling these objects from Kotlin, several extension methods are pr
You can serialize Lyng exception objects using `Lynon` to transmit them across boundaries and then rethrow them. You can serialize Lyng exception objects using `Lynon` to transmit them across boundaries and then rethrow them.
```kotlin ```kotlin
val session = EvalSession()
val scope = session.getScope()
try { try {
scope.eval("throw MyUserException(404, \"Not Found\")") session.eval("throw MyUserException(404, \"Not Found\")")
} catch (e: ExecutionError) { } catch (e: ExecutionError) {
// 1. Serialize the Lyng exception object // 1. Serialize the Lyng exception object
val encoded: UByteArray = lynonEncodeAny(scope, e.errorObject) val encoded: UByteArray = lynonEncodeAny(scope, e.errorObject)
+4 -3
View File
@@ -122,7 +122,8 @@ data class TestJson2(
@Test @Test
fun deserializeMapWithJsonTest() = runTest { fun deserializeMapWithJsonTest() = runTest {
val x = eval(""" val session = EvalSession()
val x = session.eval("""
import lyng.serialization import lyng.serialization
{ value: 1, inner: { "foo": 1, "bar": 2 }} { value: 1, inner: { "foo": 1, "bar": 2 }}
""".trimIndent()).decodeSerializable<TestJson2>() """.trimIndent()).decodeSerializable<TestJson2>()
@@ -143,7 +144,8 @@ data class TestJson3(
) )
@Test @Test
fun deserializeAnyMapWithJsonTest() = runTest { fun deserializeAnyMapWithJsonTest() = runTest {
val x = eval(""" val session = EvalSession()
val x = session.eval("""
import lyng.serialization import lyng.serialization
{ value: 12, inner: { "foo": 1, "bar": "two" }} { value: 12, inner: { "foo": 1, "bar": "two" }}
""".trimIndent()).decodeSerializable<TestJson3>() """.trimIndent()).decodeSerializable<TestJson3>()
@@ -175,4 +177,3 @@ on [Instant](time.md), see `Instant.truncateTo...` functions.
(3) (3)
: Map keys must be strings, map values may be any objects serializable to Json. : Map keys must be strings, map values may be any objects serializable to Json.
+3 -2
View File
@@ -9,12 +9,13 @@
#### Install in host #### Install in host
```kotlin ```kotlin
import net.sergeych.lyng.Script import net.sergeych.lyng.EvalSession
import net.sergeych.lyng.io.console.createConsoleModule import net.sergeych.lyng.io.console.createConsoleModule
import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy
suspend fun initScope() { suspend fun initScope() {
val scope = Script.newScope() val session = EvalSession()
val scope = session.getScope()
createConsoleModule(PermitAllConsoleAccessPolicy, scope) createConsoleModule(PermitAllConsoleAccessPolicy, scope)
} }
``` ```
+10 -6
View File
@@ -39,23 +39,27 @@ This brings in:
--- ---
#### Install the module into a Lyng Scope #### Install the module into a Lyng session
The filesystem module is not installed automatically. You must explicitly register it in the scope’s `ImportManager` using the installer. You can customize access control via `FsAccessPolicy`. The filesystem module is not installed automatically. The preferred host runtime is `EvalSession`: create the session, get its underlying scope, install the module there, and execute scripts through the session. You can customize access control via `FsAccessPolicy`.
Kotlin (host) bootstrap example: Kotlin (host) bootstrap example:
```kotlin ```kotlin
import net.sergeych.lyng.EvalSession
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.io.fs.createFs import net.sergeych.lyng.io.fs.createFs
import net.sergeych.lyngio.fs.security.PermitAllAccessPolicy import net.sergeych.lyngio.fs.security.PermitAllAccessPolicy
val scope: Scope = Scope.new() suspend fun bootstrapFs() {
val session = EvalSession()
val scope: Scope = session.getScope()
val installed: Boolean = createFs(PermitAllAccessPolicy, scope) val installed: Boolean = createFs(PermitAllAccessPolicy, scope)
// installed == true on first registration in this ImportManager, false on repeats // installed == true on first registration in this ImportManager, false on repeats
// In scripts (or via scope.eval), import the module to use its symbols: // In scripts (or via session.eval), import the module to use its symbols:
scope.eval("import lyng.io.fs") session.eval("import lyng.io.fs")
}
``` ```
You can install with a custom policy too (see Access policy below). You can install with a custom policy too (see Access policy below).
@@ -185,7 +189,7 @@ val denyWrites = object : FsAccessPolicy {
} }
createFs(denyWrites, scope) createFs(denyWrites, scope)
scope.eval("import lyng.io.fs") session.eval("import lyng.io.fs")
``` ```
Composite operations like `copy` and `move` are checked as a set of primitives (e.g., `OpenRead(src)` + `Delete(dst)` if overwriting + `CreateFile(dst)` + `OpenWrite(dst)`). Composite operations like `copy` and `move` are checked as a set of primitives (e.g., `OpenRead(src)` + `Delete(dst)` if overwriting + `CreateFile(dst)` + `OpenWrite(dst)`).
+9 -7
View File
@@ -20,24 +20,26 @@ For external projects, ensure you have the appropriate Maven repository configur
--- ---
#### Install the module into a Lyng Scope #### Install the module into a Lyng session
The process module is not installed automatically. You must explicitly register it in the scope’s `ImportManager` using `createProcessModule`. You can customize access control via `ProcessAccessPolicy`. The process module is not installed automatically. The preferred host runtime is `EvalSession`: create the session, get its underlying scope, install the module there, and execute scripts through the session. You can customize access control via `ProcessAccessPolicy`.
Kotlin (host) bootstrap example: Kotlin (host) bootstrap example:
```kotlin ```kotlin
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.Script import net.sergeych.lyng.EvalSession
import net.sergeych.lyng.io.process.createProcessModule import net.sergeych.lyng.io.process.createProcessModule
import net.sergeych.lyngio.process.security.PermitAllProcessAccessPolicy import net.sergeych.lyngio.process.security.PermitAllProcessAccessPolicy
// ... inside a suspend function or runBlocking suspend fun bootstrapProcess() {
val scope: Scope = Script.newScope() val session = EvalSession()
val scope: Scope = session.getScope()
createProcessModule(PermitAllProcessAccessPolicy, scope) createProcessModule(PermitAllProcessAccessPolicy, scope)
// In scripts (or via scope.eval), import the module: // In scripts (or via session.eval), import the module:
scope.eval("import lyng.io.process") session.eval("import lyng.io.process")
}
``` ```
--- ---
+4 -3
View File
@@ -37,7 +37,7 @@ dependencies {
To use `lyngio` modules in your scripts, you must install them into your Lyng scope and provide a security policy. To use `lyngio` modules in your scripts, you must install them into your Lyng scope and provide a security policy.
```kotlin ```kotlin
import net.sergeych.lyng.Script import net.sergeych.lyng.EvalSession
import net.sergeych.lyng.io.fs.createFs import net.sergeych.lyng.io.fs.createFs
import net.sergeych.lyng.io.process.createProcessModule import net.sergeych.lyng.io.process.createProcessModule
import net.sergeych.lyng.io.console.createConsoleModule import net.sergeych.lyng.io.console.createConsoleModule
@@ -46,7 +46,8 @@ import net.sergeych.lyngio.process.security.PermitAllProcessAccessPolicy
import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy
suspend fun runMyScript() { suspend fun runMyScript() {
val scope = Script.newScope() val session = EvalSession()
val scope = session.getScope()
// Install modules with policies // Install modules with policies
createFs(PermitAllAccessPolicy, scope) createFs(PermitAllAccessPolicy, scope)
@@ -54,7 +55,7 @@ suspend fun runMyScript() {
createConsoleModule(PermitAllConsoleAccessPolicy, scope) createConsoleModule(PermitAllConsoleAccessPolicy, scope)
// Now scripts can import them // Now scripts can import them
scope.eval(""" session.eval("""
import lyng.io.fs import lyng.io.fs
import lyng.io.process import lyng.io.process
import lyng.io.console import lyng.io.console
+73 -3
View File
@@ -60,8 +60,13 @@ but:
## Round and range ## Round and range
The following functions return its argument if it is `Int`, The following functions return the argument unchanged if it is `Int`.
or transformed `Real` otherwise.
For `Decimal`:
- `floor(x)`, `ceil(x)`, and `round(x)` currently use exact decimal operations
- the result stays `Decimal`
For `Real`, the result is a transformed `Real`.
| name | description | | name | description |
|----------------|--------------------------------------------------------| |----------------|--------------------------------------------------------|
@@ -72,6 +77,14 @@ or transformed `Real` otherwise.
## Lyng math functions ## Lyng math functions
Decimal note:
- all scalar math helpers accept `Decimal`
- `abs(x)` stays exact for `Decimal`
- `pow(x, y)` is exact for `Decimal` when `y` is an integral exponent
- the remaining `Decimal` cases currently use a temporary bridge:
`Decimal -> Real -> host math -> Decimal`
- this is temporary; native decimal implementations are planned
| name | meaning | | name | meaning |
|-----------|------------------------------------------------------| |-----------|------------------------------------------------------|
| sin(x) | sine | | sin(x) | sine |
@@ -91,7 +104,7 @@ or transformed `Real` otherwise.
| log10(x) | $log_{10}(x)$ | | log10(x) | $log_{10}(x)$ |
| pow(x, y) | ${x^y}$ | | pow(x, y) | ${x^y}$ |
| sqrt(x) | $ \sqrt {x}$ | | sqrt(x) | $ \sqrt {x}$ |
| abs(x) | absolute value of x. Int if x is Int, Real otherwise | | abs(x) | absolute value of x. Int if x is Int, Decimal if x is Decimal, Real otherwise |
| clamp(x, range) | limit x to be inside range boundaries | | clamp(x, range) | limit x to be inside range boundaries |
For example: For example:
@@ -104,12 +117,69 @@ For example:
assert( abs(-1) is Int) assert( abs(-1) is Int)
assert( abs(-2.21) == 2.21 ) assert( abs(-2.21) == 2.21 )
import lyng.decimal
// Decimal-aware math works too. Some functions are exact, some still bridge through Real temporarily:
assert( (abs("-2.5".d) as Decimal).toStringExpanded() == "2.5" )
assert( (floor("2.9".d) as Decimal).toStringExpanded() == "2" )
assert( sin("0.5".d) is Decimal )
// clamp() limits value to the range: // clamp() limits value to the range:
assert( clamp(15, 0..10) == 10 ) assert( clamp(15, 0..10) == 10 )
assert( clamp(-5, 0..10) == 0 ) assert( clamp(-5, 0..10) == 0 )
assert( 5.clamp(0..10) == 5 ) assert( 5.clamp(0..10) == 5 )
>>> void >>> void
## Linear algebra: `lyng.matrix`
For vectors and dense matrices, import `lyng.matrix`:
```lyng
import lyng.matrix
```
It provides:
- `Vector`
- `Matrix`
- `vector(values)`
- `matrix(rows)`
Core operations include:
- matrix addition and subtraction
- matrix-matrix multiplication
- matrix-vector multiplication
- transpose
- determinant
- inverse
- linear solve
- vector dot, norm, normalize, cross, outer product
Example:
```lyng
import lyng.matrix
val a: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
val b: Matrix = matrix([[7, 8], [9, 10], [11, 12]])
val product: Matrix = a * b
assertEquals([[58.0, 64.0], [139.0, 154.0]], product.toList())
```
Matrices also support two-axis bracket indexing and slicing:
```lyng
import lyng.matrix
val m: Matrix = matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
assertEquals(6.0, m[1, 2])
val sub: Matrix = m[0..1, 1..2]
assertEquals([[2.0, 3.0], [5.0, 6.0]], sub.toList())
```
See [Matrix](Matrix.md) for the full API.
## Random values ## Random values
Lyng stdlib provides a global random singleton and deterministic seeded generators: Lyng stdlib provides a global random singleton and deterministic seeded generators:
+16 -1
View File
@@ -32,10 +32,25 @@ Depending on the platform, these coroutines may be executed on different CPU and
assert(xIsCalled) assert(xIsCalled)
>>> void >>> void
This example shows how to launch a coroutine with `launch` which returns [Deferred] instance, the latter have ways to await for the coroutine completion and retrieve possible result. This example shows how to launch a coroutine with `launch` which returns [Deferred] instance, the latter have ways to await for the coroutine completion, cancel it if it is no longer needed, and retrieve possible result.
Launch has the only argument which should be a callable (lambda usually) that is run in parallel (or cooperatively in parallel), and return anything as the result. Launch has the only argument which should be a callable (lambda usually) that is run in parallel (or cooperatively in parallel), and return anything as the result.
If you no longer need the result, cancel the deferred. Awaiting a cancelled deferred throws `CancellationException`:
var reached = false
val work = launch {
delay(100)
reached = true
"ok"
}
work.cancel()
assertThrows(CancellationException) { work.await() }
assert(work.isCancelled)
assert(!work.isActive)
assert(!reached)
>>> void
## Synchronization: Mutex ## Synchronization: Mutex
Suppose we have a resource, that could be used concurrently, a counter in our case. If we won't protect it, concurrent usage cause RC, Race Condition, providing wrong result: Suppose we have a resource, that could be used concurrently, a counter in our case. If we won't protect it, concurrent usage cause RC, Race Condition, providing wrong result:
+4 -3
View File
@@ -114,10 +114,12 @@ When running end‑to‑end “book” workloads or heavier benches, you can ena
Flags are mutable at runtime, e.g.: Flags are mutable at runtime, e.g.:
```kotlin ```kotlin
runTest {
PerfFlags.ARG_BUILDER = false PerfFlags.ARG_BUILDER = false
val r1 = (Scope().eval(script) as ObjInt).value val r1 = (EvalSession(Scope()).eval(script) as ObjInt).value
PerfFlags.ARG_BUILDER = true PerfFlags.ARG_BUILDER = true
val r2 = (Scope().eval(script) as ObjInt).value val r2 = (EvalSession(Scope()).eval(script) as ObjInt).value
}
``` ```
Reset flags at the end of a test to avoid impacting other tests. Reset flags at the end of a test to avoid impacting other tests.
@@ -619,4 +621,3 @@ Reproduce
Notes Notes
- Negative caches are installed only after a real miss throws (cache‑after‑miss), preserving error semantics and invalidation on `layoutVersion` changes. - Negative caches are installed only after a real miss throws (cache‑after‑miss), preserving error semantics and invalidation on `layoutVersion` changes.
- IndexRef PIC augments the existing direct path and uses move‑to‑front promotion; it is keyed on `(classId, layoutVersion)` like other PICs. - IndexRef PIC augments the existing direct path and uses move‑to‑front promotion; it is keyed on `(classId, layoutVersion)` like other PICs.
+28
View File
@@ -375,6 +375,18 @@ It is rather simple, like everywhere else:
See [math](math.md) for more on it. Notice using Greek as identifier, all languages are allowed. See [math](math.md) for more on it. Notice using Greek as identifier, all languages are allowed.
For linear algebra, import `lyng.matrix`:
import lyng.matrix
val a: Matrix = matrix([[1, 2], [3, 4]])
val i: Matrix = Matrix.identity(2)
val sum: Matrix = a + i
assertEquals([[2.0, 2.0], [3.0, 5.0]], sum.toList())
>>> void
See [Matrix](Matrix.md) for vectors, matrix multiplication, inversion, and slicing such as `m[0..2, 1]`.
Logical operation could be used the same Logical operation could be used the same
var x = 10 var x = 10
@@ -811,6 +823,14 @@ Lists can contain any type of objects, lists too:
Notice usage of indexing. You can use negative indexes to offset from the end of the list; see more in [Lists](List.md). Notice usage of indexing. You can use negative indexes to offset from the end of the list; see more in [Lists](List.md).
In general, bracket indexing may contain more than one selector:
value[i]
value[i, j]
For built-in lists, strings, maps, and buffers, the selector is usually a single value such as an `Int`, `Range`, or `Regex`.
For types with custom indexers, multiple selectors are packed into one list-like index object and passed to `getAt` / `putAt`.
When you want to "flatten" it to single array, you can use splat syntax: When you want to "flatten" it to single array, you can use splat syntax:
[1, ...[2,3], 4] [1, ...[2,3], 4]
@@ -1699,6 +1719,14 @@ Open-ended ranges could be used to get start and end too:
assertEquals( "pult", "catapult"[ 4.. ]) assertEquals( "pult", "catapult"[ 4.. ])
>>> void >>> void
The same bracket syntax is also used by imported numeric modules such as `lyng.matrix`, where indexing can be multi-axis:
import lyng.matrix
val m: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
assertEquals(6.0, m[1, 2])
>>> void
### String operations ### String operations
Concatenation is a `+`: `"hello " + name` works as expected. No confusion. There is also Concatenation is a `+`: `"hello " + name` works as expected. No confusion. There is also
+48 -1
View File
@@ -5,12 +5,59 @@ For a programmer-focused migration summary, see `docs/whats_new_1_5.md`.
## Language Features ## Language Features
### Matrix and Vector Module (`lyng.matrix`)
Lyng now ships a dense linear algebra module with immutable double-precision `Matrix` and `Vector` types.
It provides:
- `matrix([[...]])` and `vector([...])`
- matrix multiplication
- matrix inversion
- determinant, trace, rank
- solving `A * x = b`
- vector operations such as `dot`, `normalize`, `cross`, and `outer`
```lyng
import lyng.matrix
val a: Matrix = matrix([[4, 7], [2, 6]])
val inv: Matrix = a.inverse()
assert(abs(inv.get(0, 0) - 0.6) < 1e-9)
```
Matrices also support Lyng-style slicing:
```lyng
import lyng.matrix
val m: Matrix = matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
assertEquals(6.0, m[1, 2])
val column: Matrix = m[0..2, 2]
val tail: Matrix = m[1.., 1..]
assertEquals([[3.0], [6.0], [9.0]], column.toList())
assertEquals([[5.0, 6.0], [8.0, 9.0]], tail.toList())
```
See [Matrix](Matrix.md).
### Multiple Selectors in Bracket Indexing
Bracket indexing now accepts more than one selector:
```lyng
value[i]
value[i, j]
value[i, j, k]
```
For custom indexers, multiple selectors are packed into one list-like index object and dispatched through `getAt` / `putAt`.
This is the rule used by `lyng.matrix` and by embedding APIs for Kotlin-backed indexers.
### Decimal Arithmetic Module (`lyng.decimal`) ### Decimal Arithmetic Module (`lyng.decimal`)
Lyng now ships a first-class decimal module built as a regular extension library rather than a deep core special case. Lyng now ships a first-class decimal module built as a regular extension library rather than a deep core special case.
It provides: It provides:
- `BigDecimal` - `Decimal`
- convenient `.d` conversions from `Int`, `Real`, and `String` - convenient `.d` conversions from `Int`, `Real`, and `String`
- mixed arithmetic with `Int` and `Real` - mixed arithmetic with `Int` and `Real`
- local division precision and rounding control via `withDecimalContext(...)` - local division precision and rounding control via `withDecimalContext(...)`
+76
View File
@@ -0,0 +1,76 @@
fun calculateDepth(
T: Real,
m: Real,
d: Real,
rho: Real = 1.2,
c: Real = 340.0,
g: Real = 9.81,
Cd: Real = 0.5,
eps: Real = 1e-3,
maxIter: Int = 100
): Real? {
// Площадь миделя
val r = d / 2.0
val A = π * r * r
// Коэффициент сопротивления
val k = 0.5 * Cd * rho * A
// Предельная скорость
val vTerm = sqrt(m * g / k)
// Функция времени падения с высоты h
fun tFall(h: Real): Real {
// Для численной стабильности при больших h используем логарифмическую форму
val arg = exp(g * h / (vTerm * vTerm))
// arcosh(x) = ln(x + sqrt(x^2 - 1))
val arcosh = ln(arg + sqrt(arg * arg - 1.0))
return vTerm / g * arcosh
}
// Полное расчётное время
fun Tcalc(h: Real): Real = tFall(h) + h / c
// Находим интервал, содержащий корень
// Нижняя граница: глубина не может быть отрицательной
var lo = 0.0
// Верхняя граница: сначала попробуем оценку по свободному падению (без звука)
var hi = 0.5 * g * T * T // максимальная глубина, если бы не было сопротивления и звука
// Уточним hi, чтобы Tcalc(hi) было заведомо больше T
while (Tcalc(hi) < T && hi < 1e4) {
hi *= 2.0
}
// Проверка, что hi достаточно велико
if (Tcalc(hi) < T) return null // слишком большая глубина, не укладываемся в разумное
// Бисекция
var iter = 0
var h = (lo + hi) / 2.0
while (iter < maxIter && (hi - lo) > eps) {
val f = Tcalc(h) - T
if (abs(f) < eps) break
if (f > 0) {
hi = h
} else {
lo = h
}
h = (lo + hi) / 2.0
iter++
}
return h
}
// Пример: T=12 секунд
val T = 26.0
val m = 1.0 // кг
val d = 0.1 // м
val depth = calculateDepth(T, m, d)
if (depth != null) {
println("Глубина: %.2f м"(depth))
// Для проверки выведем теоретическое время при найденной глубине
// (можно добавить функцию для самопроверки)
} else {
println("Расчёт не сошёлся")
}
+1 -4
View File
@@ -27,9 +27,6 @@ kotlin.mpp.enableCInteropCommonization=true
android.useAndroidX=true android.useAndroidX=true
android.nonTransitiveRClass=true android.nonTransitiveRClass=true
# other
kotlin.native.cacheKind.linuxX64=none
# Workaround: Ensure Gradle uses a JDK with `jlink` available for AGP's JDK image transform. # Workaround: Ensure Gradle uses a JDK with `jlink` available for AGP's JDK image transform.
# On this environment, the system JDK 21 installation lacks `jlink`, causing # On this environment, the system JDK 21 installation lacks `jlink`, causing
# :lynglib:androidJdkImage to fail. Point Gradle to a JDK that includes `jlink`. # :lynglib:androidJdkImage to fail. Point Gradle to a JDK that includes `jlink`.
@@ -37,6 +34,6 @@ kotlin.native.cacheKind.linuxX64=none
#org.gradle.java.home=/home/sergeych/.jdks/corretto-21.0.9 #org.gradle.java.home=/home/sergeych/.jdks/corretto-21.0.9
android.experimental.lint.migrateToK2=false android.experimental.lint.migrateToK2=false
android.lint.useK2Uast=false android.lint.useK2Uast=false
kotlin.mpp.applyDefaultHierarchyTemplate=true kotlin.mpp.applyDefaultHierarchyTemplate=false
org.gradle.parallel=true org.gradle.parallel=true
+3 -1
View File
@@ -2,13 +2,14 @@
agp = "8.5.2" agp = "8.5.2"
clikt = "5.0.3" clikt = "5.0.3"
mordant = "3.0.2" mordant = "3.0.2"
kotlin = "2.3.0" kotlin = "2.3.20"
android-minSdk = "24" android-minSdk = "24"
android-compileSdk = "34" android-compileSdk = "34"
kotlinx-coroutines = "1.10.2" kotlinx-coroutines = "1.10.2"
kotlinx-datetime = "0.6.1" kotlinx-datetime = "0.6.1"
mp_bintools = "0.3.2" mp_bintools = "0.3.2"
ionspin-bignum = "0.3.10" ionspin-bignum = "0.3.10"
multik = "0.3.0"
firebaseCrashlyticsBuildtools = "3.0.3" firebaseCrashlyticsBuildtools = "3.0.3"
okioVersion = "3.10.2" okioVersion = "3.10.2"
compiler = "3.2.0-alpha11" compiler = "3.2.0-alpha11"
@@ -24,6 +25,7 @@ kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-c
kotlinx-datetime = { module = "org.jetbrains.kotlinx:kotlinx-datetime", version.ref = "kotlinx-datetime" } kotlinx-datetime = { module = "org.jetbrains.kotlinx:kotlinx-datetime", version.ref = "kotlinx-datetime" }
mp_bintools = { module = "net.sergeych:mp_bintools", version.ref = "mp_bintools" } mp_bintools = { module = "net.sergeych:mp_bintools", version.ref = "mp_bintools" }
ionspin-bignum = { module = "com.ionspin.kotlin:bignum", version.ref = "ionspin-bignum" } ionspin-bignum = { module = "com.ionspin.kotlin:bignum", version.ref = "ionspin-bignum" }
multik-default = { module = "org.jetbrains.kotlinx:multik-default", version.ref = "multik" }
firebase-crashlytics-buildtools = { group = "com.google.firebase", name = "firebase-crashlytics-buildtools", version.ref = "firebaseCrashlyticsBuildtools" } firebase-crashlytics-buildtools = { group = "com.google.firebase", name = "firebase-crashlytics-buildtools", version.ref = "firebaseCrashlyticsBuildtools" }
okio = { module = "com.squareup.okio:okio", version.ref = "okioVersion" } okio = { module = "com.squareup.okio:okio", version.ref = "okioVersion" }
okio-fakefilesystem = { module = "com.squareup.okio:okio-fakefilesystem", version.ref = "okioVersion" } okio-fakefilesystem = { module = "com.squareup.okio:okio-fakefilesystem", version.ref = "okioVersion" }
@@ -23,6 +23,8 @@ import com.intellij.execution.ui.ConsoleViewContentType
import com.intellij.openapi.actionSystem.AnAction import com.intellij.openapi.actionSystem.AnAction
import com.intellij.openapi.actionSystem.AnActionEvent import com.intellij.openapi.actionSystem.AnActionEvent
import com.intellij.openapi.actionSystem.CommonDataKeys import com.intellij.openapi.actionSystem.CommonDataKeys
import com.intellij.openapi.application.ApplicationManager
import com.intellij.openapi.fileEditor.FileDocumentManager
import com.intellij.openapi.project.Project import com.intellij.openapi.project.Project
import com.intellij.openapi.wm.ToolWindow import com.intellij.openapi.wm.ToolWindow
import com.intellij.openapi.wm.ToolWindowAnchor import com.intellij.openapi.wm.ToolWindowAnchor
@@ -36,9 +38,10 @@ import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.SupervisorJob import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.launch import kotlinx.coroutines.launch
import net.sergeych.lyng.idea.LyngIcons import net.sergeych.lyng.idea.LyngIcons
import java.io.File
class RunLyngScriptAction : AnAction(LyngIcons.FILE) { class RunLyngScriptAction : AnAction(LyngIcons.FILE) {
private val scope = CoroutineScope(Dispatchers.Default + SupervisorJob()) private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
private fun getPsiFile(e: AnActionEvent): PsiFile? { private fun getPsiFile(e: AnActionEvent): PsiFile? {
val project = e.project ?: return null val project = e.project ?: return null
@@ -48,36 +51,99 @@ class RunLyngScriptAction : AnAction(LyngIcons.FILE) {
} }
} }
private fun getRunnableFile(e: AnActionEvent): PsiFile? {
val psiFile = getPsiFile(e) ?: return null
val virtualFile = psiFile.virtualFile ?: return null
if (!virtualFile.isInLocalFileSystem) return null
if (!psiFile.name.endsWith(".lyng")) return null
return psiFile
}
override fun update(e: AnActionEvent) { override fun update(e: AnActionEvent) {
val psiFile = getPsiFile(e) val psiFile = getRunnableFile(e)
val isLyng = psiFile?.name?.endsWith(".lyng") == true val isRunnable = psiFile != null
e.presentation.isEnabledAndVisible = isLyng e.presentation.isEnabledAndVisible = isRunnable
if (isLyng) { if (isRunnable) {
e.presentation.isEnabled = false e.presentation.text = "Run '${psiFile.name}'"
e.presentation.text = "Run '${psiFile.name}' (disabled)" e.presentation.description = "Run the current Lyng script using the Lyng CLI"
e.presentation.description = "Running scripts from the IDE is disabled; use the CLI."
} else { } else {
e.presentation.text = "Run Lyng Script" e.presentation.text = "Run Lyng Script"
e.presentation.description = "Run the current Lyng script"
} }
} }
override fun actionPerformed(e: AnActionEvent) { override fun actionPerformed(e: AnActionEvent) {
val project = e.project ?: return val project = e.project ?: return
val psiFile = getPsiFile(e) ?: return val psiFile = getRunnableFile(e) ?: return
val fileName = psiFile.name val virtualFile = psiFile.virtualFile ?: return
FileDocumentManager.getInstance().getDocument(virtualFile)?.let { document ->
FileDocumentManager.getInstance().saveDocument(document)
}
val filePath = virtualFile.path
val workingDir = virtualFile.parent?.path ?: project.basePath ?: File(filePath).parent
val (console, toolWindow) = getConsoleAndToolWindow(project) val (console, toolWindow) = getConsoleAndToolWindow(project)
console.clear() console.clear()
toolWindow.show { toolWindow.show {
scope.launch { scope.launch {
console.print("--- Run is disabled ---\n", ConsoleViewContentType.SYSTEM_OUTPUT) val command = startLyngProcess(filePath, workingDir)
console.print("Lyng now runs in bytecode-only mode; the IDE no longer evaluates scripts.\n", ConsoleViewContentType.NORMAL_OUTPUT) if (command == null) {
console.print("Use the CLI to run scripts, e.g. `lyng run $fileName`.\n", ConsoleViewContentType.NORMAL_OUTPUT) printToConsole(console, "Unable to start Lyng CLI.\n", ConsoleViewContentType.ERROR_OUTPUT)
printToConsole(console, "Tried commands: lyng, jlyng.\n", ConsoleViewContentType.ERROR_OUTPUT)
printToConsole(console, "Install `lyng` or `jlyng` and make sure it is available on PATH.\n", ConsoleViewContentType.NORMAL_OUTPUT)
return@launch
}
printToConsole(
console,
"Running ${command.commandLine} in ${command.workingDir}\n",
ConsoleViewContentType.SYSTEM_OUTPUT
)
streamProcess(command.process, console)
val exitCode = command.process.waitFor()
val outputType = if (exitCode == 0) ConsoleViewContentType.SYSTEM_OUTPUT else ConsoleViewContentType.ERROR_OUTPUT
printToConsole(console, "\nProcess finished with exit code $exitCode\n", outputType)
} }
} }
} }
private suspend fun streamProcess(process: Process, console: ConsoleView) {
val stdout = scope.launch {
process.inputStream.bufferedReader().useLines { lines ->
lines.forEach { printToConsole(console, "$it\n", ConsoleViewContentType.NORMAL_OUTPUT) }
}
}
val stderr = scope.launch {
process.errorStream.bufferedReader().useLines { lines ->
lines.forEach { printToConsole(console, "$it\n", ConsoleViewContentType.ERROR_OUTPUT) }
}
}
stdout.join()
stderr.join()
}
private fun printToConsole(console: ConsoleView, text: String, type: ConsoleViewContentType) {
ApplicationManager.getApplication().invokeLater {
console.print(text, type)
}
}
private fun startLyngProcess(filePath: String, workingDir: String?): StartedProcess? {
val candidates = listOf("lyng", "jlyng")
for (candidate in candidates) {
try {
val process = ProcessBuilder(candidate, filePath)
.directory(workingDir?.let(::File))
.start()
return StartedProcess(process, "$candidate $filePath", workingDir ?: File(filePath).parent.orEmpty())
} catch (_: java.io.IOException) {
// Try the next candidate when the command is not available.
}
}
return null
}
private fun getConsoleAndToolWindow(project: Project): Pair<ConsoleView, ToolWindow> { private fun getConsoleAndToolWindow(project: Project): Pair<ConsoleView, ToolWindow> {
val toolWindowManager = ToolWindowManager.getInstance(project) val toolWindowManager = ToolWindowManager.getInstance(project)
var toolWindow = toolWindowManager.getToolWindow(ToolWindowId.RUN) var toolWindow = toolWindowManager.getToolWindow(ToolWindowId.RUN)
@@ -106,4 +172,10 @@ class RunLyngScriptAction : AnAction(LyngIcons.FILE) {
contentManager.setSelectedContent(content) contentManager.setSelectedContent(content)
return console to actualToolWindow return console to actualToolWindow
} }
private data class StartedProcess(
val process: Process,
val commandLine: String,
val workingDir: String
)
} }
+8 -8
View File
@@ -1,5 +1,5 @@
/* /*
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com * Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -34,11 +34,13 @@ kotlin {
// Suppress Beta warning for expect/actual classes across all targets in this module // Suppress Beta warning for expect/actual classes across all targets in this module
targets.configureEach { targets.configureEach {
compilations.configureEach { compilations.configureEach {
compilerOptions.configure { compileTaskProvider.configure {
compilerOptions {
freeCompilerArgs.add("-Xexpect-actual-classes") freeCompilerArgs.add("-Xexpect-actual-classes")
} }
} }
} }
}
jvm { jvm {
binaries { binaries {
@@ -75,19 +77,17 @@ kotlin {
implementation(libs.okio.fakefilesystem) implementation(libs.okio.fakefilesystem)
} }
} }
val nativeMain by creating {
dependsOn(commonMain)
}
val jvmTest by getting { val jvmTest by getting {
dependencies { dependencies {
implementation(kotlin("test")) implementation(kotlin("test"))
implementation(kotlin("test-junit")) implementation(kotlin("test-junit"))
} }
} }
// val nativeMain by getting {
// dependencies {
// implementation(kotlin("stdlib-common"))
// }
// }
val linuxX64Main by getting { val linuxX64Main by getting {
dependsOn(nativeMain)
} }
} }
} }
+1
View File
@@ -158,6 +158,7 @@ private class Fmt : CliktCommand(name = "fmt") {
private class Lyng(val launcher: (suspend () -> Unit) -> Unit) : CliktCommand() { private class Lyng(val launcher: (suspend () -> Unit) -> Unit) : CliktCommand() {
override val invokeWithoutSubcommand = true
override val printHelpOnEmptyArgs = true override val printHelpOnEmptyArgs = true
val version by option("-v", "--version", help = "Print version and exit").flag() val version by option("-v", "--version", help = "Print version and exit").flag()
@@ -1,5 +1,5 @@
/* /*
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com * Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -131,4 +131,18 @@ class CliFmtJvmTest {
Files.deleteIfExists(tmp) Files.deleteIfExists(tmp)
} }
} }
@Test
fun inlineExecuteWithDashXStillWorksAndPassesArgv() {
val r = runCli(
"-x",
"""println("INLINE"); println(ARGV[0]); println(ARGV[1])""",
"one",
"two"
)
assertTrue("Expected inline execution output", r.out.contains("INLINE"))
assertTrue("Expected ARGV to include first trailing arg", r.out.contains("one"))
assertTrue("Expected ARGV to include second trailing arg", r.out.contains("two"))
assertTrue("Did not expect CLI exit()", r.exitCode == null)
}
} }
+25 -2
View File
@@ -44,7 +44,6 @@ kotlin {
iosX64() iosX64()
iosArm64() iosArm64()
iosSimulatorArm64() iosSimulatorArm64()
macosX64()
macosArm64() macosArm64()
mingwX64() mingwX64()
linuxX64() linuxX64()
@@ -62,11 +61,13 @@ kotlin {
// Keep expect/actual warning suppressed consistently with other modules // Keep expect/actual warning suppressed consistently with other modules
targets.configureEach { targets.configureEach {
compilations.configureEach { compilations.configureEach {
compilerOptions.configure { compileTaskProvider.configure {
compilerOptions {
freeCompilerArgs.add("-Xexpect-actual-classes") freeCompilerArgs.add("-Xexpect-actual-classes")
} }
} }
} }
}
sourceSets { sourceSets {
all { all {
@@ -81,11 +82,33 @@ kotlin {
api(libs.mordant.core) api(libs.mordant.core)
} }
} }
val nativeMain by creating {
dependsOn(commonMain)
}
val iosMain by creating {
dependsOn(nativeMain)
}
val linuxMain by creating {
dependsOn(nativeMain)
}
val macosMain by creating {
dependsOn(nativeMain)
}
val mingwMain by creating {
dependsOn(nativeMain)
}
val commonTest by getting { val commonTest by getting {
dependencies { dependencies {
implementation(libs.kotlin.test) implementation(libs.kotlin.test)
} }
} }
val iosX64Main by getting { dependsOn(iosMain) }
val iosArm64Main by getting { dependsOn(iosMain) }
val iosSimulatorArm64Main by getting { dependsOn(iosMain) }
val macosArm64Main by getting { dependsOn(macosMain) }
val mingwX64Main by getting { dependsOn(mingwMain) }
val linuxX64Main by getting { dependsOn(linuxMain) }
val linuxArm64Main by getting { dependsOn(linuxMain) }
// JS: use runtime detection in jsMain to select Node vs Browser implementation // JS: use runtime detection in jsMain to select Node vs Browser implementation
val jsMain by getting { val jsMain by getting {
+70 -17
View File
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
import org.jetbrains.kotlin.gradle.dsl.JvmTarget import org.jetbrains.kotlin.gradle.dsl.JvmTarget
group = "net.sergeych" group = "net.sergeych"
version = "1.5.1" version = "1.5.3"
// Removed legacy buildscript classpath declarations; plugins are applied via the plugins DSL below // Removed legacy buildscript classpath declarations; plugins are applied via the plugins DSL below
@@ -29,7 +29,7 @@ plugins {
alias(libs.plugins.kotlinMultiplatform) alias(libs.plugins.kotlinMultiplatform)
alias(libs.plugins.androidLibrary) alias(libs.plugins.androidLibrary)
// alias(libs.plugins.vanniktech.mavenPublish) // alias(libs.plugins.vanniktech.mavenPublish)
kotlin("plugin.serialization") version "2.2.21" kotlin("plugin.serialization") version "2.3.20"
id("com.codingfeline.buildkonfig") version "0.17.1" id("com.codingfeline.buildkonfig") version "0.17.1"
`maven-publish` `maven-publish`
} }
@@ -58,7 +58,6 @@ kotlin {
iosX64() iosX64()
iosArm64() iosArm64()
iosSimulatorArm64() iosSimulatorArm64()
macosX64()
macosArm64() macosArm64()
mingwX64() mingwX64()
linuxX64() linuxX64()
@@ -76,11 +75,13 @@ kotlin {
// Suppress Beta warning for expect/actual classes across all targets // Suppress Beta warning for expect/actual classes across all targets
targets.configureEach { targets.configureEach {
compilations.configureEach { compilations.configureEach {
compilerOptions.configure { compileTaskProvider.configure {
compilerOptions {
freeCompilerArgs.add("-Xexpect-actual-classes") freeCompilerArgs.add("-Xexpect-actual-classes")
} }
} }
} }
}
sourceSets { sourceSets {
all { all {
@@ -94,7 +95,7 @@ kotlin {
} }
val commonMain by getting { val commonMain by getting {
kotlin.srcDir("$buildDir/generated/buildConfig/commonMain/kotlin") kotlin.srcDir(layout.buildDirectory.dir("generated/buildConfig/commonMain/kotlin"))
dependencies { dependencies {
implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.9.0") implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.9.0")
implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.6.1") implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.6.1")
@@ -110,6 +111,51 @@ kotlin {
implementation(libs.kotlinx.coroutines.test) implementation(libs.kotlinx.coroutines.test)
} }
} }
val matrixMultikMain by creating {
dependsOn(commonMain)
dependencies {
implementation(libs.multik.default)
}
}
val nativeMain by creating {
dependsOn(commonMain)
}
val matrixPureMain by creating {
dependsOn(commonMain)
}
val jvmMain by getting { dependsOn(matrixMultikMain) }
val androidMain by getting { dependsOn(matrixPureMain) }
val jsMain by getting { dependsOn(matrixMultikMain) }
val wasmJsMain by getting { dependsOn(matrixMultikMain) }
// Multik 0.3.0 does not publish ios native artifacts, so keep iOS on the pure backend.
val iosX64Main by getting {
dependsOn(nativeMain)
dependsOn(matrixPureMain)
}
val iosArm64Main by getting {
dependsOn(nativeMain)
dependsOn(matrixPureMain)
}
val iosSimulatorArm64Main by getting {
dependsOn(nativeMain)
dependsOn(matrixPureMain)
}
val macosArm64Main by getting {
dependsOn(nativeMain)
dependsOn(matrixPureMain)
}
val mingwX64Main by getting {
dependsOn(nativeMain)
dependsOn(matrixPureMain)
}
val linuxX64Main by getting {
dependsOn(nativeMain)
dependsOn(matrixPureMain)
}
val linuxArm64Main by getting {
dependsOn(nativeMain)
dependsOn(matrixPureMain)
}
val jvmTest by getting { val jvmTest by getting {
dependencies { dependencies {
// Allow tests to load external docs like lyng.io.fs via registrar // Allow tests to load external docs like lyng.io.fs via registrar
@@ -149,6 +195,9 @@ abstract class GenerateLyngStdlib : DefaultTask() {
val outBase = outputDir.get().asFile val outBase = outputDir.get().asFile
val targetDir = outBase.resolve(pkgPath) val targetDir = outBase.resolve(pkgPath)
targetDir.mkdirs() targetDir.mkdirs()
targetDir.listFiles()
?.filter { it.isFile && it.name.endsWith(".generated.kt") }
?.forEach { it.delete() }
val srcDir = sourceDir.get().asFile val srcDir = sourceDir.get().asFile
val files = srcDir.walkTopDown() val files = srcDir.walkTopDown()
@@ -156,34 +205,38 @@ abstract class GenerateLyngStdlib : DefaultTask() {
.sortedBy { it.name } .sortedBy { it.name }
.toList() .toList()
val content = if (files.isEmpty()) "" else buildString {
files.forEachIndexed { idx, f ->
val text = f.readText()
if (idx > 0) append("\n\n")
append(text)
}
}
fun escapeForQuoted(s: String): String = buildString { fun escapeForQuoted(s: String): String = buildString {
for (ch in s) when (ch) { for (ch in s) when (ch) {
'\\' -> append("\\\\") '\\' -> append("\\\\")
'"' -> append("\\\"") '"' -> append("\\\"")
'$' -> append("\\$")
'\n' -> append("\\n") '\n' -> append("\\n")
'\r' -> {} '\r' -> {}
'\t' -> append("\\t") '\t' -> append("\\t")
else -> append(ch) else -> append(ch)
} }
} }
val body = escapeForQuoted(content)
fun constantName(baseName: String): String {
val parts = baseName.split(Regex("[^A-Za-z0-9]+")).filter { it.isNotEmpty() }
if (parts.isEmpty()) return "moduleLyng"
val head = parts.first().replaceFirstChar { it.lowercase() }
val tail = parts.drop(1).joinToString("") { part ->
part.replaceFirstChar { it.uppercase() }
}
return "${head}${tail}Lyng"
}
for (file in files) {
val body = escapeForQuoted(file.readText())
val sb = StringBuilder() val sb = StringBuilder()
sb.append("package ").append(targetPkg).append("\n\n") sb.append("package ").append(targetPkg).append("\n\n")
sb.append("@Suppress(\"Unused\", \"MemberVisibilityCanBePrivate\")\n") sb.append("@Suppress(\"Unused\", \"MemberVisibilityCanBePrivate\")\n")
sb.append("internal val rootLyng = \"") sb.append("internal val ").append(constantName(file.nameWithoutExtension)).append(" = \"")
sb.append(body) sb.append(body)
sb.append("\"\n") sb.append("\"\n")
targetDir.resolve("${file.nameWithoutExtension}_lyng.generated.kt").writeText(sb.toString())
targetDir.resolve("root_lyng.generated.kt").writeText(sb.toString()) }
} }
} }
@@ -172,6 +172,7 @@ class Compiler(
private val callReturnTypeDeclByRef: MutableMap<CallRef, TypeDecl> = mutableMapOf() private val callReturnTypeDeclByRef: MutableMap<CallRef, TypeDecl> = mutableMapOf()
private val callableReturnTypeByScopeId: MutableMap<Int, MutableMap<Int, ObjClass>> = mutableMapOf() private val callableReturnTypeByScopeId: MutableMap<Int, MutableMap<Int, ObjClass>> = mutableMapOf()
private val callableReturnTypeByName: MutableMap<String, ObjClass> = mutableMapOf() private val callableReturnTypeByName: MutableMap<String, ObjClass> = mutableMapOf()
private val callableReturnTypeDeclByName: MutableMap<String, TypeDecl> = mutableMapOf()
private val lambdaReturnTypeByRef: MutableMap<ObjRef, ObjClass> = mutableMapOf() private val lambdaReturnTypeByRef: MutableMap<ObjRef, ObjClass> = mutableMapOf()
private val lambdaCaptureEntriesByRef: MutableMap<ValueFnRef, List<net.sergeych.lyng.bytecode.LambdaCaptureEntry>> = private val lambdaCaptureEntriesByRef: MutableMap<ValueFnRef, List<net.sergeych.lyng.bytecode.LambdaCaptureEntry>> =
mutableMapOf() mutableMapOf()
@@ -186,6 +187,8 @@ class Compiler(
private val externCallableNames: MutableSet<String> = mutableSetOf() private val externCallableNames: MutableSet<String> = mutableSetOf()
private val externBindingNames: MutableSet<String> = mutableSetOf() private val externBindingNames: MutableSet<String> = mutableSetOf()
private val moduleDeclaredNames: MutableSet<String> = mutableSetOf() private val moduleDeclaredNames: MutableSet<String> = mutableSetOf()
private val predeclaredTopLevelValueNames: MutableSet<String> = mutableSetOf()
private val moduleReferencePosByName: MutableMap<String, Pos> = mutableMapOf()
private var seedingSlotPlan: Boolean = false private var seedingSlotPlan: Boolean = false
private fun moduleForcedLocalSlotInfo(): Map<String, ForcedLocalSlotInfo> { private fun moduleForcedLocalSlotInfo(): Map<String, ForcedLocalSlotInfo> {
@@ -340,6 +343,73 @@ class Compiler(
} }
return t return t
} }
fun handleTopLevelKeyword(keyword: Token): Boolean {
when (keyword.value) {
"fun", "fn" -> {
val nameToken = nextNonWs()
if (nameToken.type != Token.Type.ID) return true
val afterName = cc.peekNextNonWhitespace()
if (afterName.type == Token.Type.DOT) {
cc.nextNonWhitespace()
val actual = cc.nextNonWhitespace()
if (actual.type == Token.Type.ID) {
extensionNames.add(actual.value)
registerExtensionName(nameToken.value, actual.value)
declareSlotNameIn(plan, extensionCallableName(nameToken.value, actual.value), isMutable = false, isDelegated = false)
moduleDeclaredNames.add(extensionCallableName(nameToken.value, actual.value))
}
return true
}
declareSlotNameIn(plan, nameToken.value, isMutable = false, isDelegated = false)
moduleDeclaredNames.add(nameToken.value)
return true
}
"val", "var" -> {
val nameToken = nextNonWs()
if (nameToken.type != Token.Type.ID) return true
val afterName = cc.peekNextNonWhitespace()
if (afterName.type == Token.Type.DOT) {
cc.nextNonWhitespace()
val actual = cc.nextNonWhitespace()
if (actual.type == Token.Type.ID) {
extensionNames.add(actual.value)
registerExtensionName(nameToken.value, actual.value)
declareSlotNameIn(plan, extensionPropertyGetterName(nameToken.value, actual.value), isMutable = false, isDelegated = false)
moduleDeclaredNames.add(extensionPropertyGetterName(nameToken.value, actual.value))
if (keyword.value == "var") {
declareSlotNameIn(plan, extensionPropertySetterName(nameToken.value, actual.value), isMutable = false, isDelegated = false)
moduleDeclaredNames.add(extensionPropertySetterName(nameToken.value, actual.value))
}
}
return true
}
declareSlotNameIn(plan, nameToken.value, isMutable = keyword.value == "var", isDelegated = false)
moduleDeclaredNames.add(nameToken.value)
predeclaredTopLevelValueNames.add(nameToken.value)
return true
}
"class", "object" -> {
val nameToken = nextNonWs()
if (nameToken.type == Token.Type.ID) {
declareSlotNameIn(plan, nameToken.value, isMutable = false, isDelegated = false)
scopeSeedNames.add(nameToken.value)
moduleDeclaredNames.add(nameToken.value)
}
return true
}
"enum" -> {
val next = nextNonWs()
val nameToken = if (next.type == Token.Type.ID && next.value == "class") nextNonWs() else next
if (nameToken.type == Token.Type.ID) {
declareSlotNameIn(plan, nameToken.value, isMutable = false, isDelegated = false)
scopeSeedNames.add(nameToken.value)
moduleDeclaredNames.add(nameToken.value)
}
return true
}
}
return false
}
try { try {
while (cc.hasNext()) { while (cc.hasNext()) {
val t = cc.next() val t = cc.next()
@@ -352,65 +422,11 @@ class Compiler(
Token.Type.RBRACKET -> if (bracketDepth > 0) bracketDepth-- Token.Type.RBRACKET -> if (bracketDepth > 0) bracketDepth--
Token.Type.ID -> if (depth == 0) { Token.Type.ID -> if (depth == 0) {
if (parenDepth > 0 || bracketDepth > 0) continue if (parenDepth > 0 || bracketDepth > 0) continue
when (t.value) { if (t.value == "extern") {
"fun", "fn" -> { handleTopLevelKeyword(nextNonWs())
val nameToken = nextNonWs()
if (nameToken.type != Token.Type.ID) continue
val afterName = cc.peekNextNonWhitespace()
if (afterName.type == Token.Type.DOT) {
cc.nextNonWhitespace()
val actual = cc.nextNonWhitespace()
if (actual.type == Token.Type.ID) {
extensionNames.add(actual.value)
registerExtensionName(nameToken.value, actual.value)
declareSlotNameIn(plan, extensionCallableName(nameToken.value, actual.value), isMutable = false, isDelegated = false)
moduleDeclaredNames.add(extensionCallableName(nameToken.value, actual.value))
}
continue continue
} }
declareSlotNameIn(plan, nameToken.value, isMutable = false, isDelegated = false) handleTopLevelKeyword(t)
moduleDeclaredNames.add(nameToken.value)
}
"val", "var" -> {
val nameToken = nextNonWs()
if (nameToken.type != Token.Type.ID) continue
val afterName = cc.peekNextNonWhitespace()
if (afterName.type == Token.Type.DOT) {
cc.nextNonWhitespace()
val actual = cc.nextNonWhitespace()
if (actual.type == Token.Type.ID) {
extensionNames.add(actual.value)
registerExtensionName(nameToken.value, actual.value)
declareSlotNameIn(plan, extensionPropertyGetterName(nameToken.value, actual.value), isMutable = false, isDelegated = false)
moduleDeclaredNames.add(extensionPropertyGetterName(nameToken.value, actual.value))
if (t.value == "var") {
declareSlotNameIn(plan, extensionPropertySetterName(nameToken.value, actual.value), isMutable = false, isDelegated = false)
moduleDeclaredNames.add(extensionPropertySetterName(nameToken.value, actual.value))
}
}
continue
}
declareSlotNameIn(plan, nameToken.value, isMutable = t.value == "var", isDelegated = false)
moduleDeclaredNames.add(nameToken.value)
}
"class", "object" -> {
val nameToken = nextNonWs()
if (nameToken.type == Token.Type.ID) {
declareSlotNameIn(plan, nameToken.value, isMutable = false, isDelegated = false)
scopeSeedNames.add(nameToken.value)
moduleDeclaredNames.add(nameToken.value)
}
}
"enum" -> {
val next = nextNonWs()
val nameToken = if (next.type == Token.Type.ID && next.value == "class") nextNonWs() else next
if (nameToken.type == Token.Type.ID) {
declareSlotNameIn(plan, nameToken.value, isMutable = false, isDelegated = false)
scopeSeedNames.add(nameToken.value)
moduleDeclaredNames.add(nameToken.value)
}
}
}
} }
else -> {} else -> {}
} }
@@ -420,6 +436,12 @@ class Compiler(
} }
} }
private fun rememberModuleReferencePos(name: String, pos: Pos) {
if (!moduleReferencePosByName.containsKey(name)) {
moduleReferencePosByName[name] = pos
}
}
private fun predeclareClassMembers(target: MutableSet<String>, overrides: MutableMap<String, Boolean>) { private fun predeclareClassMembers(target: MutableSet<String>, overrides: MutableMap<String, Boolean>) {
val saved = cc.savePos() val saved = cc.savePos()
var depth = 0 var depth = 0
@@ -932,6 +954,7 @@ class Compiler(
} }
} }
captureLocalRef(name, slotLoc, pos)?.let { ref -> captureLocalRef(name, slotLoc, pos)?.let { ref ->
rememberModuleReferencePos(name, pos)
resolutionSink?.reference(name, pos) resolutionSink?.reference(name, pos)
return ref return ref
} }
@@ -977,8 +1000,11 @@ class Compiler(
if (moduleLoc != null) { if (moduleLoc != null) {
val moduleDeclaredNames = localNamesStack.firstOrNull() val moduleDeclaredNames = localNamesStack.firstOrNull()
if (moduleDeclaredNames == null || !moduleDeclaredNames.contains(name)) { if (moduleDeclaredNames == null || !moduleDeclaredNames.contains(name)) {
resolveImportBinding(name, pos)?.let { resolved -> val resolvedImport = resolveImportBinding(name, pos)
registerImportBinding(name, resolved.binding, pos) if (resolvedImport != null) {
registerImportBinding(name, resolvedImport.binding, pos)
} else if (predeclaredTopLevelValueNames.contains(name)) {
throw ScriptError(pos, "symbol '$name' is not defined")
} }
} }
val ref = LocalSlotRef( val ref = LocalSlotRef(
@@ -1007,8 +1033,11 @@ class Compiler(
if (moduleEntry != null) { if (moduleEntry != null) {
val moduleDeclaredNames = localNamesStack.firstOrNull() val moduleDeclaredNames = localNamesStack.firstOrNull()
if (moduleDeclaredNames == null || !moduleDeclaredNames.contains(name)) { if (moduleDeclaredNames == null || !moduleDeclaredNames.contains(name)) {
resolveImportBinding(name, pos)?.let { resolved -> val resolvedImport = resolveImportBinding(name, pos)
registerImportBinding(name, resolved.binding, pos) if (resolvedImport != null) {
registerImportBinding(name, resolvedImport.binding, pos)
} else if (predeclaredTopLevelValueNames.contains(name)) {
throw ScriptError(pos, "symbol '$name' is not defined")
} }
} }
val moduleLoc = SlotLocation( val moduleLoc = SlotLocation(
@@ -1019,6 +1048,7 @@ class Compiler(
moduleEntry.isDelegated moduleEntry.isDelegated
) )
captureLocalRef(name, moduleLoc, pos)?.let { ref -> captureLocalRef(name, moduleLoc, pos)?.let { ref ->
rememberModuleReferencePos(name, pos)
resolutionSink?.reference(name, pos) resolutionSink?.reference(name, pos)
return ref return ref
} }
@@ -1045,6 +1075,7 @@ class Compiler(
strictSlotRefs strictSlotRefs
) )
} }
rememberModuleReferencePos(name, pos)
resolutionSink?.reference(name, pos) resolutionSink?.reference(name, pos)
return ref return ref
} }
@@ -1079,6 +1110,7 @@ class Compiler(
val slot = lookupSlotLocation(name) val slot = lookupSlotLocation(name)
if (slot != null) { if (slot != null) {
captureLocalRef(name, slot, pos)?.let { ref -> captureLocalRef(name, slot, pos)?.let { ref ->
rememberModuleReferencePos(name, pos)
resolutionSink?.reference(name, pos) resolutionSink?.reference(name, pos)
return ref return ref
} }
@@ -1105,6 +1137,7 @@ class Compiler(
strictSlotRefs strictSlotRefs
) )
} }
rememberModuleReferencePos(name, pos)
resolutionSink?.reference(name, pos) resolutionSink?.reference(name, pos)
return ref return ref
} }
@@ -1281,23 +1314,11 @@ class Compiler(
} }
} }
if (seedRecord != null) { if (seedRecord != null) {
val value = seedRecord.value seedImportTypeMetadata(name, seedRecord)
if (!nameObjClass.containsKey(name)) {
when (value) {
is ObjClass -> nameObjClass[name] = value
is ObjInstance -> nameObjClass[name] = value.objClass
}
}
return ImportBindingResolution(ImportBinding(name, ImportBindingSource.Seed), seedRecord) return ImportBindingResolution(ImportBinding(name, ImportBindingSource.Seed), seedRecord)
} }
if (rootRecord != null) { if (rootRecord != null) {
val value = rootRecord.value seedImportTypeMetadata(name, rootRecord)
if (!nameObjClass.containsKey(name)) {
when (value) {
is ObjClass -> nameObjClass[name] = value
is ObjInstance -> nameObjClass[name] = value.objClass
}
}
return ImportBindingResolution(ImportBinding(name, ImportBindingSource.Root), rootRecord) return ImportBindingResolution(ImportBinding(name, ImportBindingSource.Root), rootRecord)
} }
if (moduleMatches.isEmpty()) return null if (moduleMatches.isEmpty()) return null
@@ -1312,13 +1333,7 @@ class Compiler(
val candidates = byOrigin[origin] ?: mutableListOf() val candidates = byOrigin[origin] ?: mutableListOf()
val preferred = candidates.firstOrNull { it.first.scope.packageName == origin } ?: candidates.first() val preferred = candidates.firstOrNull { it.first.scope.packageName == origin } ?: candidates.first()
val binding = ImportBinding(name, ImportBindingSource.Module(origin, preferred.first.pos)) val binding = ImportBinding(name, ImportBindingSource.Module(origin, preferred.first.pos))
val value = preferred.second.value seedImportTypeMetadata(name, preferred.second)
if (!nameObjClass.containsKey(name)) {
when (value) {
is ObjClass -> nameObjClass[name] = value
is ObjInstance -> nameObjClass[name] = value.objClass
}
}
return ImportBindingResolution(binding, preferred.second) return ImportBindingResolution(binding, preferred.second)
} }
val moduleNames = moduleMatches.keys.toList() val moduleNames = moduleMatches.keys.toList()
@@ -1326,14 +1341,24 @@ class Compiler(
} }
val (module, record) = moduleMatches.values.first() val (module, record) = moduleMatches.values.first()
val binding = ImportBinding(name, ImportBindingSource.Module(module.scope.packageName, module.pos)) val binding = ImportBinding(name, ImportBindingSource.Module(module.scope.packageName, module.pos))
val value = record.value seedImportTypeMetadata(name, record)
return ImportBindingResolution(binding, record)
}
private fun seedImportTypeMetadata(name: String, record: ObjRecord) {
if (record.typeDecl != null && nameTypeDecl[name] == null) {
nameTypeDecl[name] = record.typeDecl
}
if (!nameObjClass.containsKey(name)) { if (!nameObjClass.containsKey(name)) {
when (value) { record.typeDecl?.let { resolveTypeDeclObjClass(it) }?.let {
nameObjClass[name] = it
return
}
when (val value = record.value) {
is ObjClass -> nameObjClass[name] = value is ObjClass -> nameObjClass[name] = value
is ObjInstance -> nameObjClass[name] = value.objClass is ObjInstance -> nameObjClass[name] = value.objClass
} }
} }
return ImportBindingResolution(binding, record)
} }
private fun collectModuleRecordMatches( private fun collectModuleRecordMatches(
@@ -1756,6 +1781,8 @@ class Compiler(
callableReturnTypeByScopeId = callableReturnTypeByScopeId, callableReturnTypeByScopeId = callableReturnTypeByScopeId,
callableReturnTypeByName = callableReturnTypeByName, callableReturnTypeByName = callableReturnTypeByName,
externBindingNames = externBindingNames, externBindingNames = externBindingNames,
preparedModuleBindingNames = importBindings.keys,
scopeRefPosByName = moduleReferencePosByName,
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
) as BytecodeStatement ) as BytecodeStatement
unwrapped to bytecodeStmt.bytecodeFunction() unwrapped to bytecodeStmt.bytecodeFunction()
@@ -2084,6 +2111,8 @@ class Compiler(
callableReturnTypeByName = callableReturnTypeByName, callableReturnTypeByName = callableReturnTypeByName,
externCallableNames = externCallableNames, externCallableNames = externCallableNames,
externBindingNames = externBindingNames, externBindingNames = externBindingNames,
preparedModuleBindingNames = importBindings.keys,
scopeRefPosByName = moduleReferencePosByName,
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
) )
} }
@@ -2115,6 +2144,8 @@ class Compiler(
callableReturnTypeByName = callableReturnTypeByName, callableReturnTypeByName = callableReturnTypeByName,
externCallableNames = externCallableNames, externCallableNames = externCallableNames,
externBindingNames = externBindingNames, externBindingNames = externBindingNames,
preparedModuleBindingNames = importBindings.keys,
scopeRefPosByName = moduleReferencePosByName,
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
) )
} }
@@ -2171,6 +2202,8 @@ class Compiler(
callableReturnTypeByName = callableReturnTypeByName, callableReturnTypeByName = callableReturnTypeByName,
externCallableNames = externCallableNames, externCallableNames = externCallableNames,
externBindingNames = externBindingNames, externBindingNames = externBindingNames,
preparedModuleBindingNames = importBindings.keys,
scopeRefPosByName = moduleReferencePosByName,
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
) )
} }
@@ -2915,9 +2948,9 @@ class Compiler(
operand?.let { left -> operand?.let { left ->
// array access via ObjRef // array access via ObjRef
val isOptional = t.type == Token.Type.NULL_COALESCE_INDEX val isOptional = t.type == Token.Type.NULL_COALESCE_INDEX
val index = parseStatement() ?: throw ScriptError(t.pos, "Expecting index expression") val index = parseIndexExpression() ?: throw ScriptError(t.pos, "Expecting index expression")
cc.skipTokenOfType(Token.Type.RBRACKET, "missing ']' at the end of the list literal") cc.skipTokenOfType(Token.Type.RBRACKET, "missing ']' at the end of the list literal")
operand = IndexRef(left, StatementRef(index), isOptional) operand = IndexRef(left, index, isOptional)
} ?: run { } ?: run {
// array literal // array literal
val entries = parseArrayLiteral() val entries = parseArrayLiteral()
@@ -3412,6 +3445,20 @@ class Compiler(
} }
} }
private suspend fun parseIndexExpression(): ObjRef? {
val first = parseExpressionLevel() ?: return null
if (!cc.skipTokenOfType(Token.Type.COMMA, isOptional = true)) {
return first
}
val entries = mutableListOf<ListEntry>(ListEntry.Element(first))
do {
val next = parseExpressionLevel() ?: throw ScriptError(cc.currentPos(), "Expecting index expression")
entries += ListEntry.Element(next)
} while (cc.skipTokenOfType(Token.Type.COMMA, isOptional = true))
return ListLiteralRef(entries)
}
private suspend fun parseDestructuringPattern(): List<ListEntry> { private suspend fun parseDestructuringPattern(): List<ListEntry> {
// it should be called after Token.Type.LBRACKET is consumed // it should be called after Token.Type.LBRACKET is consumed
val entries = mutableListOf<ListEntry>() val entries = mutableListOf<ListEntry>()
@@ -4299,14 +4346,22 @@ class Compiler(
is MapLiteralRef -> inferMapLiteralTypeDecl(ref) is MapLiteralRef -> inferMapLiteralTypeDecl(ref)
is ConstRef -> inferTypeDeclFromConst(ref.constValue) is ConstRef -> inferTypeDeclFromConst(ref.constValue)
is CallRef -> { is CallRef -> {
inferCallReturnClass(ref)?.let { TypeDecl.Simple(it.className, false) } val targetDecl = resolveReceiverTypeDecl(ref.target)
?: run {
val targetName = when (val target = ref.target) { val targetName = when (val target = ref.target) {
is LocalVarRef -> target.name is LocalVarRef -> target.name
is FastLocalVarRef -> target.name is FastLocalVarRef -> target.name
is LocalSlotRef -> target.name is LocalSlotRef -> target.name
else -> null else -> null
} }
if (targetDecl is TypeDecl.Function) {
return targetDecl.returnType
}
if (targetName != null) {
callableReturnTypeDeclByName[targetName]?.let { return it }
(seedTypeDeclByName(targetName) as? TypeDecl.Function)?.let { return it.returnType }
}
inferCallReturnClass(ref)?.let { TypeDecl.Simple(it.className, false) }
?: run {
if (targetName != null && targetName.firstOrNull()?.isUpperCase() == true) { if (targetName != null && targetName.firstOrNull()?.isUpperCase() == true) {
TypeDecl.Simple(targetName, false) TypeDecl.Simple(targetName, false)
} else { } else {
@@ -4637,6 +4692,17 @@ class Compiler(
return null return null
} }
private fun lookupLocalTypeDeclByName(name: String): TypeDecl? {
val slotLoc = lookupSlotLocation(name, includeModule = true) ?: return null
return slotTypeDeclByScopeId[slotLoc.scopeId]?.get(slotLoc.slot)
}
private fun lookupLocalObjClassByName(name: String): ObjClass? {
val slotLoc = lookupSlotLocation(name, includeModule = true) ?: return null
return slotTypeByScopeId[slotLoc.scopeId]?.get(slotLoc.slot)
?: slotTypeDeclByScopeId[slotLoc.scopeId]?.get(slotLoc.slot)?.let { resolveTypeDeclObjClass(it) }
}
private fun resolveReceiverTypeDecl(ref: ObjRef): TypeDecl? { private fun resolveReceiverTypeDecl(ref: ObjRef): TypeDecl? {
return when (ref) { return when (ref) {
is LocalSlotRef -> { is LocalSlotRef -> {
@@ -4646,8 +4712,12 @@ class Compiler(
?: nameTypeDecl[ref.name] ?: nameTypeDecl[ref.name]
?: seedTypeDeclByName(ref.name) ?: seedTypeDeclByName(ref.name)
} }
is LocalVarRef -> nameTypeDecl[ref.name] ?: seedTypeDeclByName(ref.name) is LocalVarRef -> nameTypeDecl[ref.name]
is FastLocalVarRef -> nameTypeDecl[ref.name] ?: seedTypeDeclByName(ref.name) ?: lookupLocalTypeDeclByName(ref.name)
?: seedTypeDeclByName(ref.name)
is FastLocalVarRef -> nameTypeDecl[ref.name]
?: lookupLocalTypeDeclByName(ref.name)
?: seedTypeDeclByName(ref.name)
is FieldRef -> { is FieldRef -> {
val targetDecl = resolveReceiverTypeDecl(ref.target) ?: return null val targetDecl = resolveReceiverTypeDecl(ref.target) ?: return null
val targetClass = resolveTypeDeclObjClass(targetDecl) ?: resolveReceiverClassForMember(ref.target) val targetClass = resolveTypeDeclObjClass(targetDecl) ?: resolveReceiverClassForMember(ref.target)
@@ -4693,11 +4763,13 @@ class Compiler(
is LocalVarRef -> nameObjClass[ref.name] is LocalVarRef -> nameObjClass[ref.name]
?.takeIf { it == ObjDynamic.type } ?.takeIf { it == ObjDynamic.type }
?: nameObjClass[ref.name] ?: nameObjClass[ref.name]
?: lookupLocalObjClassByName(ref.name)
?: nameTypeDecl[ref.name]?.let { resolveTypeDeclObjClass(it) } ?: nameTypeDecl[ref.name]?.let { resolveTypeDeclObjClass(it) }
?: resolveClassByName(ref.name) ?: resolveClassByName(ref.name)
is FastLocalVarRef -> nameObjClass[ref.name] is FastLocalVarRef -> nameObjClass[ref.name]
?.takeIf { it == ObjDynamic.type } ?.takeIf { it == ObjDynamic.type }
?: nameObjClass[ref.name] ?: nameObjClass[ref.name]
?: lookupLocalObjClassByName(ref.name)
?: nameTypeDecl[ref.name]?.let { resolveTypeDeclObjClass(it) } ?: nameTypeDecl[ref.name]?.let { resolveTypeDeclObjClass(it) }
?: resolveClassByName(ref.name) ?: resolveClassByName(ref.name)
is ClassScopeMemberRef -> { is ClassScopeMemberRef -> {
@@ -8143,6 +8215,10 @@ class Compiler(
inferredReturnClass inferredReturnClass
} }
} }
val inferredReturnDecl = returnTypeDecl ?: inferredReturnClass?.let { TypeDecl.Simple(it.className, false) }
if (declKind != SymbolKind.MEMBER && inferredReturnDecl != null) {
callableReturnTypeDeclByName[name] = inferredReturnDecl
}
val fnStatements = rawFnStatements?.let { stmt -> val fnStatements = rawFnStatements?.let { stmt ->
if (!compileBytecode) return@let stmt if (!compileBytecode) return@let stmt
val paramKnownClasses = mutableMapOf<String, ObjClass>() val paramKnownClasses = mutableMapOf<String, ObjClass>()
@@ -8253,7 +8329,7 @@ class Compiler(
?: context.parent?.get(localName) ?: context.parent?.get(localName)
?: context.get(localName) ?: context.get(localName)
?: continue ?: continue
val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property) { val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is ObjProperty) {
context.resolve(record, localName) context.resolve(record, localName)
} else { } else {
record.value record.value
@@ -9012,7 +9088,10 @@ class Compiler(
val effectiveEqToken = if (isProperty) null else eqToken val effectiveEqToken = if (isProperty) null else eqToken
// Register the local name at compile time so that subsequent identifiers can be emitted as fast locals // Register the local name at compile time so that subsequent identifiers can be emitted as fast locals
if (!isStatic && declaringClassNameCaptured == null && !actualExtern) declareLocalName(name, isMutable) val isTopLevelExtern = actualExtern && declaringClassNameCaptured == null && slotPlanStack.size == 1
if (!isStatic && declaringClassNameCaptured == null && (!actualExtern || isTopLevelExtern)) {
declareLocalName(name, isMutable)
}
val declKind = if (codeContexts.lastOrNull() is CodeContext.ClassBody) { val declKind = if (codeContexts.lastOrNull() is CodeContext.ClassBody) {
SymbolKind.MEMBER SymbolKind.MEMBER
} else { } else {
@@ -0,0 +1,129 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.filter
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import net.sergeych.lyng.obj.Obj
import kotlin.coroutines.AbstractCoroutineContextElement
import kotlin.coroutines.CoroutineContext
/**
* Host-managed lifetime owner for coroutines started from Lyng scripts.
*
* The session reuses a single [Scope] across eval calls and tracks async work launched by
* `launch { ... }` and active flow producers created from these evals.
*/
class EvalSession(initialScope: Scope? = null) {
private val ownerJob = SupervisorJob()
private val evalMutex = Mutex()
private val scopeMutex = Mutex()
private val activeJobs = MutableStateFlow(0)
private var _scope: Scope? = initialScope
val scope: Scope? get() = _scope
val isActive: Boolean get() = ownerJob.isActive
val isCancelled: Boolean get() = ownerJob.isCancelled
suspend fun getScope(): Scope = ensureScope()
suspend fun eval(code: String): Obj = eval(code.toSource())
suspend fun eval(source: Source): Obj = evalMutex.withLock {
throwIfCancelled()
val scope = ensureScope()
withEvalSession(this@EvalSession) {
scope.eval(source)
}
}
fun cancel(cause: String? = null) {
ownerJob.cancel(ScriptSessionCancelled(cause ?: "EvalSession cancelled"))
}
suspend fun join() {
activeJobs.filter { it == 0 }.first()
}
suspend fun cancelAndJoin() {
cancel()
join()
}
internal suspend fun <T> launchTrackedDeferred(block: suspend CoroutineScope.() -> T): Deferred<T> {
throwIfCancelled()
val deferred = CoroutineScope(currentTrackedCoroutineContext()).async(block = block)
track(deferred)
return deferred
}
internal suspend fun launchTrackedJob(block: suspend CoroutineScope.() -> Unit): Job {
throwIfCancelled()
val job = CoroutineScope(currentTrackedCoroutineContext()).launch(block = block)
track(job)
return job
}
private suspend fun currentTrackedCoroutineContext(): CoroutineContext {
val base = currentCoroutineContext()
return base.minusKey(Job) + ownerJob + EvalSessionElement(this)
}
private suspend fun ensureScope(): Scope {
_scope?.let { return it }
return scopeMutex.withLock {
_scope ?: Script.newScope().also { _scope = it }
}
}
private fun track(job: Job) {
activeJobs.update { it + 1 }
job.invokeOnCompletion {
activeJobs.update { count -> if (count > 0) count - 1 else 0 }
}
}
internal fun throwIfCancelled() {
if (ownerJob.isCancelled) {
throw ScriptSessionCancelled("EvalSession cancelled")
}
}
companion object {
suspend fun currentOrNull(): EvalSession? = currentCoroutineContext()[EvalSessionElement]?.session
}
}
internal class EvalSessionElement(val session: EvalSession) :
AbstractCoroutineContextElement(EvalSessionElement) {
companion object Key : CoroutineContext.Key<EvalSessionElement>
}
internal suspend fun <T> withEvalSession(session: EvalSession, block: suspend () -> T): T {
return kotlinx.coroutines.withContext(EvalSessionElement(session)) {
block()
}
}
class ScriptSessionCancelled(message: String) : CancellationException(message)
@@ -167,6 +167,19 @@ class RecordSlotRef(
} }
} }
suspend fun read(scope: Scope, name: String?): Obj {
val direct = record.value
if (name != null && (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || direct is ObjProperty)) {
return scope.resolve(record, name)
}
return when (direct) {
is FrameSlotRef -> direct.read()
is RecordSlotRef -> direct.read(scope, name)
is ScopeSlotRef -> direct.read()
else -> direct
}
}
override suspend fun callOn(scope: Scope): Obj { override suspend fun callOn(scope: Scope): Obj {
val resolved = read() val resolved = read()
if (resolved === this) { if (resolved === this) {
@@ -193,4 +206,18 @@ class RecordSlotRef(
record.value = value record.value = value
} }
} }
suspend fun write(scope: Scope, name: String?, value: Obj): Boolean {
val direct = record.value
if (name != null && (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || direct is ObjProperty)) {
scope.assign(record, name, value)
return true
}
when (direct) {
is ScopeSlotRef -> direct.write(value)
is RecordSlotRef -> if (direct.write(scope, name, value)) return true else direct.write(value)
else -> record.value = value
}
return false
}
} }
@@ -732,7 +732,8 @@ private class Parser(fromPos: Pos, private val interpolationEnabled: Boolean = t
} }
val expanded = mutableListOf<Token>() val expanded = mutableListOf<Token>()
expanded += Token("(", tokenPos, Token.Type.LPAREN) expanded += Token("(", tokenPos, Token.Type.LPAREN)
var emittedPieces = 0 expanded += Token("", tokenPos, Token.Type.STRING)
var emittedPieces = 1
for (chunk in chunks) { for (chunk in chunks) {
val pieceTokens = when (chunk) { val pieceTokens = when (chunk) {
is StringChunk.Literal -> { is StringChunk.Literal -> {
@@ -755,9 +756,6 @@ private class Parser(fromPos: Pos, private val interpolationEnabled: Boolean = t
expanded += pieceTokens expanded += pieceTokens
emittedPieces++ emittedPieces++
} }
if (emittedPieces == 0) {
expanded += Token("", tokenPos, Token.Type.STRING)
}
expanded += Token(")", tokenPos, Token.Type.RPAREN) expanded += Token(")", tokenPos, Token.Type.RPAREN)
val first = expanded.first() val first = expanded.first()
@@ -766,10 +764,21 @@ private class Parser(fromPos: Pos, private val interpolationEnabled: Boolean = t
} }
private fun parseEmbeddedExpressionTokens(text: String, exprPos: Pos): List<Token> { private fun parseEmbeddedExpressionTokens(text: String, exprPos: Pos): List<Token> {
val tokens = parseLyng(Source(exprPos.source.fileName, text), interpolationEnabled) val tokens = try {
parseLyng(Source(exprPos.source.fileName, text), interpolationEnabled)
} catch (e: ScriptError) {
throw ScriptError(remapEmbeddedPos(exprPos, e.pos), e.errorMessage, e)
}
if (tokens.isEmpty()) return emptyList() if (tokens.isEmpty()) return emptyList()
val withoutEof = if (tokens.last().type == Token.Type.EOF) tokens.dropLast(1) else tokens val withoutEof = if (tokens.last().type == Token.Type.EOF) tokens.dropLast(1) else tokens
return withoutEof return withoutEof.map { it.copy(pos = remapEmbeddedPos(exprPos, it.pos)) }
}
private fun remapEmbeddedPos(exprPos: Pos, embeddedPos: Pos): Pos {
if (embeddedPos.line < 0 || embeddedPos.column < 0) return exprPos
val line = exprPos.line + embeddedPos.line
val column = if (embeddedPos.line == 0) exprPos.column + embeddedPos.column else embeddedPos.column
return Pos(exprPos.source, line, column)
} }
private fun readInterpolationExprText(start: Pos): String { private fun readInterpolationExprText(start: Pos): String {
@@ -17,6 +17,7 @@
package net.sergeych.lyng package net.sergeych.lyng
import com.ionspin.kotlin.bignum.decimal.BigDecimal
import net.sergeych.lyng.obj.* import net.sergeych.lyng.obj.*
/** /**
@@ -133,3 +134,6 @@ fun ScopeFacade.raiseIllegalOperation(message: String = "Operation is illegal"):
fun ScopeFacade.raiseIterationFinished(): Nothing = fun ScopeFacade.raiseIterationFinished(): Nothing =
raiseError(ObjIterationFinishedException(requireScope())) raiseError(ObjIterationFinishedException(requireScope()))
suspend fun ScopeFacade.newDecimal(value: BigDecimal): ObjInstance =
ObjDecimalSupport.newDecimal(this, value)
@@ -27,7 +27,9 @@ import net.sergeych.lyng.bytecode.CmdVm
import net.sergeych.lyng.miniast.* import net.sergeych.lyng.miniast.*
import net.sergeych.lyng.obj.* import net.sergeych.lyng.obj.*
import net.sergeych.lyng.pacman.ImportManager import net.sergeych.lyng.pacman.ImportManager
import net.sergeych.lyng.stdlib_included.complexLyng
import net.sergeych.lyng.stdlib_included.decimalLyng import net.sergeych.lyng.stdlib_included.decimalLyng
import net.sergeych.lyng.stdlib_included.matrixLyng
import net.sergeych.lyng.stdlib_included.observableLyng import net.sergeych.lyng.stdlib_included.observableLyng
import net.sergeych.lyng.stdlib_included.operatorsLyng import net.sergeych.lyng.stdlib_included.operatorsLyng
import net.sergeych.lyng.stdlib_included.rootLyng import net.sergeych.lyng.stdlib_included.rootLyng
@@ -250,6 +252,44 @@ class Script(
companion object { companion object {
private suspend fun ScopeFacade.numberToDouble(value: Obj): Double =
ObjDecimalSupport.toDoubleOrNull(value) ?: value.toDouble()
private suspend fun ScopeFacade.decimalAwareUnaryMath(
value: Obj,
exactDecimal: (suspend ScopeFacade.(Obj) -> Obj?)? = null,
fallback: (Double) -> Double
): Obj {
exactDecimal?.let { exact ->
exact(value)?.let { return it }
}
if (ObjDecimalSupport.isDecimalValue(value)) {
return ObjDecimalSupport.fromRealLike(this, value, fallback(numberToDouble(value)))
?: raiseIllegalState("failed to convert Real result back to Decimal")
}
return ObjReal(fallback(numberToDouble(value)))
}
private suspend fun ScopeFacade.decimalAwareRoundLike(
value: Obj,
exactDecimal: suspend ScopeFacade.(Obj) -> Obj?,
realFallback: (Double) -> Double
): Obj {
if (value is ObjInt) return value
exactDecimal(value)?.let { return it }
return ObjReal(realFallback(numberToDouble(value)))
}
private suspend fun ScopeFacade.decimalAwarePow(base: Obj, exponent: Obj): Obj {
ObjDecimalSupport.exactPow(this, base, exponent)?.let { return it }
if (ObjDecimalSupport.isDecimalValue(base) || ObjDecimalSupport.isDecimalValue(exponent)) {
return ObjDecimalSupport.fromRealLike(this, base, numberToDouble(base).pow(numberToDouble(exponent)))
?: ObjDecimalSupport.fromRealLike(this, exponent, numberToDouble(base).pow(numberToDouble(exponent)))
?: raiseIllegalState("failed to convert Real pow result back to Decimal")
}
return ObjReal(numberToDouble(base).pow(numberToDouble(exponent)))
}
/** /**
* Create new scope using a standard safe set of modules, using [defaultImportManager]. It is * Create new scope using a standard safe set of modules, using [defaultImportManager]. It is
* suspended as first time invocation requires compilation of standard library or other * suspended as first time invocation requires compilation of standard library or other
@@ -287,87 +327,92 @@ class Script(
} }
addFn("floor") { addFn("floor") {
val x = args.firstAndOnly() val x = args.firstAndOnly()
(if (x is ObjInt) x decimalAwareRoundLike(x, ObjDecimalSupport::exactFloor, ::floor)
else ObjReal(floor(x.toDouble())))
} }
addFn("ceil") { addFn("ceil") {
val x = args.firstAndOnly() val x = args.firstAndOnly()
(if (x is ObjInt) x decimalAwareRoundLike(x, ObjDecimalSupport::exactCeil, ::ceil)
else ObjReal(ceil(x.toDouble())))
} }
addFn("round") { addFn("round") {
val x = args.firstAndOnly() val x = args.firstAndOnly()
(if (x is ObjInt) x decimalAwareRoundLike(x, ObjDecimalSupport::exactRound, ::round)
else ObjReal(round(x.toDouble())))
} }
addFn("sin") { addFn("sin") {
ObjReal(sin(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sin)
} }
addFn("cos") { addFn("cos") {
ObjReal(cos(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::cos)
} }
addFn("tan") { addFn("tan") {
ObjReal(tan(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::tan)
} }
addFn("asin") { addFn("asin") {
ObjReal(asin(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::asin)
} }
addFn("acos") { addFn("acos") {
ObjReal(acos(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::acos)
} }
addFn("atan") { addFn("atan") {
ObjReal(atan(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::atan)
} }
addFn("sinh") { addFn("sinh") {
ObjReal(sinh(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sinh)
} }
addFn("cosh") { addFn("cosh") {
ObjReal(cosh(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::cosh)
} }
addFn("tanh") { addFn("tanh") {
ObjReal(tanh(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::tanh)
} }
addFn("asinh") { addFn("asinh") {
ObjReal(asinh(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::asinh)
} }
addFn("acosh") { addFn("acosh") {
ObjReal(acosh(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::acosh)
} }
addFn("atanh") { addFn("atanh") {
ObjReal(atanh(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::atanh)
} }
addFn("exp") { addFn("exp") {
ObjReal(exp(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::exp)
} }
addFn("ln") { addFn("ln") {
ObjReal(ln(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::ln)
} }
addFn("log10") { addFn("log10") {
ObjReal(log10(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::log10)
} }
addFn("log2") { addFn("log2") {
ObjReal(log2(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::log2)
} }
addFn("pow") { addFn("pow") {
requireExactCount(2) requireExactCount(2)
ObjReal( decimalAwarePow(args[0], args[1])
(args[0].toDouble()).pow(args[1].toDouble())
)
} }
addFn("sqrt") { addItem(
ObjReal( "sqrt",
sqrt(args.firstAndOnly().toDouble()) false,
ObjExternCallable.fromBridge {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sqrt)
},
recordType = ObjRecord.Type.Fun,
typeDecl = TypeDecl.Function(
receiver = null,
params = listOf(TypeDecl.TypeAny),
returnType = TypeDecl.Simple("Real", false),
nullable = false
)
) )
}
addFn("abs") { addFn("abs") {
val x = args.firstAndOnly() val x = args.firstAndOnly()
if (x is ObjInt) ObjInt(x.value.absoluteValue) else ObjReal(x.toDouble().absoluteValue) if (x is ObjInt) ObjInt(x.value.absoluteValue)
else decimalAwareUnaryMath(x, ObjDecimalSupport::exactAbs) { it.absoluteValue }
} }
addFnDoc( addFnDoc(
@@ -591,9 +636,17 @@ class Script(
addFn("launch") { addFn("launch") {
val callable = requireOnlyArg<Obj>() val callable = requireOnlyArg<Obj>()
val captured = this val captured = this
ObjDeferred(globalDefer { val session = EvalSession.currentOrNull()
val deferred = if (session != null) {
session.launchTrackedDeferred {
captured.call(callable) captured.call(callable)
}) }
} else {
globalDefer {
captured.call(callable)
}
}
ObjDeferred(deferred)
} }
addFn("yield") { addFn("yield") {
@@ -604,7 +657,7 @@ class Script(
addFn("flow", callSignature = CallSignature(tailBlockReceiverType = "FlowBuilder")) { addFn("flow", callSignature = CallSignature(tailBlockReceiverType = "FlowBuilder")) {
// important is: current context contains closure often used in call; // important is: current context contains closure often used in call;
// we'll need it for the producer // we'll need it for the producer
ObjFlow(requireOnlyArg<Obj>(), requireScope()) ObjFlow(requireOnlyArg<Obj>(), requireScope(), EvalSession.currentOrNull())
} }
val pi = ObjReal(PI) val pi = ObjReal(PI)
@@ -615,12 +668,88 @@ class Script(
type = type("lyng.Real") type = type("lyng.Real")
) )
getOrCreateNamespace("Math").apply { getOrCreateNamespace("Math").apply {
fun ensureFn(name: String, fn: suspend ScopeFacade.() -> Obj) {
if (members.containsKey(name)) return
addFn(name, code = fn)
}
addConstDoc( addConstDoc(
name = "PI", name = "PI",
value = pi, value = pi,
doc = "The mathematical constant pi (π) in the Math namespace.", doc = "The mathematical constant pi (π) in the Math namespace.",
type = type("lyng.Real") type = type("lyng.Real")
) )
ensureFn("floor") {
val x = args.firstAndOnly()
decimalAwareRoundLike(x, ObjDecimalSupport::exactFloor, ::floor)
}
ensureFn("ceil") {
val x = args.firstAndOnly()
decimalAwareRoundLike(x, ObjDecimalSupport::exactCeil, ::ceil)
}
ensureFn("round") {
val x = args.firstAndOnly()
decimalAwareRoundLike(x, ObjDecimalSupport::exactRound, ::round)
}
ensureFn("sin") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sin)
}
ensureFn("cos") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::cos)
}
ensureFn("tan") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::tan)
}
ensureFn("asin") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::asin)
}
ensureFn("acos") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::acos)
}
ensureFn("atan") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::atan)
}
ensureFn("sinh") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sinh)
}
ensureFn("cosh") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::cosh)
}
ensureFn("tanh") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::tanh)
}
ensureFn("asinh") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::asinh)
}
ensureFn("acosh") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::acosh)
}
ensureFn("atanh") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::atanh)
}
ensureFn("exp") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::exp)
}
ensureFn("ln") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::ln)
}
ensureFn("log10") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::log10)
}
ensureFn("log2") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::log2)
}
ensureFn("pow") {
requireExactCount(2)
decimalAwarePow(args[0], args[1])
}
ensureFn("sqrt") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sqrt)
}
ensureFn("abs") {
val x = args.firstAndOnly()
if (x is ObjInt) ObjInt(x.value.absoluteValue)
else decimalAwareUnaryMath(x, ObjDecimalSupport::exactAbs) { it.absoluteValue }
}
} }
} }
@@ -757,7 +886,15 @@ class Script(
} }
addPackage("lyng.decimal") { module -> addPackage("lyng.decimal") { module ->
module.eval(Source("lyng.decimal", decimalLyng)) module.eval(Source("lyng.decimal", decimalLyng))
ObjBigDecimalSupport.bindTo(module) ObjDecimalSupport.bindTo(module)
}
addPackage("lyng.matrix") { module ->
module.eval(Source("lyng.matrix", matrixLyng))
ObjMatrixSupport.bindTo(module)
}
addPackage("lyng.complex") { module ->
module.eval(Source("lyng.complex", complexLyng))
ObjComplexSupport.bindTo(module)
} }
addPackage("lyng.buffer") { addPackage("lyng.buffer") {
it.addConstDoc( it.addConstDoc(
@@ -43,6 +43,8 @@ class BytecodeCompiler(
private val callableReturnTypeByName: Map<String, ObjClass> = emptyMap(), private val callableReturnTypeByName: Map<String, ObjClass> = emptyMap(),
private val externCallableNames: Set<String> = emptySet(), private val externCallableNames: Set<String> = emptySet(),
private val externBindingNames: Set<String> = emptySet(), private val externBindingNames: Set<String> = emptySet(),
private val preparedModuleBindingNames: Set<String> = emptySet(),
private val scopeRefPosByName: Map<String, Pos> = emptyMap(),
private val lambdaCaptureEntriesByRef: Map<ValueFnRef, List<LambdaCaptureEntry>> = emptyMap(), private val lambdaCaptureEntriesByRef: Map<ValueFnRef, List<LambdaCaptureEntry>> = emptyMap(),
) { ) {
private val useScopeSlots: Boolean = allowedScopeNames != null || scopeSlotNameSet != null private val useScopeSlots: Boolean = allowedScopeNames != null || scopeSlotNameSet != null
@@ -53,12 +55,15 @@ class BytecodeCompiler(
private var scopeSlotIndices = IntArray(0) private var scopeSlotIndices = IntArray(0)
private var scopeSlotNames = emptyArray<String?>() private var scopeSlotNames = emptyArray<String?>()
private var scopeSlotIsModule = BooleanArray(0) private var scopeSlotIsModule = BooleanArray(0)
private var scopeSlotRequiresPreparedBinding = BooleanArray(0)
private var scopeSlotRefPos = emptyArray<Pos?>()
private var scopeSlotMutables = BooleanArray(0) private var scopeSlotMutables = BooleanArray(0)
private var scopeKeyByIndex = emptyArray<ScopeSlotKey?>() private var scopeKeyByIndex = emptyArray<ScopeSlotKey?>()
private val scopeSlotMap = LinkedHashMap<ScopeSlotKey, Int>() private val scopeSlotMap = LinkedHashMap<ScopeSlotKey, Int>()
private val scopeSlotNameMap = LinkedHashMap<ScopeSlotKey, String>() private val scopeSlotNameMap = LinkedHashMap<ScopeSlotKey, String>()
private val scopeSlotMutableMap = LinkedHashMap<ScopeSlotKey, Boolean>() private val scopeSlotMutableMap = LinkedHashMap<ScopeSlotKey, Boolean>()
private val scopeSlotIndexByName = LinkedHashMap<String, Int>() private val scopeSlotIndexByName = LinkedHashMap<String, Int>()
private val scopeSlotRefPosByKey = LinkedHashMap<ScopeSlotKey, Pos>()
private val pendingScopeNameRefs = LinkedHashSet<String>() private val pendingScopeNameRefs = LinkedHashSet<String>()
private val addrSlotByScopeSlot = LinkedHashMap<Int, Int>() private val addrSlotByScopeSlot = LinkedHashMap<Int, Int>()
private data class LocalSlotInfo(val name: String, val isMutable: Boolean, val isDelegated: Boolean) private data class LocalSlotInfo(val name: String, val isMutable: Boolean, val isDelegated: Boolean)
@@ -119,6 +124,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -140,6 +147,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -158,6 +167,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -176,6 +187,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -194,6 +207,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -212,6 +227,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -230,6 +247,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -248,6 +267,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -266,6 +287,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -284,6 +307,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -302,6 +327,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -322,6 +349,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -340,6 +369,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -358,6 +389,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -376,6 +409,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -395,6 +430,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -416,6 +453,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -439,6 +478,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -459,6 +500,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -534,6 +577,7 @@ class BytecodeCompiler(
resolved = SlotType.INT resolved = SlotType.INT
} }
if (mapped < scopeSlotCount && resolved != SlotType.UNKNOWN) { if (mapped < scopeSlotCount && resolved != SlotType.UNKNOWN) {
noteScopeSlotRef(mapped, ref.pos())
val addrSlot = ensureScopeAddr(mapped) val addrSlot = ensureScopeAddr(mapped)
val local = allocSlot() val local = allocSlot()
emitLoadFromAddr(addrSlot, local, resolved) emitLoadFromAddr(addrSlot, local, resolved)
@@ -544,6 +588,7 @@ class BytecodeCompiler(
return CompiledValue(local, resolved) return CompiledValue(local, resolved)
} }
if (mapped < scopeSlotCount && resolved == SlotType.UNKNOWN) { if (mapped < scopeSlotCount && resolved == SlotType.UNKNOWN) {
noteScopeSlotRef(mapped, ref.pos())
val addrSlot = ensureScopeAddr(mapped) val addrSlot = ensureScopeAddr(mapped)
val local = allocSlot() val local = allocSlot()
emitLoadFromAddr(addrSlot, local, SlotType.OBJ) emitLoadFromAddr(addrSlot, local, SlotType.OBJ)
@@ -563,6 +608,7 @@ class BytecodeCompiler(
} }
if (allowLocalSlots) { if (allowLocalSlots) {
scopeSlotIndexByName[ref.name]?.let { slot -> scopeSlotIndexByName[ref.name]?.let { slot ->
noteScopeSlotRef(slot, callSitePos())
val resolved = slotTypes[slot] ?: SlotType.UNKNOWN val resolved = slotTypes[slot] ?: SlotType.UNKNOWN
return CompiledValue(slot, resolved) return CompiledValue(slot, resolved)
} }
@@ -585,6 +631,7 @@ class BytecodeCompiler(
return CompiledValue(slot, resolved) return CompiledValue(slot, resolved)
} }
scopeSlotIndexByName[ref.name]?.let { slot -> scopeSlotIndexByName[ref.name]?.let { slot ->
noteScopeSlotRef(slot, callSitePos())
val resolved = slotTypes[slot] ?: SlotType.UNKNOWN val resolved = slotTypes[slot] ?: SlotType.UNKNOWN
return CompiledValue(slot, resolved) return CompiledValue(slot, resolved)
} }
@@ -596,6 +643,7 @@ class BytecodeCompiler(
val slot = ref.slotIndex() val slot = ref.slotIndex()
val resolved = slotTypes[slot] ?: SlotType.UNKNOWN val resolved = slotTypes[slot] ?: SlotType.UNKNOWN
if (slot < scopeSlotCount && resolved != SlotType.UNKNOWN) { if (slot < scopeSlotCount && resolved != SlotType.UNKNOWN) {
noteScopeSlotRef(slot, callSitePos())
val addrSlot = ensureScopeAddr(slot) val addrSlot = ensureScopeAddr(slot)
val local = allocSlot() val local = allocSlot()
emitLoadFromAddr(addrSlot, local, resolved) emitLoadFromAddr(addrSlot, local, resolved)
@@ -2396,7 +2444,8 @@ class BytecodeCompiler(
builder.emit(Opcode.THROW, posId, msgSlot) builder.emit(Opcode.THROW, posId, msgSlot)
return value return value
} }
val slot = resolveSlot(localTarget) val slot = resolveCapturedOwnerScopeSlot(localTarget)
?: resolveSlot(localTarget)
?: resolveAssignableSlotByName(localTarget.name)?.first ?: resolveAssignableSlotByName(localTarget.name)?.first
?: return null ?: return null
if (slot < scopeSlotCount && value.type != SlotType.UNKNOWN) { if (slot < scopeSlotCount && value.type != SlotType.UNKNOWN) {
@@ -2702,7 +2751,7 @@ class BytecodeCompiler(
return CompiledValue(result, SlotType.OBJ) return CompiledValue(result, SlotType.OBJ)
} }
if (localTarget.isDelegated) return compileEvalRef(ref) if (localTarget.isDelegated) return compileEvalRef(ref)
val slot = resolveSlot(localTarget) ?: return null val slot = resolveCapturedOwnerScopeSlot(localTarget) ?: resolveSlot(localTarget) ?: return null
val targetType = slotTypes[slot] ?: SlotType.OBJ val targetType = slotTypes[slot] ?: SlotType.OBJ
if (!localTarget.isMutable) { if (!localTarget.isMutable) {
if (targetType != SlotType.OBJ && targetType != SlotType.UNKNOWN) return compileEvalRef(ref) if (targetType != SlotType.OBJ && targetType != SlotType.UNKNOWN) return compileEvalRef(ref)
@@ -5001,6 +5050,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -5020,6 +5071,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -5040,6 +5093,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -5060,6 +5115,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -5083,6 +5140,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -5102,6 +5161,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -5726,6 +5787,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -7598,6 +7661,14 @@ class BytecodeCompiler(
private fun assignValue(ref: AssignRef): ObjRef = ref.value private fun assignValue(ref: AssignRef): ObjRef = ref.value
private fun refPos(ref: BinaryOpRef): Pos = Pos.builtIn private fun refPos(ref: BinaryOpRef): Pos = Pos.builtIn
private fun noteScopeSlotRef(slot: Int, pos: Pos) {
if (slot >= scopeSlotCount) return
val key = scopeKeyByIndex.getOrNull(slot) ?: return
if (!scopeSlotRefPosByKey.containsKey(key)) {
scopeSlotRefPosByKey[key] = pos
}
}
private fun resolveSlot(ref: LocalSlotRef): Int? { private fun resolveSlot(ref: LocalSlotRef): Int? {
loopSlotOverrides[ref.name]?.let { return it } loopSlotOverrides[ref.name]?.let { return it }
val scopeId = refScopeId(ref) val scopeId = refScopeId(ref)
@@ -7605,8 +7676,18 @@ class BytecodeCompiler(
val key = ScopeSlotKey(scopeId, refSlot(ref)) val key = ScopeSlotKey(scopeId, refSlot(ref))
val localIndex = localSlotIndexByKey[key] val localIndex = localSlotIndexByKey[key]
if (localIndex != null) return scopeSlotCount + localIndex if (localIndex != null) return scopeSlotCount + localIndex
scopeSlotMap[key]?.let { return it } scopeSlotMap[key]?.let {
scopeSlotIndexByName[ref.name]?.let { return it } if (!scopeSlotRefPosByKey.containsKey(key)) {
scopeSlotRefPosByKey[key] = ref.pos()
}
return it
}
scopeSlotIndexByName[ref.name]?.let {
if (!scopeSlotRefPosByKey.containsKey(key)) {
scopeSlotRefPosByKey[key] = ref.pos()
}
return it
}
} }
if (ref.captureOwnerScopeId != null) { if (ref.captureOwnerScopeId != null) {
val scopeKey = ScopeSlotKey(refScopeId(ref), refSlot(ref)) val scopeKey = ScopeSlotKey(refScopeId(ref), refSlot(ref))
@@ -7616,7 +7697,13 @@ class BytecodeCompiler(
return scopeSlotCount + localIndex return scopeSlotCount + localIndex
} }
} }
return scopeSlotMap[scopeKey] val resolved = scopeSlotMap[scopeKey]
if (resolved != null) {
if (!scopeSlotRefPosByKey.containsKey(scopeKey)) {
scopeSlotRefPosByKey[scopeKey] = ref.pos()
}
}
return resolved
} }
if (ref.isDelegated) { if (ref.isDelegated) {
val localKey = ScopeSlotKey(refScopeId(ref), refSlot(ref)) val localKey = ScopeSlotKey(refScopeId(ref), refSlot(ref))
@@ -7627,7 +7714,20 @@ class BytecodeCompiler(
val localIndex = localSlotIndexByKey[localKey] val localIndex = localSlotIndexByKey[localKey]
if (localIndex != null) return scopeSlotCount + localIndex if (localIndex != null) return scopeSlotCount + localIndex
val scopeKey = ScopeSlotKey(refScopeId(ref), refSlot(ref)) val scopeKey = ScopeSlotKey(refScopeId(ref), refSlot(ref))
return scopeSlotMap[scopeKey] val resolved = scopeSlotMap[scopeKey]
if (resolved != null) {
if (!scopeSlotRefPosByKey.containsKey(scopeKey)) {
scopeSlotRefPosByKey[scopeKey] = ref.pos()
}
}
return resolved
}
private fun resolveCapturedOwnerScopeSlot(ref: LocalSlotRef): Int? {
val ownerScopeId = ref.captureOwnerScopeId ?: return null
val ownerSlot = ref.captureOwnerSlot ?: return null
val key = ScopeSlotKey(ownerScopeId, ownerSlot)
return scopeSlotMap[key]
} }
private fun updateSlotType(slot: Int, type: SlotType) { private fun updateSlotType(slot: Int, type: SlotType) {
@@ -7850,6 +7950,8 @@ class BytecodeCompiler(
scopeSlotIndices = IntArray(scopeSlotCount) scopeSlotIndices = IntArray(scopeSlotCount)
scopeSlotNames = arrayOfNulls(scopeSlotCount) scopeSlotNames = arrayOfNulls(scopeSlotCount)
scopeSlotIsModule = BooleanArray(scopeSlotCount) scopeSlotIsModule = BooleanArray(scopeSlotCount)
scopeSlotRequiresPreparedBinding = BooleanArray(scopeSlotCount)
scopeSlotRefPos = arrayOfNulls(scopeSlotCount)
scopeSlotMutables = BooleanArray(scopeSlotCount) { true } scopeSlotMutables = BooleanArray(scopeSlotCount) { true }
scopeKeyByIndex = arrayOfNulls(scopeSlotCount) scopeKeyByIndex = arrayOfNulls(scopeSlotCount)
for ((key, index) in scopeSlotMap) { for ((key, index) in scopeSlotMap) {
@@ -7857,6 +7959,8 @@ class BytecodeCompiler(
scopeSlotIndices[index] = key.slot scopeSlotIndices[index] = key.slot
scopeSlotNames[index] = name scopeSlotNames[index] = name
scopeSlotIsModule[index] = moduleScopeId != null && key.scopeId == moduleScopeId scopeSlotIsModule[index] = moduleScopeId != null && key.scopeId == moduleScopeId
scopeSlotRequiresPreparedBinding[index] = name != null && preparedModuleBindingNames.contains(name)
scopeSlotRefPos[index] = name?.let { scopeRefPosByName[it] } ?: scopeSlotRefPosByKey[key]
scopeSlotMutableMap[key]?.let { scopeSlotMutables[index] = it } scopeSlotMutableMap[key]?.let { scopeSlotMutables[index] = it }
scopeKeyByIndex[index] = key scopeKeyByIndex[index] = key
} }
@@ -50,7 +50,7 @@ class BytecodeStatement private constructor(
?: scope.parent?.get(name) ?: scope.parent?.get(name)
?: scope.get(name) ?: scope.get(name)
?: continue ?: continue
val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property) { val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is net.sergeych.lyng.obj.ObjProperty) {
scope.resolve(record, name) scope.resolve(record, name)
} else { } else {
record.value record.value
@@ -88,6 +88,8 @@ class BytecodeStatement private constructor(
callableReturnTypeByName: Map<String, ObjClass> = emptyMap(), callableReturnTypeByName: Map<String, ObjClass> = emptyMap(),
externCallableNames: Set<String> = emptySet(), externCallableNames: Set<String> = emptySet(),
externBindingNames: Set<String> = emptySet(), externBindingNames: Set<String> = emptySet(),
preparedModuleBindingNames: Set<String> = emptySet(),
scopeRefPosByName: Map<String, Pos> = emptyMap(),
lambdaCaptureEntriesByRef: Map<ValueFnRef, List<LambdaCaptureEntry>> = emptyMap(), lambdaCaptureEntriesByRef: Map<ValueFnRef, List<LambdaCaptureEntry>> = emptyMap(),
slotTypeDeclByScopeId: Map<Int, Map<Int, TypeDecl>> = emptyMap(), slotTypeDeclByScopeId: Map<Int, Map<Int, TypeDecl>> = emptyMap(),
): Statement { ): Statement {
@@ -124,6 +126,8 @@ class BytecodeStatement private constructor(
callableReturnTypeByName = callableReturnTypeByName, callableReturnTypeByName = callableReturnTypeByName,
externCallableNames = externCallableNames, externCallableNames = externCallableNames,
externBindingNames = externBindingNames, externBindingNames = externBindingNames,
preparedModuleBindingNames = preparedModuleBindingNames,
scopeRefPosByName = scopeRefPosByName,
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
) )
val compiled = compiler.compileStatement(nameHint, statement) val compiled = compiler.compileStatement(nameHint, statement)
@@ -67,6 +67,8 @@ class CmdBuilder {
scopeSlotIndices: IntArray = IntArray(0), scopeSlotIndices: IntArray = IntArray(0),
scopeSlotNames: Array<String?> = emptyArray(), scopeSlotNames: Array<String?> = emptyArray(),
scopeSlotIsModule: BooleanArray = BooleanArray(0), scopeSlotIsModule: BooleanArray = BooleanArray(0),
scopeSlotRequiresPreparedBinding: BooleanArray = BooleanArray(0),
scopeSlotRefPos: Array<net.sergeych.lyng.Pos?> = emptyArray(),
localSlotNames: Array<String?> = emptyArray(), localSlotNames: Array<String?> = emptyArray(),
localSlotMutables: BooleanArray = BooleanArray(0), localSlotMutables: BooleanArray = BooleanArray(0),
localSlotDelegated: BooleanArray = BooleanArray(0), localSlotDelegated: BooleanArray = BooleanArray(0),
@@ -79,6 +81,12 @@ class CmdBuilder {
require(scopeSlotIsModule.isEmpty() || scopeSlotIsModule.size == scopeSlotCount) { require(scopeSlotIsModule.isEmpty() || scopeSlotIsModule.size == scopeSlotCount) {
"scope slot module mapping size mismatch" "scope slot module mapping size mismatch"
} }
require(scopeSlotRequiresPreparedBinding.isEmpty() || scopeSlotRequiresPreparedBinding.size == scopeSlotCount) {
"scope slot prepared-binding mapping size mismatch"
}
require(scopeSlotRefPos.isEmpty() || scopeSlotRefPos.size == scopeSlotCount) {
"scope slot position mapping size mismatch"
}
require(localSlotNames.size == localSlotMutables.size) { "local slot metadata size mismatch" } require(localSlotNames.size == localSlotMutables.size) { "local slot metadata size mismatch" }
require(localSlotNames.size == localSlotDelegated.size) { "local slot delegation size mismatch" } require(localSlotNames.size == localSlotDelegated.size) { "local slot delegation size mismatch" }
require(localSlotNames.size == localSlotCaptures.size) { "local slot capture size mismatch" } require(localSlotNames.size == localSlotCaptures.size) { "local slot capture size mismatch" }
@@ -113,6 +121,8 @@ class CmdBuilder {
scopeSlotIndices = scopeSlotIndices, scopeSlotIndices = scopeSlotIndices,
scopeSlotNames = if (scopeSlotNames.isEmpty()) Array(scopeSlotCount) { null } else scopeSlotNames, scopeSlotNames = if (scopeSlotNames.isEmpty()) Array(scopeSlotCount) { null } else scopeSlotNames,
scopeSlotIsModule = if (scopeSlotIsModule.isEmpty()) BooleanArray(scopeSlotCount) else scopeSlotIsModule, scopeSlotIsModule = if (scopeSlotIsModule.isEmpty()) BooleanArray(scopeSlotCount) else scopeSlotIsModule,
scopeSlotRequiresPreparedBinding = if (scopeSlotRequiresPreparedBinding.isEmpty()) BooleanArray(scopeSlotCount) else scopeSlotRequiresPreparedBinding,
scopeSlotRefPos = if (scopeSlotRefPos.isEmpty()) Array(scopeSlotCount) { null } else scopeSlotRefPos,
localSlotNames = localSlotNames, localSlotNames = localSlotNames,
localSlotMutables = localSlotMutables, localSlotMutables = localSlotMutables,
localSlotDelegated = localSlotDelegated, localSlotDelegated = localSlotDelegated,
@@ -26,6 +26,8 @@ data class CmdFunction(
val scopeSlotIndices: IntArray, val scopeSlotIndices: IntArray,
val scopeSlotNames: Array<String?>, val scopeSlotNames: Array<String?>,
val scopeSlotIsModule: BooleanArray, val scopeSlotIsModule: BooleanArray,
val scopeSlotRequiresPreparedBinding: BooleanArray,
val scopeSlotRefPos: Array<net.sergeych.lyng.Pos?>,
val localSlotNames: Array<String?>, val localSlotNames: Array<String?>,
val localSlotMutables: BooleanArray, val localSlotMutables: BooleanArray,
val localSlotDelegated: BooleanArray, val localSlotDelegated: BooleanArray,
@@ -38,6 +40,8 @@ data class CmdFunction(
require(scopeSlotIndices.size == scopeSlotCount) { "scopeSlotIndices size mismatch" } require(scopeSlotIndices.size == scopeSlotCount) { "scopeSlotIndices size mismatch" }
require(scopeSlotNames.size == scopeSlotCount) { "scopeSlotNames size mismatch" } require(scopeSlotNames.size == scopeSlotCount) { "scopeSlotNames size mismatch" }
require(scopeSlotIsModule.size == scopeSlotCount) { "scopeSlotIsModule size mismatch" } require(scopeSlotIsModule.size == scopeSlotCount) { "scopeSlotIsModule size mismatch" }
require(scopeSlotRequiresPreparedBinding.size == scopeSlotCount) { "scopeSlotRequiresPreparedBinding size mismatch" }
require(scopeSlotRefPos.size == scopeSlotCount) { "scopeSlotRefPos size mismatch" }
require(localSlotNames.size == localSlotMutables.size) { "localSlot metadata size mismatch" } require(localSlotNames.size == localSlotMutables.size) { "localSlot metadata size mismatch" }
require(localSlotNames.size == localSlotDelegated.size) { "localSlot delegation size mismatch" } require(localSlotNames.size == localSlotDelegated.size) { "localSlot delegation size mismatch" }
require(localSlotNames.size == localSlotCaptures.size) { "localSlot capture size mismatch" } require(localSlotNames.size == localSlotCaptures.size) { "localSlot capture size mismatch" }
@@ -85,6 +85,9 @@ class CmdNop : Cmd() {
class CmdMoveObj(internal val src: Int, internal val dst: Int) : Cmd() { class CmdMoveObj(internal val src: Int, internal val dst: Int) : Cmd() {
override suspend fun perform(frame: CmdFrame) { override suspend fun perform(frame: CmdFrame) {
val value = frame.slotToObj(src) val value = frame.slotToObj(src)
if (frame.writeThroughPropertyLikeSlot(dst, value)) {
return
}
if (frame.shouldBypassImmutableWrite(dst)) { if (frame.shouldBypassImmutableWrite(dst)) {
frame.setObjUnchecked(dst, value) frame.setObjUnchecked(dst, value)
} else { } else {
@@ -97,6 +100,9 @@ class CmdMoveObj(internal val src: Int, internal val dst: Int) : Cmd() {
class CmdMoveInt(internal val src: Int, internal val dst: Int) : Cmd() { class CmdMoveInt(internal val src: Int, internal val dst: Int) : Cmd() {
override suspend fun perform(frame: CmdFrame) { override suspend fun perform(frame: CmdFrame) {
val value = frame.getInt(src) val value = frame.getInt(src)
if (frame.writeThroughPropertyLikeSlot(dst, ObjInt.of(value))) {
return
}
if (frame.shouldBypassImmutableWrite(dst)) { if (frame.shouldBypassImmutableWrite(dst)) {
frame.setIntUnchecked(dst, value) frame.setIntUnchecked(dst, value)
} else { } else {
@@ -117,6 +123,9 @@ class CmdMoveIntLocal(internal val src: Int, internal val dst: Int) : Cmd() {
class CmdMoveReal(internal val src: Int, internal val dst: Int) : Cmd() { class CmdMoveReal(internal val src: Int, internal val dst: Int) : Cmd() {
override suspend fun perform(frame: CmdFrame) { override suspend fun perform(frame: CmdFrame) {
val value = frame.getReal(src) val value = frame.getReal(src)
if (frame.writeThroughPropertyLikeSlot(dst, ObjReal.of(value))) {
return
}
if (frame.shouldBypassImmutableWrite(dst)) { if (frame.shouldBypassImmutableWrite(dst)) {
frame.setRealUnchecked(dst, value) frame.setRealUnchecked(dst, value)
} else { } else {
@@ -137,6 +146,9 @@ class CmdMoveRealLocal(internal val src: Int, internal val dst: Int) : Cmd() {
class CmdMoveBool(internal val src: Int, internal val dst: Int) : Cmd() { class CmdMoveBool(internal val src: Int, internal val dst: Int) : Cmd() {
override suspend fun perform(frame: CmdFrame) { override suspend fun perform(frame: CmdFrame) {
val value = frame.getBool(src) val value = frame.getBool(src)
if (frame.writeThroughPropertyLikeSlot(dst, if (value) ObjTrue else ObjFalse)) {
return
}
if (frame.shouldBypassImmutableWrite(dst)) { if (frame.shouldBypassImmutableWrite(dst)) {
frame.setBoolUnchecked(dst, value) frame.setBoolUnchecked(dst, value)
} else { } else {
@@ -2595,7 +2607,7 @@ private fun buildFunctionCaptureRecords(frame: CmdFrame, captureNames: List<Stri
} }
val scoped = frame.scope.chainLookupIgnoreClosure(name, followClosure = true) ?: frame.scope.get(name) val scoped = frame.scope.chainLookupIgnoreClosure(name, followClosure = true) ?: frame.scope.get(name)
if (scoped != null) { if (scoped != null) {
records += ObjRecord(RecordSlotRef(scoped), isMutable = scoped.isMutable) records += scoped
continue continue
} }
frame.ensureScope().raiseSymbolNotFound("capture $name not found") frame.ensureScope().raiseSymbolNotFound("capture $name not found")
@@ -2858,7 +2870,7 @@ class CmdDeclInstanceProperty(internal val constId: Int, internal val slot: Int)
val decl = frame.fn.constants[constId] as? BytecodeConst.InstancePropertyDecl val decl = frame.fn.constants[constId] as? BytecodeConst.InstancePropertyDecl
?: error("DECL_INSTANCE_PROPERTY expects InstancePropertyDecl at $constId") ?: error("DECL_INSTANCE_PROPERTY expects InstancePropertyDecl at $constId")
val scope = frame.ensureScope() val scope = frame.ensureScope()
val prop = frame.slotToObj(slot) val prop = frame.storedSlotObj(slot)
scope.addItem( scope.addItem(
decl.name, decl.name,
decl.isMutable, decl.isMutable,
@@ -3724,7 +3736,7 @@ class BytecodeLambdaCallable(
?: context.parent?.get(name) ?: context.parent?.get(name)
?: context.get(name) ?: context.get(name)
?: continue ?: continue
val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property) { val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is ObjProperty) {
context.resolve(record, name) context.resolve(record, name)
} else { } else {
record.value record.value
@@ -3817,7 +3829,29 @@ class CmdFrame(
} }
internal fun getLocalSlotTypeCode(localIndex: Int): Byte = frame.getSlotTypeCode(localIndex) internal fun getLocalSlotTypeCode(localIndex: Int): Byte = frame.getSlotTypeCode(localIndex)
internal fun readLocalObj(localIndex: Int): Obj = localSlotToObj(localIndex) internal fun readLocalObj(localIndex: Int): Obj {
return when (frame.getSlotTypeCode(localIndex)) {
SlotType.INT.code -> ObjInt.of(frame.getInt(localIndex))
SlotType.REAL.code -> ObjReal.of(frame.getReal(localIndex))
SlotType.BOOL.code -> if (frame.getBool(localIndex)) ObjTrue else ObjFalse
SlotType.OBJ.code -> {
val obj = frame.getObj(localIndex)
when (obj) {
is FrameSlotRef -> obj.read()
is RecordSlotRef -> obj.read()
else -> obj
}
}
else -> {
val obj = frame.getObj(localIndex)
when (obj) {
is FrameSlotRef -> obj.read()
is RecordSlotRef -> obj.read()
else -> obj
}
}
}
}
internal fun isFastLocalSlot(slot: Int): Boolean { internal fun isFastLocalSlot(slot: Int): Boolean {
if (slot < fn.scopeSlotCount) return false if (slot < fn.scopeSlotCount) return false
val localIndex = slot - fn.scopeSlotCount val localIndex = slot - fn.scopeSlotCount
@@ -4078,7 +4112,7 @@ class CmdFrame(
} }
fun ensureScope(): Scope { fun ensureScope(): Scope {
val pos = posForIp(ip - 1) val pos = currentErrorPos()
if (pos != null && lastScopePosIp != ip) { if (pos != null && lastScopePosIp != ip) {
scope.pos = pos scope.pos = pos
lastScopePosIp = ip lastScopePosIp = ip
@@ -4155,6 +4189,33 @@ class CmdFrame(
return fn.posByIp.getOrNull(ip) return fn.posByIp.getOrNull(ip)
} }
private fun currentErrorPos(): Pos? {
val center = ip - 1
if (center < 0) return null
var fallback: Pos? = null
val maxRadius = maxOf(center, fn.posByIp.size - 1 - center)
for (radius in 0..maxRadius) {
val before = center - radius
if (before >= 0) {
val pos = posForIp(before)
if (pos != null) {
if (pos.source !== Source.builtIn && pos.source !== Source.UNKNOWN) return pos
if (fallback == null) fallback = pos
}
}
if (radius == 0) continue
val after = center + radius
if (after < fn.posByIp.size) {
val pos = posForIp(after)
if (pos != null) {
if (pos.source !== Source.builtIn && pos.source !== Source.UNKNOWN) return pos
if (fallback == null) fallback = pos
}
}
}
return fallback
}
fun pushScope(plan: Map<String, Int>, captures: List<String>) { fun pushScope(plan: Map<String, Int>, captures: List<String>) {
if (scope.skipScopeCreation) { if (scope.skipScopeCreation) {
val snapshot = emptyMap<String, Int?>() val snapshot = emptyMap<String, Int?>()
@@ -4262,7 +4323,7 @@ class CmdFrame(
return if (slot < fn.scopeSlotCount) { return if (slot < fn.scopeSlotCount) {
getScopeSlotValue(slot) getScopeSlotValue(slot)
} else { } else {
localSlotToObj(slot - fn.scopeSlotCount) readLocalSlotValue(slot - fn.scopeSlotCount)
} }
} }
@@ -4305,6 +4366,35 @@ class CmdFrame(
} }
} }
suspend fun writeThroughPropertyLikeSlot(slot: Int, value: Obj): Boolean {
if (slot < fn.scopeSlotCount) {
val target = scopeTarget(slot)
val index = ensureScopeSlot(target, slot)
val name = fn.scopeSlotNames.getOrNull(slot)
val record = resolveScopeSlotRecordForWrite(target, index, name)
if (name != null && record != null && (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is ObjProperty)) {
target.assign(record, name, value)
return true
}
return false
}
val localIndex = slot - fn.scopeSlotCount
val name = fn.localSlotNames.getOrNull(localIndex) ?: return false
val isCapture = fn.localSlotCaptures.getOrNull(localIndex) == true
val raw = frame.getRawObj(localIndex)
if (raw is RecordSlotRef) {
if (raw.write(scope, name, value)) return true
return false
}
if (!isCapture && raw !== ObjUnset && raw !is ObjProperty) return false
val record = scope.parent?.get(name) ?: scope.get(name) ?: return false
if (record.type != ObjRecord.Type.Delegated && record.type != ObjRecord.Type.Property && record.value !is ObjProperty) {
return false
}
scope.assign(record, name, value)
return true
}
suspend fun getInt(slot: Int): Long { suspend fun getInt(slot: Int): Long {
return if (slot < fn.scopeSlotCount) { return if (slot < fn.scopeSlotCount) {
getScopeSlotValue(slot).toLong() getScopeSlotValue(slot).toLong()
@@ -4314,14 +4404,7 @@ class CmdFrame(
SlotType.INT.code -> frame.getInt(local) SlotType.INT.code -> frame.getInt(local)
SlotType.REAL.code -> frame.getReal(local).toLong() SlotType.REAL.code -> frame.getReal(local).toLong()
SlotType.BOOL.code -> if (frame.getBool(local)) 1L else 0L SlotType.BOOL.code -> if (frame.getBool(local)) 1L else 0L
SlotType.OBJ.code -> { SlotType.OBJ.code -> readLocalSlotValue(local).toLong()
val obj = frame.getObj(local)
when (obj) {
is FrameSlotRef -> obj.read().toLong()
is RecordSlotRef -> obj.read().toLong()
else -> obj.toLong()
}
}
else -> 0L else -> 0L
} }
} }
@@ -4401,14 +4484,7 @@ class CmdFrame(
SlotType.REAL.code -> frame.getReal(local) SlotType.REAL.code -> frame.getReal(local)
SlotType.INT.code -> frame.getInt(local).toDouble() SlotType.INT.code -> frame.getInt(local).toDouble()
SlotType.BOOL.code -> if (frame.getBool(local)) 1.0 else 0.0 SlotType.BOOL.code -> if (frame.getBool(local)) 1.0 else 0.0
SlotType.OBJ.code -> { SlotType.OBJ.code -> readLocalSlotValue(local).toDouble()
val obj = frame.getObj(local)
when (obj) {
is FrameSlotRef -> obj.read().toDouble()
is RecordSlotRef -> obj.read().toDouble()
else -> obj.toDouble()
}
}
else -> 0.0 else -> 0.0
} }
} }
@@ -4477,14 +4553,7 @@ class CmdFrame(
SlotType.BOOL.code -> frame.getBool(local) SlotType.BOOL.code -> frame.getBool(local)
SlotType.INT.code -> frame.getInt(local) != 0L SlotType.INT.code -> frame.getInt(local) != 0L
SlotType.REAL.code -> frame.getReal(local) != 0.0 SlotType.REAL.code -> frame.getReal(local) != 0.0
SlotType.OBJ.code -> { SlotType.OBJ.code -> readLocalSlotValue(local).toBool()
val obj = frame.getObj(local)
when (obj) {
is FrameSlotRef -> obj.read().toBool()
is RecordSlotRef -> obj.read().toBool()
else -> obj.toBool()
}
}
else -> false else -> false
} }
} }
@@ -4596,21 +4665,42 @@ class CmdFrame(
} }
val local = slot - fn.scopeSlotCount val local = slot - fn.scopeSlotCount
if (fn.localSlotCaptures.getOrNull(local) == true) { if (fn.localSlotCaptures.getOrNull(local) == true) {
return localSlotToObj(local) return readLocalSlotValue(local)
} }
return when (frame.getSlotTypeCode(local)) { return when (frame.getSlotTypeCode(local)) {
SlotType.INT.code -> ObjInt.of(frame.getInt(local)) SlotType.INT.code -> ObjInt.of(frame.getInt(local))
SlotType.REAL.code -> ObjReal.of(frame.getReal(local)) SlotType.REAL.code -> ObjReal.of(frame.getReal(local))
SlotType.BOOL.code -> if (frame.getBool(local)) ObjTrue else ObjFalse SlotType.BOOL.code -> if (frame.getBool(local)) ObjTrue else ObjFalse
SlotType.OBJ.code -> { SlotType.OBJ.code -> readLocalSlotValue(local)
val obj = frame.getObj(local) else -> readLocalSlotValue(local)
when (obj) {
is FrameSlotRef -> obj.read()
is RecordSlotRef -> obj.read()
else -> obj
} }
} }
else -> localSlotToObj(local)
fun storedSlotObj(slot: Int): Obj {
if (slot < fn.scopeSlotCount) {
val target = scopeTarget(slot)
val index = ensureScopeSlot(target, slot)
val record = target.getSlotRecord(index)
return when (val direct = record.value) {
is FrameSlotRef -> direct.read()
is RecordSlotRef -> direct.read()
is ScopeSlotRef -> direct.read()
else -> direct
}
}
val local = slot - fn.scopeSlotCount
return when (frame.getSlotTypeCode(local)) {
SlotType.INT.code -> ObjInt.of(frame.getInt(local))
SlotType.REAL.code -> ObjReal.of(frame.getReal(local))
SlotType.BOOL.code -> if (frame.getBool(local)) ObjTrue else ObjFalse
SlotType.OBJ.code, SlotType.UNKNOWN.code -> when (val raw = frame.getRawObj(local)) {
is FrameSlotRef -> raw.read()
is RecordSlotRef -> raw.read()
is ScopeSlotRef -> raw.read()
null -> ObjNull
else -> raw
}
else -> frame.getRawObj(local) ?: ObjNull
} }
} }
@@ -4766,7 +4856,8 @@ class CmdFrame(
} }
} }
private fun localSlotToObj(localIndex: Int): Obj { private suspend fun readLocalSlotValue(localIndex: Int): Obj {
val localName = fn.localSlotNames.getOrNull(localIndex)
return when (frame.getSlotTypeCode(localIndex)) { return when (frame.getSlotTypeCode(localIndex)) {
SlotType.INT.code -> ObjInt.of(frame.getInt(localIndex)) SlotType.INT.code -> ObjInt.of(frame.getInt(localIndex))
SlotType.REAL.code -> ObjReal.of(frame.getReal(localIndex)) SlotType.REAL.code -> ObjReal.of(frame.getReal(localIndex))
@@ -4775,7 +4866,9 @@ class CmdFrame(
val obj = frame.getObj(localIndex) val obj = frame.getObj(localIndex)
when (obj) { when (obj) {
is FrameSlotRef -> obj.read() is FrameSlotRef -> obj.read()
is RecordSlotRef -> obj.read() is RecordSlotRef -> obj.read(scope, localName)
is ObjProperty -> resolvePropertyLikeLocal(localName, obj)
ObjUnset -> resolveUnsetLocal(localName)
else -> obj else -> obj
} }
} }
@@ -4783,13 +4876,34 @@ class CmdFrame(
val obj = frame.getObj(localIndex) val obj = frame.getObj(localIndex)
when (obj) { when (obj) {
is FrameSlotRef -> obj.read() is FrameSlotRef -> obj.read()
is RecordSlotRef -> obj.read() is RecordSlotRef -> obj.read(scope, localName)
is ObjProperty -> resolvePropertyLikeLocal(localName, obj)
ObjUnset -> resolveUnsetLocal(localName)
else -> obj else -> obj
} }
} }
} }
} }
private suspend fun resolvePropertyLikeLocal(localName: String?, property: ObjProperty): Obj {
if (localName != null) {
val record = scope.parent?.get(localName) ?: scope.get(localName)
if (record != null && (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is ObjProperty)) {
return scope.resolve(record, localName)
}
}
return property.callGetter(scope, scope.thisObj)
}
private suspend fun resolveUnsetLocal(localName: String?): Obj {
if (localName == null) return ObjUnset
val record = scope.parent?.get(localName) ?: scope.get(localName) ?: return ObjUnset
if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is ObjProperty) {
return scope.resolve(record, localName)
}
return record.value
}
private suspend fun getScopeSlotValue(slot: Int): Obj { private suspend fun getScopeSlotValue(slot: Int): Obj {
val target = scopeTarget(slot) val target = scopeTarget(slot)
val name = fn.scopeSlotNames[slot] val name = fn.scopeSlotNames[slot]
@@ -4878,16 +4992,33 @@ class CmdFrame(
private suspend fun setScopeSlotValueAtAddr(addrSlot: Int, value: Obj) { private suspend fun setScopeSlotValueAtAddr(addrSlot: Int, value: Obj) {
val target = addrScopes[addrSlot] ?: error("Address slot $addrSlot is not resolved") val target = addrScopes[addrSlot] ?: error("Address slot $addrSlot is not resolved")
val index = addrIndices[addrSlot] val index = addrIndices[addrSlot]
val record = target.getSlotRecord(index)
val slotId = addrScopeSlots[addrSlot] val slotId = addrScopeSlots[addrSlot]
val name = fn.scopeSlotNames.getOrNull(slotId) val name = fn.scopeSlotNames.getOrNull(slotId)
if (name != null && (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is ObjProperty)) { val record = resolveScopeSlotRecordForWrite(target, index, name)
if (name != null && record != null && (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is ObjProperty)) {
target.assign(record, name, value) target.assign(record, name, value)
return return
} }
target.setSlotValue(index, value) target.setSlotValue(index, value)
} }
private fun resolveScopeSlotRecordForWrite(target: Scope, index: Int, name: String?): ObjRecord? {
val record = target.getSlotRecord(index)
if (name == null) return record
if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is ObjProperty) {
return record
}
if (record.value !== ObjUnset && record.memberName == null) {
return record
}
val resolved = target.get(name) ?: return record
if (resolved.value !== ObjUnset || resolved.type == ObjRecord.Type.Delegated || resolved.type == ObjRecord.Type.Property || resolved.value is ObjProperty) {
target.updateSlotFor(name, resolved)
return resolved
}
return record
}
internal fun ensureScopeSlot(target: Scope, slot: Int): Int { internal fun ensureScopeSlot(target: Scope, slot: Int): Int {
val name = fn.scopeSlotNames[slot] val name = fn.scopeSlotNames[slot]
if (name != null) { if (name != null) {
@@ -4941,8 +5072,12 @@ class CmdFrame(
if (hadNamedBinding) return if (hadNamedBinding) return
if (record.value !== ObjUnset) return if (record.value !== ObjUnset) return
if (fn.scopeSlotIsModule.getOrNull(slot) != true) return if (fn.scopeSlotIsModule.getOrNull(slot) != true) return
val pos = fn.scopeSlotRefPos.getOrNull(slot) ?: currentErrorPos() ?: ensureScope().pos
if (fn.scopeSlotRequiresPreparedBinding.getOrNull(slot) != true) {
throw ScriptError(pos, "symbol '$name' is not defined")
}
throw ScriptError( throw ScriptError(
ensureScope().pos, pos,
"module binding '$name' is not available in the execution scope; prepare the script imports/module bindings explicitly" "module binding '$name' is not available in the execution scope; prepare the script imports/module bindings explicitly"
) )
} }
@@ -31,7 +31,7 @@ internal suspend fun seedFrameLocalsFromScope(frame: CmdFrame, scope: Scope) {
val record = scope.getLocalRecordDirect(name) val record = scope.getLocalRecordDirect(name)
?: scope.chainLookupIgnoreClosure(name, followClosure = true) ?: scope.chainLookupIgnoreClosure(name, followClosure = true)
?: continue ?: continue
val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property) { val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is net.sergeych.lyng.obj.ObjProperty) {
scope.resolve(record, name) scope.resolve(record, name)
} else { } else {
record.value record.value
@@ -0,0 +1,152 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.matrix
internal data class MatrixData(
val rows: Int,
val cols: Int,
val values: DoubleArray
) {
init {
require(rows > 0) { "matrix must have at least one row" }
require(cols > 0) { "matrix must have at least one column" }
require(values.size == rows * cols) {
"matrix data size ${values.size} does not match shape ${rows}x${cols}"
}
}
val isSquare: Boolean get() = rows == cols
fun at(row: Int, col: Int): Double {
require(row in 0 until rows) { "row index $row out of bounds for $rows rows" }
require(col in 0 until cols) { "column index $col out of bounds for $cols columns" }
return values[row * cols + col]
}
fun rowValues(row: Int): DoubleArray {
require(row in 0 until rows) { "row index $row out of bounds for $rows rows" }
val start = row * cols
return values.copyOfRange(start, start + cols)
}
fun columnValues(col: Int): DoubleArray {
require(col in 0 until cols) { "column index $col out of bounds for $cols columns" }
return DoubleArray(rows) { row -> values[row * cols + col] }
}
fun slice(rowIndices: IntArray, colIndices: IntArray): MatrixData {
require(rowIndices.isNotEmpty()) { "matrix slice must include at least one row" }
require(colIndices.isNotEmpty()) { "matrix slice must include at least one column" }
val out = DoubleArray(rowIndices.size * colIndices.size)
var offset = 0
for (row in rowIndices) {
require(row in 0 until rows) { "row index $row out of bounds for $rows rows" }
val rowOffset = row * cols
for (col in colIndices) {
require(col in 0 until cols) { "column index $col out of bounds for $cols columns" }
out[offset++] = values[rowOffset + col]
}
}
return MatrixData(rowIndices.size, colIndices.size, out)
}
fun plus(other: MatrixData): MatrixData {
requireSameShape(other)
return MatrixData(rows, cols, DoubleArray(values.size) { index -> values[index] + other.values[index] })
}
fun minus(other: MatrixData): MatrixData {
requireSameShape(other)
return MatrixData(rows, cols, DoubleArray(values.size) { index -> values[index] - other.values[index] })
}
fun scale(factor: Double): MatrixData =
MatrixData(rows, cols, DoubleArray(values.size) { index -> values[index] * factor })
fun divide(divisor: Double): MatrixData {
require(divisor != 0.0) { "matrix division by zero" }
return MatrixData(rows, cols, DoubleArray(values.size) { index -> values[index] / divisor })
}
fun transpose(): MatrixData {
val out = DoubleArray(values.size)
for (row in 0 until rows) {
for (col in 0 until cols) {
out[col * rows + row] = values[row * cols + col]
}
}
return MatrixData(cols, rows, out)
}
fun multiply(other: MatrixData): MatrixData = PlatformMatrixBackend.multiply(this, other)
fun multiply(other: VectorData): VectorData = PureMatrixAlgorithms.multiply(this, other)
fun solve(other: VectorData): VectorData = PureMatrixAlgorithms.solve(this, other)
fun solve(other: MatrixData): MatrixData = PureMatrixAlgorithms.solve(this, other)
fun determinant(): Double = PureMatrixAlgorithms.determinant(this)
fun inverse(): MatrixData = PlatformMatrixBackend.inverse(this)
fun trace(): Double = PureMatrixAlgorithms.trace(this)
fun rank(): Int = PureMatrixAlgorithms.rank(this)
fun toNestedLists(): List<List<Double>> =
List(rows) { row ->
List(cols) { col -> values[row * cols + col] }
}
fun render(): String = buildString {
append("Matrix(")
append(rows)
append("x")
append(cols)
append(", [")
for (row in 0 until rows) {
if (row > 0) append(", ")
append("[")
for (col in 0 until cols) {
if (col > 0) append(", ")
append(formatMatrixValue(values[row * cols + col]))
}
append("]")
}
append("])")
}
fun compareTo(other: MatrixData): Int {
val rowCmp = rows.compareTo(other.rows)
if (rowCmp != 0) return rowCmp
val colCmp = cols.compareTo(other.cols)
if (colCmp != 0) return colCmp
for (index in values.indices) {
val cmp = values[index].compareTo(other.values[index])
if (cmp != 0) return cmp
}
return 0
}
private fun requireSameShape(other: MatrixData) {
require(rows == other.rows && cols == other.cols) {
"matrix shape mismatch: ${rows}x${cols} vs ${other.rows}x${other.cols}"
}
}
}
@@ -0,0 +1,30 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.matrix
import net.sergeych.lyng.obj.ObjReal
internal fun formatMatrixValue(value: Double): String {
if (value.isFinite()) {
val asLong = value.toLong()
if (asLong.toDouble() == value) {
return asLong.toString()
}
}
return ObjReal.of(value).toString()
}
@@ -0,0 +1,23 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.matrix
internal expect object PlatformMatrixBackend {
fun multiply(left: MatrixData, right: MatrixData): MatrixData
fun inverse(matrix: MatrixData): MatrixData
}
@@ -0,0 +1,286 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.matrix
internal object PureMatrixAlgorithms {
private const val singularEpsilon = 1e-12
fun multiply(left: MatrixData, right: MatrixData): MatrixData {
require(left.cols == right.rows) {
"matrix multiplication shape mismatch: ${left.rows}x${left.cols} cannot multiply ${right.rows}x${right.cols}"
}
val out = DoubleArray(left.rows * right.cols)
for (row in 0 until left.rows) {
val leftRowOffset = row * left.cols
val outRowOffset = row * right.cols
for (pivot in 0 until left.cols) {
val leftValue = left.values[leftRowOffset + pivot]
val rightRowOffset = pivot * right.cols
for (col in 0 until right.cols) {
out[outRowOffset + col] += leftValue * right.values[rightRowOffset + col]
}
}
}
return MatrixData(left.rows, right.cols, out)
}
fun multiply(left: MatrixData, right: VectorData): VectorData {
require(left.cols == right.size) {
"matrix-vector multiplication shape mismatch: ${left.rows}x${left.cols} cannot multiply length ${right.size}"
}
val out = DoubleArray(left.rows)
for (row in 0 until left.rows) {
var sum = 0.0
val rowOffset = row * left.cols
for (col in 0 until left.cols) {
sum += left.values[rowOffset + col] * right.values[col]
}
out[row] = sum
}
return VectorData(out)
}
fun inverse(matrix: MatrixData): MatrixData {
require(matrix.isSquare) { "matrix inverse requires a square matrix, got ${matrix.rows}x${matrix.cols}" }
val n = matrix.rows
val width = n * 2
val augmented = DoubleArray(n * width)
for (row in 0 until n) {
for (col in 0 until n) {
augmented[row * width + col] = matrix.values[row * n + col]
}
augmented[row * width + (n + row)] = 1.0
}
for (pivotCol in 0 until n) {
var pivotRow = pivotCol
var pivotAbs = kotlin.math.abs(augmented[pivotRow * width + pivotCol])
for (candidate in pivotCol + 1 until n) {
val candidateAbs = kotlin.math.abs(augmented[candidate * width + pivotCol])
if (candidateAbs > pivotAbs) {
pivotAbs = candidateAbs
pivotRow = candidate
}
}
require(pivotAbs > singularEpsilon) { "matrix is singular and cannot be inverted" }
if (pivotRow != pivotCol) {
swapRows(augmented, width, pivotRow, pivotCol)
}
val pivotValue = augmented[pivotCol * width + pivotCol]
val pivotOffset = pivotCol * width
for (col in 0 until width) {
augmented[pivotOffset + col] /= pivotValue
}
for (row in 0 until n) {
if (row == pivotCol) continue
val factor = augmented[row * width + pivotCol]
if (factor == 0.0) continue
val rowOffset = row * width
for (col in 0 until width) {
augmented[rowOffset + col] -= factor * augmented[pivotOffset + col]
}
}
}
val inverse = DoubleArray(n * n)
for (row in 0 until n) {
for (col in 0 until n) {
inverse[row * n + col] = augmented[row * width + n + col]
}
}
return MatrixData(n, n, inverse)
}
fun determinant(matrix: MatrixData): Double {
require(matrix.isSquare) { "matrix determinant requires a square matrix, got ${matrix.rows}x${matrix.cols}" }
val n = matrix.rows
val work = matrix.values.copyOf()
var sign = 1.0
var determinant = 1.0
for (pivotCol in 0 until n) {
var pivotRow = pivotCol
var pivotAbs = kotlin.math.abs(work[pivotRow * n + pivotCol])
for (candidate in pivotCol + 1 until n) {
val candidateAbs = kotlin.math.abs(work[candidate * n + pivotCol])
if (candidateAbs > pivotAbs) {
pivotAbs = candidateAbs
pivotRow = candidate
}
}
if (pivotAbs <= singularEpsilon) {
return 0.0
}
if (pivotRow != pivotCol) {
swapRows(work, n, pivotRow, pivotCol)
sign = -sign
}
val pivotValue = work[pivotCol * n + pivotCol]
determinant *= pivotValue
for (row in pivotCol + 1 until n) {
val rowOffset = row * n
val factor = work[rowOffset + pivotCol] / pivotValue
if (factor == 0.0) continue
for (col in pivotCol + 1 until n) {
work[rowOffset + col] -= factor * work[pivotCol * n + col]
}
}
}
return determinant * sign
}
fun trace(matrix: MatrixData): Double {
require(matrix.isSquare) { "matrix trace requires a square matrix, got ${matrix.rows}x${matrix.cols}" }
var sum = 0.0
for (index in 0 until matrix.rows) {
sum += matrix.values[index * matrix.cols + index]
}
return sum
}
fun rank(matrix: MatrixData): Int {
val work = matrix.values.copyOf()
var rank = 0
var pivotRow = 0
val rows = matrix.rows
val cols = matrix.cols
for (pivotCol in 0 until cols) {
var bestRow = -1
var bestAbs = singularEpsilon
for (candidate in pivotRow until rows) {
val absValue = kotlin.math.abs(work[candidate * cols + pivotCol])
if (absValue > bestAbs) {
bestAbs = absValue
bestRow = candidate
}
}
if (bestRow == -1) continue
if (bestRow != pivotRow) {
swapRows(work, cols, bestRow, pivotRow)
}
val pivotValue = work[pivotRow * cols + pivotCol]
for (row in pivotRow + 1 until rows) {
val factor = work[row * cols + pivotCol] / pivotValue
if (kotlin.math.abs(factor) <= singularEpsilon) continue
val rowOffset = row * cols
val pivotOffset = pivotRow * cols
for (col in pivotCol until cols) {
work[rowOffset + col] -= factor * work[pivotOffset + col]
}
}
rank += 1
pivotRow += 1
if (pivotRow == rows) break
}
return rank
}
fun solve(matrix: MatrixData, rhs: VectorData): VectorData {
require(matrix.isSquare) { "matrix solve requires a square matrix, got ${matrix.rows}x${matrix.cols}" }
require(matrix.rows == rhs.size) {
"matrix solve shape mismatch: ${matrix.rows}x${matrix.cols} cannot solve length ${rhs.size}"
}
val solution = solveAugmented(matrix.rows, matrix.cols, 1, matrix.values, rhs.values)
return VectorData(solution)
}
fun solve(matrix: MatrixData, rhs: MatrixData): MatrixData {
require(matrix.isSquare) { "matrix solve requires a square matrix, got ${matrix.rows}x${matrix.cols}" }
require(matrix.rows == rhs.rows) {
"matrix solve shape mismatch: ${matrix.rows}x${matrix.cols} cannot solve ${rhs.rows}x${rhs.cols}"
}
val solution = solveAugmented(matrix.rows, matrix.cols, rhs.cols, matrix.values, rhs.values)
return MatrixData(matrix.rows, rhs.cols, solution)
}
private fun solveAugmented(rows: Int, cols: Int, rhsCols: Int, matrixValues: DoubleArray, rhsValues: DoubleArray): DoubleArray {
val width = cols + rhsCols
val augmented = DoubleArray(rows * width)
for (row in 0 until rows) {
val matrixOffset = row * cols
val augmentedOffset = row * width
for (col in 0 until cols) {
augmented[augmentedOffset + col] = matrixValues[matrixOffset + col]
}
val rhsOffset = row * rhsCols
for (col in 0 until rhsCols) {
augmented[augmentedOffset + cols + col] = rhsValues[rhsOffset + col]
}
}
for (pivotCol in 0 until cols) {
var pivotRow = pivotCol
var pivotAbs = kotlin.math.abs(augmented[pivotRow * width + pivotCol])
for (candidate in pivotCol + 1 until rows) {
val candidateAbs = kotlin.math.abs(augmented[candidate * width + pivotCol])
if (candidateAbs > pivotAbs) {
pivotAbs = candidateAbs
pivotRow = candidate
}
}
require(pivotAbs > singularEpsilon) { "matrix is singular and cannot be solved" }
if (pivotRow != pivotCol) {
swapRows(augmented, width, pivotRow, pivotCol)
}
val pivotOffset = pivotCol * width
val pivotValue = augmented[pivotOffset + pivotCol]
for (col in pivotCol until width) {
augmented[pivotOffset + col] /= pivotValue
}
for (row in 0 until rows) {
if (row == pivotCol) continue
val factor = augmented[row * width + pivotCol]
if (kotlin.math.abs(factor) <= singularEpsilon) continue
val rowOffset = row * width
for (col in pivotCol until width) {
augmented[rowOffset + col] -= factor * augmented[pivotOffset + col]
}
}
}
val solution = DoubleArray(rows * rhsCols)
for (row in 0 until rows) {
val augmentedOffset = row * width + cols
val solutionOffset = row * rhsCols
for (col in 0 until rhsCols) {
solution[solutionOffset + col] = augmented[augmentedOffset + col]
}
}
return solution
}
private fun swapRows(data: DoubleArray, stride: Int, firstRow: Int, secondRow: Int) {
val firstOffset = firstRow * stride
val secondOffset = secondRow * stride
for (col in 0 until stride) {
val tmp = data[firstOffset + col]
data[firstOffset + col] = data[secondOffset + col]
data[secondOffset + col] = tmp
}
}
}
@@ -0,0 +1,113 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.matrix
import kotlin.math.sqrt
internal data class VectorData(
val values: DoubleArray
) {
init {
require(values.isNotEmpty()) { "vector must have at least one element" }
}
val size: Int get() = values.size
fun at(index: Int): Double {
require(index in values.indices) { "vector index $index out of bounds for length $size" }
return values[index]
}
fun plus(other: VectorData): VectorData {
require(size == other.size) { "vector size mismatch: $size vs ${other.size}" }
return VectorData(DoubleArray(size) { index -> values[index] + other.values[index] })
}
fun minus(other: VectorData): VectorData {
require(size == other.size) { "vector size mismatch: $size vs ${other.size}" }
return VectorData(DoubleArray(size) { index -> values[index] - other.values[index] })
}
fun scale(factor: Double): VectorData =
VectorData(DoubleArray(size) { index -> values[index] * factor })
fun divide(divisor: Double): VectorData {
require(divisor != 0.0) { "vector division by zero" }
return VectorData(DoubleArray(size) { index -> values[index] / divisor })
}
fun dot(other: VectorData): Double {
require(size == other.size) { "vector size mismatch: $size vs ${other.size}" }
var sum = 0.0
for (index in values.indices) {
sum += values[index] * other.values[index]
}
return sum
}
fun norm(): Double = sqrt(dot(this))
fun normalize(): VectorData {
val length = norm()
require(length != 0.0) { "cannot normalize a zero vector" }
return divide(length)
}
fun cross(other: VectorData): VectorData {
require(size == 3 && other.size == 3) { "cross product requires two 3D vectors" }
return VectorData(
doubleArrayOf(
values[1] * other.values[2] - values[2] * other.values[1],
values[2] * other.values[0] - values[0] * other.values[2],
values[0] * other.values[1] - values[1] * other.values[0]
)
)
}
fun outer(other: VectorData): MatrixData {
val out = DoubleArray(size * other.size)
for (row in values.indices) {
val rowOffset = row * other.size
for (col in other.values.indices) {
out[rowOffset + col] = values[row] * other.values[col]
}
}
return MatrixData(size, other.size, out)
}
fun toList(): List<Double> = values.asList()
fun render(): String = buildString {
append("Vector([")
for (index in values.indices) {
if (index > 0) append(", ")
append(formatMatrixValue(values[index]))
}
append("])")
}
fun compareTo(other: VectorData): Int {
val sizeCmp = size.compareTo(other.size)
if (sizeCmp != 0) return sizeCmp
for (index in values.indices) {
val cmp = values[index].compareTo(other.values[index])
if (cmp != 0) return cmp
}
return 0
}
}
@@ -448,37 +448,37 @@ private fun buildStdlibDocs(): List<MiniDecl> {
// Math helpers (scalar versions) // Math helpers (scalar versions)
fun math1(name: String) = mod.funDoc( fun math1(name: String) = mod.funDoc(
name = name, name = name,
doc = StdlibInlineDocIndex.topFunDoc(name) ?: "Compute $name(x).", doc = StdlibInlineDocIndex.topFunDoc(name) ?: "Compute $name(x). Accepts Int, Real, and Decimal. Decimal currently uses a temporary Real bridge and will get native decimal implementations later.",
params = listOf(ParamDoc("x", type("lyng.Number"))) params = listOf(ParamDoc("x", type("lyng.Number")))
) )
math1("sin"); math1("cos"); math1("tan"); math1("asin"); math1("acos"); math1("atan") math1("sin"); math1("cos"); math1("tan"); math1("asin"); math1("acos"); math1("atan")
mod.funDoc(name = "floor", doc = StdlibInlineDocIndex.topFunDoc("floor") ?: "Round down the number to the nearest integer.", params = listOf(ParamDoc("x", type("lyng.Number")))) mod.funDoc(name = "floor", doc = StdlibInlineDocIndex.topFunDoc("floor") ?: "Round down the number to the nearest integer. Decimal is handled directly and stays Decimal.", params = listOf(ParamDoc("x", type("lyng.Number"))))
mod.funDoc(name = "ceil", doc = StdlibInlineDocIndex.topFunDoc("ceil") ?: "Round up the number to the nearest integer.", params = listOf(ParamDoc("x", type("lyng.Number")))) mod.funDoc(name = "ceil", doc = StdlibInlineDocIndex.topFunDoc("ceil") ?: "Round up the number to the nearest integer. Decimal is handled directly and stays Decimal.", params = listOf(ParamDoc("x", type("lyng.Number"))))
mod.funDoc(name = "round", doc = StdlibInlineDocIndex.topFunDoc("round") ?: "Round the number to the nearest integer.", params = listOf(ParamDoc("x", type("lyng.Number")))) mod.funDoc(name = "round", doc = StdlibInlineDocIndex.topFunDoc("round") ?: "Round the number to the nearest integer. Decimal is handled directly and stays Decimal.", params = listOf(ParamDoc("x", type("lyng.Number"))))
// Hyperbolic and inverse hyperbolic // Hyperbolic and inverse hyperbolic
math1("sinh"); math1("cosh"); math1("tanh"); math1("asinh"); math1("acosh"); math1("atanh") math1("sinh"); math1("cosh"); math1("tanh"); math1("asinh"); math1("acosh"); math1("atanh")
// Exponentials and logarithms // Exponentials and logarithms
mod.funDoc(name = "exp", doc = StdlibInlineDocIndex.topFunDoc("exp") ?: "Euler's exponential e^x.", params = listOf(ParamDoc("x", type("lyng.Number")))) mod.funDoc(name = "exp", doc = StdlibInlineDocIndex.topFunDoc("exp") ?: "Euler's exponential e^x. Decimal currently uses a temporary Real bridge and will get a native decimal implementation later.", params = listOf(ParamDoc("x", type("lyng.Number"))))
mod.funDoc(name = "ln", doc = StdlibInlineDocIndex.topFunDoc("ln") ?: "Natural logarithm (base e).", params = listOf(ParamDoc("x", type("lyng.Number")))) mod.funDoc(name = "ln", doc = StdlibInlineDocIndex.topFunDoc("ln") ?: "Natural logarithm (base e). Decimal currently uses a temporary Real bridge and will get a native decimal implementation later.", params = listOf(ParamDoc("x", type("lyng.Number"))))
mod.funDoc(name = "log10", doc = StdlibInlineDocIndex.topFunDoc("log10") ?: "Logarithm base 10.", params = listOf(ParamDoc("x", type("lyng.Number")))) mod.funDoc(name = "log10", doc = StdlibInlineDocIndex.topFunDoc("log10") ?: "Logarithm base 10. Decimal currently uses a temporary Real bridge and will get a native decimal implementation later.", params = listOf(ParamDoc("x", type("lyng.Number"))))
mod.funDoc(name = "log2", doc = StdlibInlineDocIndex.topFunDoc("log2") ?: "Logarithm base 2.", params = listOf(ParamDoc("x", type("lyng.Number")))) mod.funDoc(name = "log2", doc = StdlibInlineDocIndex.topFunDoc("log2") ?: "Logarithm base 2. Decimal currently uses a temporary Real bridge and will get a native decimal implementation later.", params = listOf(ParamDoc("x", type("lyng.Number"))))
// Power/roots and absolute value // Power/roots and absolute value
mod.funDoc( mod.funDoc(
name = "pow", name = "pow",
doc = StdlibInlineDocIndex.topFunDoc("pow") ?: "Raise `x` to the power `y`.", doc = StdlibInlineDocIndex.topFunDoc("pow") ?: "Raise `x` to the power `y`. Decimal with integral `y` is handled directly; other Decimal cases currently use a temporary Real bridge.",
params = listOf(ParamDoc("x", type("lyng.Number")), ParamDoc("y", type("lyng.Number"))) params = listOf(ParamDoc("x", type("lyng.Number")), ParamDoc("y", type("lyng.Number")))
) )
mod.funDoc( mod.funDoc(
name = "sqrt", name = "sqrt",
doc = StdlibInlineDocIndex.topFunDoc("sqrt") ?: "Square root of `x`.", doc = StdlibInlineDocIndex.topFunDoc("sqrt") ?: "Square root of `x`. Decimal currently uses a temporary Real bridge and will get a native decimal implementation later.",
params = listOf(ParamDoc("x", type("lyng.Number"))) params = listOf(ParamDoc("x", type("lyng.Number")))
) )
mod.funDoc( mod.funDoc(
name = "abs", name = "abs",
doc = StdlibInlineDocIndex.topFunDoc("abs") ?: "Absolute value of a number (works for Int and Real).", doc = StdlibInlineDocIndex.topFunDoc("abs") ?: "Absolute value of a number. Int stays Int, and Decimal stays Decimal.",
params = listOf(ParamDoc("x", type("lyng.Number"))) params = listOf(ParamDoc("x", type("lyng.Number")))
) )
@@ -540,7 +540,8 @@ private fun buildStdlibDocs(): List<MiniDecl> {
// Concurrency helpers // Concurrency helpers
mod.classDoc(name = "Deferred", doc = "Represents a value that will be available in the future.", bases = listOf(type("Obj"))) { mod.classDoc(name = "Deferred", doc = "Represents a value that will be available in the future.", bases = listOf(type("Obj"))) {
method(name = "await", doc = "Suspend until the value is available and return it.") method(name = "cancel", doc = "Cancel the deferred if it is still active.")
method(name = "await", doc = "Suspend until the value is available and return it. Throws `CancellationException` if cancelled.")
} }
mod.funDoc( mod.funDoc(
name = "launch", name = "launch",
@@ -591,11 +591,14 @@ open class Obj {
return obj.copy(value = res, type = ObjRecord.Type.Other) return obj.copy(value = res, type = ObjRecord.Type.Other)
} }
val value = obj.value val value = obj.value
if (value is ObjProperty || obj.type == ObjRecord.Type.Property) { if (value is ObjProperty) {
val prop = (value as? ObjProperty) val res = value.callGetter(scope, this, decl)
?: scope.raiseError("Expected ObjProperty for property member $name, got ${value::class}") return obj.copy(value = res, type = ObjRecord.Type.Other)
val res = prop.callGetter(scope, this, decl) }
return ObjRecord(res, obj.isMutable) if (obj.type == ObjRecord.Type.Property) {
// Some runtime paths cache the resolved property value back into the record.
// Treat that as an already-resolved read result instead of trying to call a getter again.
return obj.copy(type = ObjRecord.Type.Other)
} }
val caller = scope.currentClassCtx val caller = scope.currentClassCtx
// Check visibility for non-property members here if they weren't checked before // Check visibility for non-property members here if they weren't checked before
@@ -1076,6 +1079,7 @@ interface Numeric {
fun Obj.toDouble(): Double = fun Obj.toDouble(): Double =
(this as? Numeric)?.doubleValue (this as? Numeric)?.doubleValue
?: ObjDecimalSupport.toDoubleOrNull(this)
?: (this as? ObjString)?.value?.toDouble() ?: (this as? ObjString)?.value?.toDouble()
?: throw IllegalArgumentException("cannot convert to double $this") ?: throw IllegalArgumentException("cannot convert to double $this")
@@ -1180,8 +1180,11 @@ open class ObjClass(
scope: Scope, name: String, args: Arguments, scope: Scope, name: String, args: Arguments,
onNotFoundResult: (suspend () -> Obj?)? onNotFoundResult: (suspend () -> Obj?)?
): Obj { ): Obj {
getInstanceMemberOrNull(name)?.let { rec -> classScope?.objects?.get(name)?.let { rec ->
val decl = rec.declaringClass ?: findDeclaringClassOf(name) ?: this val decl = rec.declaringClass ?: this
if (!rec.visibility.isPublic) {
return super.invokeInstanceMethod(scope, name, args, onNotFoundResult)
}
if (rec.type == ObjRecord.Type.Delegated) { if (rec.type == ObjRecord.Type.Delegated) {
val del = rec.delegate ?: scope.raiseError("Internal error: delegated member $name has no delegate") val del = rec.delegate ?: scope.raiseError("Internal error: delegated member $name has no delegate")
val allArgs = (listOf(this, ObjString(name)) + args.list).toTypedArray() val allArgs = (listOf(this, ObjString(name)) + args.list).toTypedArray()
@@ -0,0 +1,125 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.obj
import net.sergeych.lyng.*
import net.sergeych.lyng.miniast.addPropertyDoc
import net.sergeych.lyng.miniast.type
import net.sergeych.lyng.requiredArg
object ObjComplexSupport {
private object BoundMarker
private val complexTypeDecl = TypeDecl.Simple("lyng.complex.Complex", false)
suspend fun bindTo(module: ModuleScope) {
val complexClass = module.requireClass("Complex")
if (complexClass.kotlinClassData === BoundMarker) return
complexClass.kotlinClassData = BoundMarker
val decimalModule = module.currentImportProvider.createModuleScope(module.pos, "lyng.decimal")
val decimalClass = decimalModule.requireClass("Decimal")
decimalClass.addPropertyDoc(
name = "re",
doc = "Convert this Decimal to a Complex with zero imaginary part.",
type = type("lyng.complex.Complex"),
moduleName = "lyng.complex",
getter = {
newComplex(
complexClass,
decimalToReal(thisObj),
0.0
)
}
)
decimalClass.members["re"] = decimalClass.members.getValue("re").copy(typeDecl = complexTypeDecl)
decimalClass.addPropertyDoc(
name = "i",
doc = "Convert this Decimal to a pure imaginary Complex after rounding to Real.",
type = type("lyng.complex.Complex"),
moduleName = "lyng.complex",
getter = {
newComplex(
complexClass,
0.0,
decimalToReal(thisObj)
)
}
)
decimalClass.members["i"] = decimalClass.members.getValue("i").copy(typeDecl = complexTypeDecl)
OperatorInteropRegistry.register(
leftClass = decimalClass,
rightClass = complexClass,
commonClass = complexClass,
operatorNames = listOf(
InteropOperator.Plus.name,
InteropOperator.Minus.name,
InteropOperator.Mul.name,
InteropOperator.Div.name
),
leftToCommon = ObjExternCallable.fromBridge {
newComplex(
complexClass,
decimalToReal(requiredArg(0)),
0.0
)
},
rightToCommon = ObjExternCallable.fromBridge {
requiredArg<Obj>(0)
}
)
}
internal suspend fun decimalBinary(scope: ScopeFacade, decimal: Obj, other: Obj, operator: InteropOperator): Obj? {
val left = ObjDecimalSupport.toDoubleOrNull(decimal) ?: return null
val complex = other as? ObjInstance ?: return null
if (complex.objClass.className != "Complex") return null
val otherReal = complex.readField(scope.requireScope(), "real").value.toDouble()
val otherImag = complex.readField(scope.requireScope(), "imag").value.toDouble()
return when (operator) {
InteropOperator.Plus -> instantiateComplex(scope, complex.objClass, left + otherReal, otherImag)
InteropOperator.Minus -> instantiateComplex(scope, complex.objClass, left - otherReal, -otherImag)
InteropOperator.Mul -> instantiateComplex(scope, complex.objClass, left * otherReal, left * otherImag)
InteropOperator.Div -> {
val denominator = otherReal * otherReal + otherImag * otherImag
instantiateComplex(scope, complex.objClass, left * otherReal / denominator, -left * otherImag / denominator)
}
else -> null
}
}
private suspend fun ScopeFacade.newComplex(complexClass: ObjClass, real: Double, imag: Double): ObjInstance =
instantiateComplex(this, complexClass, real, imag)
private suspend fun instantiateComplex(scope: ScopeFacade, complexClass: ObjClass, real: Double, imag: Double): ObjInstance {
val runtimeScope = scope.requireScope()
val instance = complexClass.createInstance(runtimeScope)
complexClass.initializeInstance(
instance,
Arguments(ObjReal.of(real), ObjReal.of(imag)),
runConstructors = false
)
return instance
}
private fun ScopeFacade.decimalToReal(value: Obj): Double =
ObjDecimalSupport.toDoubleOrNull(value)
?: raiseClassCastError("expected Decimal-compatible value, got ${value.objClass.className}")
}
@@ -17,33 +17,25 @@
package net.sergeych.lyng.obj package net.sergeych.lyng.obj
import com.ionspin.kotlin.bignum.decimal.BigDecimal as IonBigDecimal
import com.ionspin.kotlin.bignum.decimal.DecimalMode import com.ionspin.kotlin.bignum.decimal.DecimalMode
import com.ionspin.kotlin.bignum.decimal.RoundingMode import com.ionspin.kotlin.bignum.decimal.RoundingMode
import com.ionspin.kotlin.bignum.integer.BigInteger import com.ionspin.kotlin.bignum.integer.BigInteger
import net.sergeych.lyng.Arguments import net.sergeych.lyng.*
import net.sergeych.lyng.FrameSlotRef
import net.sergeych.lyng.InteropOperator
import net.sergeych.lyng.ModuleScope
import net.sergeych.lyng.OperatorInteropRegistry
import net.sergeych.lyng.RecordSlotRef
import net.sergeych.lyng.Scope
import net.sergeych.lyng.ScopeFacade
import net.sergeych.lyng.TypeDecl
import net.sergeych.lyng.miniast.addPropertyDoc import net.sergeych.lyng.miniast.addPropertyDoc
import net.sergeych.lyng.miniast.type import net.sergeych.lyng.miniast.type
import net.sergeych.lyng.requiredArg import net.sergeych.lyng.requiredArg
import com.ionspin.kotlin.bignum.decimal.BigDecimal as IonBigDecimal
object ObjBigDecimalSupport { object ObjDecimalSupport {
private const val decimalContextVar = "__lyng_decimal_context__" private const val decimalContextVar = "__lyng_decimal_context__"
// For Real -> BigDecimal, preserve the actual IEEE-754 Double value using a // For Real -> Decimal, preserve the actual IEEE-754 Double value using a
// round-trip-safe precision. This intentionally does not try to recover source text. // round-trip-safe precision. This intentionally does not try to recover source text.
private val realConversionMode = DecimalMode(17L, RoundingMode.ROUND_HALF_TO_EVEN) private val realConversionMode = DecimalMode(17L, RoundingMode.ROUND_HALF_TO_EVEN)
// Division needs an explicit stopping rule for non-terminating results. Use a // Division needs an explicit stopping rule for non-terminating results. Use a
// decimal128-like default context until Lyng exposes per-operation contexts. // decimal128-like default context until Lyng exposes per-operation contexts.
private val defaultDivisionMode = DecimalMode(34L, RoundingMode.ROUND_HALF_TO_EVEN) private val defaultDivisionMode = DecimalMode(34L, RoundingMode.ROUND_HALF_TO_EVEN)
private val zero: IonBigDecimal = IonBigDecimal.ZERO private val zero: IonBigDecimal = IonBigDecimal.ZERO
private val decimalTypeDecl = TypeDecl.Simple("lyng.decimal.BigDecimal", false) private val decimalTypeDecl = TypeDecl.Simple("lyng.decimal.Decimal", false)
private object BoundMarker private object BoundMarker
private data class DecimalRuntimeContext( private data class DecimalRuntimeContext(
val precision: Long, val precision: Long,
@@ -51,7 +43,7 @@ object ObjBigDecimalSupport {
) : Obj() ) : Obj()
suspend fun bindTo(module: ModuleScope) { suspend fun bindTo(module: ModuleScope) {
val decimalClass = module.requireClass("BigDecimal") val decimalClass = module.requireClass("Decimal")
if (decimalClass.kotlinClassData === BoundMarker) return if (decimalClass.kotlinClassData === BoundMarker) return
decimalClass.kotlinClassData = BoundMarker decimalClass.kotlinClassData = BoundMarker
decimalClass.isAbstract = false decimalClass.isAbstract = false
@@ -62,22 +54,36 @@ object ObjBigDecimalSupport {
instance.kotlinInstanceData = zero instance.kotlinInstanceData = zero
} }
decimalClass.addFn("plus") { decimalClass.addFn("plus") {
newInstance(decimalClass, valueOf(thisObj).plus(coerceArg(requireScope(), args.firstAndOnly()))) mixedRealDecimalArithmeticFallback(thisObj, args.firstAndOnly(), InteropOperator.Plus)
?: ObjComplexSupport.decimalBinary(this, thisObj, args.firstAndOnly(), InteropOperator.Plus)
?: OperatorInteropRegistry.invokeBinary(requireScope(), thisObj, args.firstAndOnly(), InteropOperator.Plus)
?: newInstance(decimalClass, valueOf(thisObj).plus(coerceArg(requireScope(), args.firstAndOnly())))
} }
decimalClass.addFn("minus") { decimalClass.addFn("minus") {
newInstance(decimalClass, valueOf(thisObj).minus(coerceArg(requireScope(), args.firstAndOnly()))) mixedRealDecimalArithmeticFallback(thisObj, args.firstAndOnly(), InteropOperator.Minus)
?: ObjComplexSupport.decimalBinary(this, thisObj, args.firstAndOnly(), InteropOperator.Minus)
?: OperatorInteropRegistry.invokeBinary(requireScope(), thisObj, args.firstAndOnly(), InteropOperator.Minus)
?: newInstance(decimalClass, valueOf(thisObj).minus(coerceArg(requireScope(), args.firstAndOnly())))
} }
decimalClass.addFn("mul") { decimalClass.addFn("mul") {
newInstance(decimalClass, valueOf(thisObj).times(coerceArg(requireScope(), args.firstAndOnly()))) mixedRealDecimalArithmeticFallback(thisObj, args.firstAndOnly(), InteropOperator.Mul)
?: ObjComplexSupport.decimalBinary(this, thisObj, args.firstAndOnly(), InteropOperator.Mul)
?: OperatorInteropRegistry.invokeBinary(requireScope(), thisObj, args.firstAndOnly(), InteropOperator.Mul)
?: newInstance(decimalClass, valueOf(thisObj).times(coerceArg(requireScope(), args.firstAndOnly())))
} }
decimalClass.addFn("div") { decimalClass.addFn("div") {
newInstance(decimalClass, divideWithContext(valueOf(thisObj), coerceArg(requireScope(), args.firstAndOnly()), currentDivisionMode(requireScope()))) mixedRealDecimalArithmeticFallback(thisObj, args.firstAndOnly(), InteropOperator.Div)
?: ObjComplexSupport.decimalBinary(this, thisObj, args.firstAndOnly(), InteropOperator.Div)
?: OperatorInteropRegistry.invokeBinary(requireScope(), thisObj, args.firstAndOnly(), InteropOperator.Div)
?: newInstance(decimalClass, divideWithContext(valueOf(thisObj), coerceArg(requireScope(), args.firstAndOnly()), currentDivisionMode(requireScope())))
} }
decimalClass.addFn("mod") { decimalClass.addFn("mod") {
newInstance(decimalClass, valueOf(thisObj).rem(coerceArg(requireScope(), args.firstAndOnly()))) mixedRealDecimalArithmeticFallback(thisObj, args.firstAndOnly(), InteropOperator.Mod)
?: newInstance(decimalClass, valueOf(thisObj).rem(coerceArg(requireScope(), args.firstAndOnly())))
} }
decimalClass.addFn("compareTo") { decimalClass.addFn("compareTo") {
ObjInt.of(valueOf(thisObj).compareTo(coerceArg(requireScope(), args.firstAndOnly())).toLong()) mixedRealDecimalCompareFallback(thisObj, args.firstAndOnly())?.toObj()
?: ObjInt.of(valueOf(thisObj).compareTo(coerceArg(requireScope(), args.firstAndOnly())).toLong())
} }
decimalClass.addFn("negate") { decimalClass.addFn("negate") {
newInstance(decimalClass, valueOf(thisObj).unaryMinus()) newInstance(decimalClass, valueOf(thisObj).unaryMinus())
@@ -88,23 +94,32 @@ object ObjBigDecimalSupport {
decimalClass.addFn("toReal") { decimalClass.addFn("toReal") {
ObjReal.of(valueOf(thisObj).doubleValue(false)) ObjReal.of(valueOf(thisObj).doubleValue(false))
} }
decimalClass.addFn("isInfinite") {
ObjFalse
}
decimalClass.addFn("isNaN") {
ObjFalse
}
decimalClass.addFn("toString") {
ObjString(valueOf(thisObj).toStringExpanded())
}
decimalClass.addFn("toStringExpanded") { decimalClass.addFn("toStringExpanded") {
ObjString(valueOf(thisObj).toStringExpanded()) ObjString(valueOf(thisObj).toStringExpanded())
} }
decimalClass.addClassFn("fromInt") { decimalClass.addClassFn("fromInt") {
val value = requiredArg<ObjInt>(0).value val value = requiredArg<ObjInt>(0).value
newInstance(decimalClass, IonBigDecimal.fromLongAsSignificand(value)) newInstance(decimalClass, IonBigDecimal.fromLong(value))
} }
decimalClass.addClassFn("fromReal") { decimalClass.addClassFn("fromReal") {
val value = requiredArg<ObjReal>(0).value val value = requiredArg<ObjReal>(0).value
newInstance(decimalClass, IonBigDecimal.fromDouble(value, realConversionMode)) newInstanceFromFiniteReal(decimalClass, value)
} }
decimalClass.addClassFn("fromString") { decimalClass.addClassFn("fromString") {
val value = requiredArg<ObjString>(0).value val value = requiredArg<ObjString>(0).value
try { try {
newInstance(decimalClass, IonBigDecimal.parseStringWithMode(value)) newInstance(decimalClass, IonBigDecimal.parseStringWithMode(value))
} catch (e: Throwable) { } catch (e: Throwable) {
requireScope().raiseIllegalArgument("invalid BigDecimal string: $value") requireScope().raiseIllegalArgument("invalid Decimal string: $value")
} }
} }
module.addFn("withDecimalContext") { module.addFn("withDecimalContext") {
@@ -133,8 +148,68 @@ object ObjBigDecimalSupport {
registerInterop(decimalClass) registerInterop(decimalClass)
} }
fun isDecimalValue(value: Obj): Boolean =
value is ObjInstance && value.objClass.className == "Decimal"
suspend fun exactAbs(scope: ScopeFacade, value: Obj): Obj? =
decimalValueOrNull(value)?.let { scope.newInstanceLikeDecimal(value, it.abs()) }
suspend fun exactFloor(scope: ScopeFacade, value: Obj): Obj? =
decimalValueOrNull(value)?.let { scope.newInstanceLikeDecimal(value, it.floor()) }
suspend fun exactCeil(scope: ScopeFacade, value: Obj): Obj? =
decimalValueOrNull(value)?.let { scope.newInstanceLikeDecimal(value, it.ceil()) }
suspend fun exactRound(scope: ScopeFacade, value: Obj): Obj? =
decimalValueOrNull(value)?.let {
scope.newInstanceLikeDecimal(value, it.roundToDigitPositionAfterDecimalPoint(0, RoundingMode.ROUND_HALF_CEILING))
}
suspend fun exactPow(scope: ScopeFacade, base: Obj, exponent: Obj): Obj? {
val decimal = decimalValueOrNull(base) ?: return null
val intExponent = exponent as? ObjInt ?: return null
return scope.newInstanceLikeDecimal(base, decimal.pow(intExponent.value))
}
suspend fun fromRealLike(scope: ScopeFacade, sample: Obj, value: Double): Obj? {
if (!isDecimalValue(sample)) return null
if (!value.isFinite()) return ObjReal.of(value)
return scope.newInstanceLikeDecimal(sample, IonBigDecimal.fromDouble(value, realConversionMode))
}
fun toDoubleOrNull(value: Obj): Double? =
decimalValueOrNull(value)?.doubleValue(false)
internal fun mixedRealDecimalArithmeticFallback(left: Obj, right: Obj, operator: InteropOperator): Obj? {
if (!isMixedRealDecimal(left, right)) return null
val leftDouble = numericDoubleOrNull(left) ?: return null
val rightDouble = numericDoubleOrNull(right) ?: return null
val result = when (operator) {
InteropOperator.Plus -> leftDouble + rightDouble
InteropOperator.Minus -> leftDouble - rightDouble
InteropOperator.Mul -> leftDouble * rightDouble
InteropOperator.Div -> leftDouble / rightDouble
InteropOperator.Mod -> leftDouble % rightDouble
else -> return null
}
return if (result.isFinite()) null else ObjReal.of(result)
}
internal fun mixedRealDecimalCompareFallback(left: Obj, right: Obj): Int? {
if (!isMixedRealDecimal(left, right)) return null
val leftDouble = numericDoubleOrNull(left) ?: return null
val rightDouble = numericDoubleOrNull(right) ?: return null
return if (leftDouble.isFinite() && rightDouble.isFinite()) null else leftDouble.compareTo(rightDouble)
}
suspend fun newDecimal(scope: ScopeFacade, value: IonBigDecimal): ObjInstance {
val decimalModule = scope.requireScope().currentImportProvider.createModuleScope(scope.pos, "lyng.decimal")
val decimalClass = decimalModule.requireClass("Decimal")
return scope.newInstance(decimalClass, value)
}
private fun valueOf(obj: Obj): IonBigDecimal { private fun valueOf(obj: Obj): IonBigDecimal {
val instance = obj as? ObjInstance ?: error("BigDecimal receiver must be an object instance") val instance = obj as? ObjInstance ?: error("Decimal receiver must be an object instance")
return instance.kotlinInstanceData as? IonBigDecimal ?: zero return instance.kotlinInstanceData as? IonBigDecimal ?: zero
} }
@@ -160,21 +235,39 @@ object ObjBigDecimalSupport {
private suspend fun ScopeFacade.newInstance(decimalClass: ObjClass, value: IonBigDecimal): ObjInstance { private suspend fun ScopeFacade.newInstance(decimalClass: ObjClass, value: IonBigDecimal): ObjInstance {
val instance = call(decimalClass) as? ObjInstance val instance = call(decimalClass) as? ObjInstance
?: raiseIllegalState("BigDecimal() did not return an object instance") ?: raiseIllegalState("Decimal() did not return an object instance")
instance.kotlinInstanceData = value instance.kotlinInstanceData = value
return instance return instance
} }
private suspend fun ScopeFacade.newInstanceFromFiniteReal(decimalClass: ObjClass, value: Double): ObjInstance {
if (!value.isFinite()) {
requireScope().raiseIllegalArgument("cannot convert non-finite Real to Decimal: $value")
}
return newInstance(decimalClass, IonBigDecimal.fromDouble(value, realConversionMode))
}
private suspend fun ScopeFacade.newInstanceLikeDecimal(sample: Obj, value: IonBigDecimal): ObjInstance {
val decimalClass = (sample as? ObjInstance)?.objClass
?: raiseIllegalState("Decimal sample must be an object instance")
return newInstance(decimalClass, value)
}
private fun coerceArg(scope: Scope, value: Obj): IonBigDecimal = when (value) { private fun coerceArg(scope: Scope, value: Obj): IonBigDecimal = when (value) {
is ObjInt -> IonBigDecimal.fromLongAsSignificand(value.value) is ObjInt -> IonBigDecimal.fromLong(value.value)
is ObjReal -> IonBigDecimal.fromDouble(value.value, realConversionMode) is ObjReal -> {
if (!value.value.isFinite()) {
scope.raiseIllegalArgument("cannot convert non-finite Real to Decimal: ${value.value}")
}
IonBigDecimal.fromDouble(value.value, realConversionMode)
}
is ObjInstance -> { is ObjInstance -> {
if (value.objClass.className != "BigDecimal") { if (value.objClass.className != "Decimal") {
scope.raiseIllegalArgument("expected BigDecimal-compatible value, got ${value.objClass.className}") scope.raiseIllegalArgument("expected Decimal-compatible value, got ${value.objClass.className}")
} }
value.kotlinInstanceData as? IonBigDecimal ?: zero value.kotlinInstanceData as? IonBigDecimal ?: zero
} }
else -> scope.raiseIllegalArgument("expected BigDecimal-compatible value, got ${value.objClass.className}") else -> scope.raiseIllegalArgument("expected Decimal-compatible value, got ${value.objClass.className}")
} }
private suspend fun normalizeContext(scope: Scope, value: Obj): DecimalRuntimeContext { private suspend fun normalizeContext(scope: Scope, value: Obj): DecimalRuntimeContext {
@@ -253,34 +346,40 @@ object ObjBigDecimalSupport {
} }
} }
private fun decimalValueOrNull(value: Obj): IonBigDecimal? {
if (!isDecimalValue(value)) return null
val instance = value as ObjInstance
return instance.kotlinInstanceData as? IonBigDecimal ?: zero
}
private fun registerBuiltinConversions(decimalClass: ObjClass) { private fun registerBuiltinConversions(decimalClass: ObjClass) {
ObjInt.type.addPropertyDoc( ObjInt.type.addPropertyDoc(
name = "d", name = "d",
doc = "Convert this integer to a BigDecimal.", doc = "Convert this integer to a Decimal.",
type = type("lyng.decimal.BigDecimal"), type = type("lyng.decimal.Decimal"),
moduleName = "lyng.decimal", moduleName = "lyng.decimal",
getter = { newInstance(decimalClass, IonBigDecimal.fromLongAsSignificand(thisAs<ObjInt>().value)) } getter = { newInstance(decimalClass, IonBigDecimal.fromLong(thisAs<ObjInt>().value)) }
) )
ObjInt.type.members["d"] = ObjInt.type.members.getValue("d").copy(typeDecl = decimalTypeDecl) ObjInt.type.members["d"] = ObjInt.type.members.getValue("d").copy(typeDecl = decimalTypeDecl)
ObjReal.type.addPropertyDoc( ObjReal.type.addPropertyDoc(
name = "d", name = "d",
doc = "Convert this real number to a BigDecimal by preserving the current IEEE-754 value with 17 significant digits and half-even rounding.", doc = "Convert this real number to a Decimal by preserving the current IEEE-754 value with 17 significant digits and half-even rounding.",
type = type("lyng.decimal.BigDecimal"), type = type("lyng.decimal.Decimal"),
moduleName = "lyng.decimal", moduleName = "lyng.decimal",
getter = { newInstance(decimalClass, IonBigDecimal.fromDouble(thisAs<ObjReal>().value, realConversionMode)) } getter = { newInstanceFromFiniteReal(decimalClass, thisAs<ObjReal>().value) }
) )
ObjReal.type.members["d"] = ObjReal.type.members.getValue("d").copy(typeDecl = decimalTypeDecl) ObjReal.type.members["d"] = ObjReal.type.members.getValue("d").copy(typeDecl = decimalTypeDecl)
ObjString.type.addPropertyDoc( ObjString.type.addPropertyDoc(
name = "d", name = "d",
doc = "Parse this string as a BigDecimal.", doc = "Parse this string as a Decimal.",
type = type("lyng.decimal.BigDecimal"), type = type("lyng.decimal.Decimal"),
moduleName = "lyng.decimal", moduleName = "lyng.decimal",
getter = { getter = {
val value = thisAs<ObjString>().value val value = thisAs<ObjString>().value
try { try {
newInstance(decimalClass, IonBigDecimal.parseStringWithMode(value)) newInstance(decimalClass, IonBigDecimal.parseStringWithMode(value))
} catch (e: Throwable) { } catch (e: Throwable) {
requireScope().raiseIllegalArgument("invalid BigDecimal string: $value") requireScope().raiseIllegalArgument("invalid Decimal string: $value")
} }
} }
) )
@@ -288,11 +387,10 @@ object ObjBigDecimalSupport {
} }
private fun registerInterop(decimalClass: ObjClass) { private fun registerInterop(decimalClass: ObjClass) {
OperatorInteropRegistry.register( val decimalIdentity = ObjExternCallable.fromBridge {
leftClass = ObjInt.type, requiredArg<Obj>(0)
rightClass = decimalClass, }
commonClass = decimalClass, val numericOperators = listOf(
operatorNames = listOf(
InteropOperator.Plus.name, InteropOperator.Plus.name,
InteropOperator.Minus.name, InteropOperator.Minus.name,
InteropOperator.Mul.name, InteropOperator.Mul.name,
@@ -300,14 +398,37 @@ object ObjBigDecimalSupport {
InteropOperator.Mod.name, InteropOperator.Mod.name,
InteropOperator.Compare.name, InteropOperator.Compare.name,
InteropOperator.Equals.name InteropOperator.Equals.name
), )
OperatorInteropRegistry.register(
leftClass = ObjInt.type,
rightClass = decimalClass,
commonClass = decimalClass,
operatorNames = numericOperators,
leftToCommon = ObjExternCallable.fromBridge { leftToCommon = ObjExternCallable.fromBridge {
val value = requiredArg<ObjInt>(0).value val value = requiredArg<ObjInt>(0).value
newInstance(decimalClass, IonBigDecimal.fromLongAsSignificand(value)) newInstance(decimalClass, IonBigDecimal.fromLong(value))
}, },
rightToCommon = ObjExternCallable.fromBridge { rightToCommon = decimalIdentity
requiredArg<Obj>(0) )
} OperatorInteropRegistry.register(
leftClass = ObjReal.type,
rightClass = decimalClass,
commonClass = decimalClass,
operatorNames = numericOperators,
leftToCommon = ObjExternCallable.fromBridge {
val value = requiredArg<ObjReal>(0).value
newInstanceFromFiniteReal(decimalClass, value)
},
rightToCommon = decimalIdentity
) )
} }
private fun isMixedRealDecimal(left: Obj, right: Obj): Boolean =
(left is ObjReal && isDecimalValue(right)) || (right is ObjReal && isDecimalValue(left))
private fun numericDoubleOrNull(value: Obj): Double? = when (value) {
is Numeric -> value.doubleValue
is ObjInstance -> toDoubleOrNull(value)
else -> null
}
} }
@@ -18,6 +18,7 @@
package net.sergeych.lyng.obj package net.sergeych.lyng.obj
import kotlinx.coroutines.Deferred import kotlinx.coroutines.Deferred
import kotlin.coroutines.cancellation.CancellationException as KotlinCancellationException
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.miniast.addFnDoc import net.sergeych.lyng.miniast.addFnDoc
import net.sergeych.lyng.miniast.addPropertyDoc import net.sergeych.lyng.miniast.addPropertyDoc
@@ -33,12 +34,27 @@ open class ObjDeferred(val deferred: Deferred<Obj>): Obj() {
scope.raiseError("Deferred constructor is not directly callable") scope.raiseError("Deferred constructor is not directly callable")
} }
}.apply { }.apply {
addFnDoc(
name = "cancel",
doc = "Cancel this deferred if it is still active. Safe to call multiple times.",
returns = type("lyng.Void"),
moduleName = "lyng.stdlib"
) {
thisAs<ObjDeferred>().deferred.cancel()
ObjVoid
}
addFnDoc( addFnDoc(
name = "await", name = "await",
doc = "Suspend until completion and return the result value (or throw if failed).", doc = "Suspend until completion and return the result value. Throws `CancellationException` if cancelled.",
returns = type("lyng.Any"), returns = type("lyng.Any"),
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { thisAs<ObjDeferred>().deferred.await() } ) {
try {
thisAs<ObjDeferred>().deferred.await()
} catch (e: KotlinCancellationException) {
requireScope().raiseError(ObjCancellationException(requireScope(), e.message ?: "Deferred was cancelled"))
}
}
addPropertyDoc( addPropertyDoc(
name = "isCompleted", name = "isCompleted",
doc = "Whether this deferred has completed (successfully or with an error).", doc = "Whether this deferred has completed (successfully or with an error).",
@@ -66,4 +82,3 @@ open class ObjDeferred(val deferred: Deferred<Obj>): Obj() {
} }
} }
} }
@@ -278,6 +278,7 @@ open class ObjException(
"AssertionFailedException", "AssertionFailedException",
"ClassCastException", "ClassCastException",
"IndexOutOfBoundsException", "IndexOutOfBoundsException",
"CancellationException",
"IllegalArgumentException", "IllegalArgumentException",
"IllegalStateException", "IllegalStateException",
"NoSuchElementException", "NoSuchElementException",
@@ -311,6 +312,9 @@ class ObjClassCastException(scope: Scope, message: String) : ObjException("Class
class ObjIndexOutOfBoundsException(scope: Scope, message: String = "index out of bounds") : class ObjIndexOutOfBoundsException(scope: Scope, message: String = "index out of bounds") :
ObjException("IndexOutOfBoundsException", scope, message) ObjException("IndexOutOfBoundsException", scope, message)
class ObjCancellationException(scope: Scope, message: String = "cancelled") :
ObjException("CancellationException", scope, message)
class ObjIllegalArgumentException(scope: Scope, message: String = "illegal argument") : class ObjIllegalArgumentException(scope: Scope, message: String = "illegal argument") :
ObjException("IllegalArgumentException", scope, message) ObjException("IllegalArgumentException", scope, message)
@@ -17,6 +17,7 @@
package net.sergeych.lyng.obj package net.sergeych.lyng.obj
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.DelicateCoroutinesApi import kotlinx.coroutines.DelicateCoroutinesApi
import kotlinx.coroutines.channels.Channel import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.channels.ChannelResult import kotlinx.coroutines.channels.ChannelResult
@@ -24,6 +25,7 @@ import kotlinx.coroutines.channels.ReceiveChannel
import kotlinx.coroutines.channels.SendChannel import kotlinx.coroutines.channels.SendChannel
import kotlinx.coroutines.sync.Mutex import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock import kotlinx.coroutines.sync.withLock
import net.sergeych.lyng.EvalSession
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.ScriptFlowIsNoMoreCollected import net.sergeych.lyng.ScriptFlowIsNoMoreCollected
import net.sergeych.lyng.miniast.ParamDoc import net.sergeych.lyng.miniast.ParamDoc
@@ -72,25 +74,34 @@ class ObjFlowBuilder(val output: SendChannel<Obj>) : Obj() {
} }
} }
private fun createLyngFlowInput(scope: Scope, producer: Obj): ReceiveChannel<Obj> { private suspend fun createLyngFlowInput(scope: Scope, producer: Obj, ownerSession: EvalSession?): ReceiveChannel<Obj> {
val channel = Channel<Obj>(Channel.RENDEZVOUS) val channel = Channel<Obj>(Channel.RENDEZVOUS)
val builder = ObjFlowBuilder(channel) val builder = ObjFlowBuilder(channel)
val builderScope = scope.createChildScope(newThisObj = builder) val builderScope = scope.createChildScope(newThisObj = builder)
globalLaunch { val runProducer: suspend CoroutineScope.() -> Unit = {
var failure: Throwable? = null
try { try {
producer.callOn(builderScope) producer.callOn(builderScope)
} catch (x: ScriptFlowIsNoMoreCollected) { } catch (x: ScriptFlowIsNoMoreCollected) {
// premature flow closing, OK // premature flow closing, OK
} catch (x: Throwable) { } catch (x: Throwable) {
channel.close(x) failure = x
return@globalLaunch
} }
if (failure != null) {
channel.close(failure)
} else {
channel.close() channel.close()
} }
}
if (ownerSession != null) {
ownerSession.launchTrackedJob(runProducer)
} else {
globalLaunch(block = runProducer)
}
return channel return channel
} }
class ObjFlow(val producer: Obj, val scope: Scope) : Obj() { class ObjFlow(val producer: Obj, val scope: Scope, val ownerSession: EvalSession? = null) : Obj() {
override val objClass get() = type override val objClass get() = type
@@ -109,14 +120,14 @@ class ObjFlow(val producer: Obj, val scope: Scope) : Obj() {
val objFlow = thisAs<ObjFlow>() val objFlow = thisAs<ObjFlow>()
ObjFlowIterator(ObjExternCallable.fromBridge { ObjFlowIterator(ObjExternCallable.fromBridge {
call(objFlow.producer) call(objFlow.producer)
}) }, objFlow.ownerSession)
} }
} }
} }
} }
class ObjFlowIterator(val producer: Obj) : Obj() { class ObjFlowIterator(val producer: Obj, val ownerSession: EvalSession? = null) : Obj() {
override val objClass: ObjClass get() = type override val objClass: ObjClass get() = type
@@ -134,7 +145,7 @@ class ObjFlowIterator(val producer: Obj) : Obj() {
suspend fun hasNext(scope: Scope): ObjBool { suspend fun hasNext(scope: Scope): ObjBool {
checkNotCancelled(scope) checkNotCancelled(scope)
// cold start: // cold start:
if (channel == null) channel = createLyngFlowInput(scope, producer) if (channel == null) channel = createLyngFlowInput(scope, producer, ownerSession)
if (nextItem == null) nextItem = channel!!.receiveCatching() if (nextItem == null) nextItem = channel!!.receiveCatching()
nextItem?.exceptionOrNull()?.let { throw it } nextItem?.exceptionOrNull()?.let { throw it }
return ObjBool(nextItem!!.isSuccess) return ObjBool(nextItem!!.isSuccess)
@@ -587,6 +587,10 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
} }
override suspend fun compareTo(scope: Scope, other: Obj): Int { override suspend fun compareTo(scope: Scope, other: Obj): Int {
val explicitCompare = objClass.getInstanceMemberOrNull("compareTo", includeStatic = false)
if (explicitCompare != null) {
return invokeInstanceMethod(scope, "compareTo", Arguments(other)).cast<ObjInt>(scope).toInt()
}
if (other !is ObjInstance || other.objClass != objClass) { if (other !is ObjInstance || other.objClass != objClass) {
OperatorInteropRegistry.invokeCompare(scope, this, other)?.let { return it } OperatorInteropRegistry.invokeCompare(scope, this, other)?.let { return it }
return -1 return -1
@@ -0,0 +1,385 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.obj
import net.sergeych.lyng.ModuleScope
import net.sergeych.lyng.Scope
import net.sergeych.lyng.ScopeFacade
import net.sergeych.lyng.matrix.MatrixData
import net.sergeych.lyng.matrix.VectorData
import net.sergeych.lyng.requiredArg
object ObjMatrixSupport {
private sealed interface MatrixAxisIndex {
data class Single(val value: Int) : MatrixAxisIndex
data class Slice(val values: IntArray) : MatrixAxisIndex
}
private object BoundMarker
private val defaultMatrix = MatrixData(1, 1, doubleArrayOf(0.0))
private val defaultVector = VectorData(doubleArrayOf(0.0))
suspend fun bindTo(module: ModuleScope) {
val matrixClass = module.requireClass("Matrix")
val vectorClass = module.requireClass("Vector")
if (matrixClass.kotlinClassData === BoundMarker && vectorClass.kotlinClassData === BoundMarker) return
bindVectorClass(vectorClass, matrixClass)
bindMatrixClass(matrixClass, vectorClass)
}
private fun bindVectorClass(vectorClass: ObjClass, matrixClass: ObjClass) {
if (vectorClass.kotlinClassData === BoundMarker) return
vectorClass.kotlinClassData = BoundMarker
vectorClass.isAbstract = false
val hooks = vectorClass.bridgeInitHooks ?: mutableListOf<suspend (ScopeFacade, ObjInstance) -> Unit>().also {
vectorClass.bridgeInitHooks = it
}
hooks += { _, instance -> instance.kotlinInstanceData = defaultVector }
vectorClass.addProperty("size", getter = {
ObjInt.of(vectorOf(thisObj).size.toLong())
})
vectorClass.addProperty("length", getter = {
ObjInt.of(vectorOf(thisObj).size.toLong())
})
vectorClass.addFn("toList") {
Obj.from(vectorOf(thisObj).toList())
}
vectorClass.addFn("get") {
ObjReal.of(vectorOf(thisObj).at(requiredArg<ObjInt>(0).value.toInt()))
}
vectorClass.addFn("plus") {
newVector(vectorClass, vectorOf(thisObj).plus(coerceVectorArg(requireScope(), args.firstAndOnly())))
}
vectorClass.addFn("minus") {
newVector(vectorClass, vectorOf(thisObj).minus(coerceVectorArg(requireScope(), args.firstAndOnly())))
}
vectorClass.addFn("mul") {
newVector(vectorClass, vectorOf(thisObj).scale(coerceScalarArg(requireScope(), args.firstAndOnly())))
}
vectorClass.addFn("div") {
newVector(vectorClass, vectorOf(thisObj).divide(coerceScalarArg(requireScope(), args.firstAndOnly())))
}
vectorClass.addFn("dot") {
ObjReal.of(vectorOf(thisObj).dot(coerceVectorArg(requireScope(), args.firstAndOnly())))
}
vectorClass.addFn("norm") {
ObjReal.of(vectorOf(thisObj).norm())
}
vectorClass.addFn("normalize") {
newVector(vectorClass, vectorOf(thisObj).normalize())
}
vectorClass.addFn("cross") {
newVector(vectorClass, vectorOf(thisObj).cross(coerceVectorArg(requireScope(), args.firstAndOnly())))
}
vectorClass.addFn("outer") {
newMatrix(matrixClass, vectorOf(thisObj).outer(coerceVectorArg(requireScope(), args.firstAndOnly())))
}
vectorClass.addFn("toString") {
ObjString(vectorOf(thisObj).render())
}
vectorClass.addFn("compareTo") {
ObjInt.of(vectorOf(thisObj).compareTo(coerceVectorArg(requireScope(), args.firstAndOnly())).toLong())
}
vectorClass.addClassFn("fromList") {
newVector(vectorClass, parseVector(requireScope(), requiredArg(0)))
}
vectorClass.addClassFn("zeros") {
val size = requiredArg<ObjInt>(0).value.toInt()
if (size <= 0) requireScope().raiseIllegalArgument("vector size must be positive")
newVector(vectorClass, VectorData(DoubleArray(size)))
}
}
private fun bindMatrixClass(matrixClass: ObjClass, vectorClass: ObjClass) {
if (matrixClass.kotlinClassData === BoundMarker) return
matrixClass.kotlinClassData = BoundMarker
matrixClass.isAbstract = false
val hooks = matrixClass.bridgeInitHooks ?: mutableListOf<suspend (ScopeFacade, ObjInstance) -> Unit>().also {
matrixClass.bridgeInitHooks = it
}
hooks += { _, instance -> instance.kotlinInstanceData = defaultMatrix }
matrixClass.addProperty("rows", getter = {
ObjInt.of(matrixOf(thisObj).rows.toLong())
})
matrixClass.addProperty("cols", getter = {
ObjInt.of(matrixOf(thisObj).cols.toLong())
})
matrixClass.addProperty("shape", getter = {
ObjList(
mutableListOf(
ObjInt.of(matrixOf(thisObj).rows.toLong()),
ObjInt.of(matrixOf(thisObj).cols.toLong())
)
)
})
matrixClass.addProperty("isSquare", getter = {
matrixOf(thisObj).isSquare.toObj()
})
matrixClass.addFn("plus") {
newMatrix(matrixClass, matrixOf(thisObj).plus(coerceMatrixArg(requireScope(), args.firstAndOnly())))
}
matrixClass.addFn("minus") {
newMatrix(matrixClass, matrixOf(thisObj).minus(coerceMatrixArg(requireScope(), args.firstAndOnly())))
}
matrixClass.addFn("mul") {
when (val other = args.firstAndOnly()) {
is ObjInstance -> when (other.objClass.className) {
"Matrix" -> newMatrix(matrixClass, matrixOf(thisObj).multiply(matrixOf(other)))
"Vector" -> newVector(vectorClass, matrixOf(thisObj).multiply(vectorOf(other)))
else -> newMatrix(matrixClass, matrixOf(thisObj).scale(coerceScalarArg(requireScope(), other)))
}
else -> newMatrix(matrixClass, matrixOf(thisObj).scale(coerceScalarArg(requireScope(), other)))
}
}
matrixClass.addFn("div") {
newMatrix(matrixClass, matrixOf(thisObj).divide(coerceScalarArg(requireScope(), args.firstAndOnly())))
}
matrixClass.addFn("transpose") {
newMatrix(matrixClass, matrixOf(thisObj).transpose())
}
matrixClass.addFn("trace") {
ObjReal.of(matrixOf(thisObj).trace())
}
matrixClass.addFn("rank") {
ObjInt.of(matrixOf(thisObj).rank().toLong())
}
matrixClass.addFn("determinant") {
ObjReal.of(matrixOf(thisObj).determinant())
}
matrixClass.addFn("inverse") {
newMatrix(matrixClass, matrixOf(thisObj).inverse())
}
matrixClass.addFn("solve") {
when (val rhs = args.firstAndOnly()) {
is ObjInstance -> when (rhs.objClass.className) {
"Vector" -> newVector(vectorClass, matrixOf(thisObj).solve(vectorOf(rhs)))
"Matrix" -> newMatrix(matrixClass, matrixOf(thisObj).solve(matrixOf(rhs)))
else -> requireScope().raiseClassCastError("Matrix.solve expects Vector or Matrix")
}
else -> requireScope().raiseClassCastError("Matrix.solve expects Vector or Matrix")
}
}
matrixClass.addFn("get") {
ObjReal.of(
matrixOf(thisObj).at(
requiredArg<ObjInt>(0).value.toInt(),
requiredArg<ObjInt>(1).value.toInt()
)
)
}
matrixClass.addFn("getAt") {
resolveMatrixIndex(matrixClass, matrixOf(thisObj), args.firstAndOnly(), thisObj)
}
matrixClass.addFn("row") {
doubleArrayToObjList(matrixOf(thisObj).rowValues(requiredArg<ObjInt>(0).value.toInt()))
}
matrixClass.addFn("column") {
doubleArrayToObjList(matrixOf(thisObj).columnValues(requiredArg<ObjInt>(0).value.toInt()))
}
matrixClass.addFn("toList") {
Obj.from(matrixOf(thisObj).toNestedLists())
}
matrixClass.addFn("toString") {
ObjString(matrixOf(thisObj).render())
}
matrixClass.addFn("compareTo") {
ObjInt.of(matrixOf(thisObj).compareTo(coerceMatrixArg(requireScope(), args.firstAndOnly())).toLong())
}
matrixClass.addClassFn("fromRows") {
newMatrix(matrixClass, parseRows(requireScope(), requiredArg(0)))
}
matrixClass.addClassFn("zeros") {
val rows = requiredArg<ObjInt>(0).value.toInt()
val cols = requiredArg<ObjInt>(1).value.toInt()
if (rows <= 0) requireScope().raiseIllegalArgument("matrix must have at least one row")
if (cols <= 0) requireScope().raiseIllegalArgument("matrix must have at least one column")
newMatrix(matrixClass, MatrixData(rows, cols, DoubleArray(rows * cols)))
}
matrixClass.addClassFn("identity") {
val size = requiredArg<ObjInt>(0).value.toInt()
if (size <= 0) requireScope().raiseIllegalArgument("identity matrix size must be positive")
val values = DoubleArray(size * size)
for (index in 0 until size) {
values[index * size + index] = 1.0
}
newMatrix(matrixClass, MatrixData(size, size, values))
}
}
private fun matrixOf(obj: Obj): MatrixData {
val instance = obj as? ObjInstance ?: error("Matrix receiver must be an object instance")
return instance.kotlinInstanceData as? MatrixData ?: defaultMatrix
}
private fun vectorOf(obj: Obj): VectorData {
val instance = obj as? ObjInstance ?: error("Vector receiver must be an object instance")
return instance.kotlinInstanceData as? VectorData ?: defaultVector
}
private suspend fun ScopeFacade.newMatrix(matrixClass: ObjClass, value: MatrixData): ObjInstance {
val instance = call(matrixClass) as? ObjInstance
?: raiseIllegalState("Matrix() did not return an object instance")
instance.kotlinInstanceData = value
return instance
}
private suspend fun ScopeFacade.newVector(vectorClass: ObjClass, value: VectorData): ObjInstance {
val instance = call(vectorClass) as? ObjInstance
?: raiseIllegalState("Vector() did not return an object instance")
instance.kotlinInstanceData = value
return instance
}
private fun coerceMatrixArg(scope: Scope, value: Obj): MatrixData {
val instance = value as? ObjInstance
?: scope.raiseClassCastError("expected Matrix, got ${value.objClass.className}")
if (instance.objClass.className != "Matrix") {
scope.raiseClassCastError("expected Matrix, got ${instance.objClass.className}")
}
return instance.kotlinInstanceData as? MatrixData ?: defaultMatrix
}
private fun coerceVectorArg(scope: Scope, value: Obj): VectorData {
val instance = value as? ObjInstance
?: scope.raiseClassCastError("expected Vector, got ${value.objClass.className}")
if (instance.objClass.className != "Vector") {
scope.raiseClassCastError("expected Vector, got ${instance.objClass.className}")
}
return instance.kotlinInstanceData as? VectorData ?: defaultVector
}
private fun coerceScalarArg(scope: Scope, value: Obj): Double = try {
value.toDouble()
} catch (_: IllegalArgumentException) {
scope.raiseClassCastError("expected matrix scalar (Int or Real), got ${value.objClass.className}")
}
private suspend fun parseRows(scope: Scope, rowsObj: Obj): MatrixData {
val outer = asObjList(scope, rowsObj, "Matrix.fromRows expects a list of rows")
if (outer.list.isEmpty()) scope.raiseIllegalArgument("matrix must have at least one row")
val rows = outer.list.size
var cols = -1
val values = mutableListOf<Double>()
for (rowObj in outer.list) {
val row = asObjList(scope, rowObj, "Matrix rows must be lists")
if (cols == -1) {
cols = row.list.size
if (cols <= 0) scope.raiseIllegalArgument("matrix must have at least one column")
} else if (row.list.size != cols) {
scope.raiseIllegalArgument("matrix rows must all have the same length")
}
for (cell in row.list) {
values += coerceScalarArg(scope, cell)
}
}
return MatrixData(rows, cols, values.toDoubleArray())
}
private suspend fun parseVector(scope: Scope, valuesObj: Obj): VectorData {
val list = asObjList(scope, valuesObj, "Vector.fromList expects a list")
if (list.list.isEmpty()) scope.raiseIllegalArgument("vector must have at least one element")
return VectorData(list.list.map { coerceScalarArg(scope, it) }.toDoubleArray())
}
private suspend fun ScopeFacade.resolveMatrixIndex(
matrixClass: ObjClass,
matrix: MatrixData,
index: Obj,
receiver: Obj
): Obj {
val tuple = asObjList(requireScope(), index, "Matrix index must be [row, col]")
if (tuple.list.size != 2) {
raiseIllegalArgument("Matrix index must contain exactly two selectors: [row, col]")
}
val rowIndex = decodeAxisIndex(requireScope(), tuple.list[0], matrix.rows, "row")
val colIndex = decodeAxisIndex(requireScope(), tuple.list[1], matrix.cols, "column")
return when {
rowIndex is MatrixAxisIndex.Single && colIndex is MatrixAxisIndex.Single ->
ObjReal.of(matrix.at(rowIndex.value, colIndex.value))
rowIndex is MatrixAxisIndex.Single && colIndex is MatrixAxisIndex.Slice ->
newMatrix(matrixClass, matrix.slice(intArrayOf(rowIndex.value), colIndex.values))
rowIndex is MatrixAxisIndex.Slice && colIndex is MatrixAxisIndex.Single ->
newMatrix(matrixClass, matrix.slice(rowIndex.values, intArrayOf(colIndex.value)))
rowIndex is MatrixAxisIndex.Slice && colIndex is MatrixAxisIndex.Slice ->
newMatrix(matrixClass, matrix.slice(rowIndex.values, colIndex.values))
else -> requireScope().raiseIllegalState("unreachable matrix index state for ${receiver.objClass.className}")
}
}
private suspend fun decodeAxisIndex(scope: Scope, index: Obj, size: Int, axisName: String): MatrixAxisIndex =
when (index) {
is ObjInt -> {
val value = index.value.toInt()
if (value !in 0 until size) {
scope.raiseIllegalArgument("$axisName index $value out of bounds for length $size")
}
MatrixAxisIndex.Single(value)
}
is ObjRange -> {
if (index.hasExplicitStep) {
scope.raiseIllegalArgument("Matrix slicing does not support stepped $axisName ranges")
}
val start = index.startInt(scope)
val endExclusive = index.exclusiveIntEnd(scope) ?: size
if (start !in 0..size) {
scope.raiseIllegalArgument("$axisName slice start $start out of bounds for length $size")
}
if (endExclusive !in 0..size) {
scope.raiseIllegalArgument("$axisName slice end $endExclusive out of bounds for length $size")
}
if (start > endExclusive) {
scope.raiseIllegalArgument("$axisName slice start $start is after end $endExclusive")
}
if (start == endExclusive) {
scope.raiseIllegalArgument("Matrix slice must include at least one $axisName")
}
MatrixAxisIndex.Slice(IntArray(endExclusive - start) { start + it })
}
else -> scope.raiseClassCastError("Matrix $axisName selector must be Int or Range, got ${index.objClass.className}")
}
private suspend fun asObjList(scope: Scope, value: Obj, message: String): ObjList = when (value) {
is ObjList -> value
else -> if (value.isInstanceOf(ObjIterable)) {
value.callMethod<ObjList>(scope, "toList")
} else {
scope.raiseClassCastError(message)
}
}
private fun doubleArrayToObjList(values: DoubleArray): ObjList =
ObjList(values.map { ObjReal.of(it) }.toMutableList())
}
@@ -43,6 +43,7 @@ data class ObjReal(val value: Double) : Obj(), Numeric {
override suspend fun compareTo(scope: Scope, other: Obj): Int { override suspend fun compareTo(scope: Scope, other: Obj): Int {
if (other is ObjReal) return value.compareTo(other.value) if (other is ObjReal) return value.compareTo(other.value)
ObjDecimalSupport.mixedRealDecimalCompareFallback(this, other)?.let { return it }
OperatorInteropRegistry.invokeCompare(scope, this, other)?.let { return it } OperatorInteropRegistry.invokeCompare(scope, this, other)?.let { return it }
if (other !is Numeric) return -2 if (other !is Numeric) return -2
return value.compareTo(other.doubleValue) return value.compareTo(other.doubleValue)
@@ -67,23 +68,28 @@ data class ObjReal(val value: Double) : Obj(), Numeric {
} }
override suspend fun plus(scope: Scope, other: Obj): Obj = override suspend fun plus(scope: Scope, other: Obj): Obj =
OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Plus) ObjDecimalSupport.mixedRealDecimalArithmeticFallback(this, other, InteropOperator.Plus)
?: OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Plus)
?: of(this.value + other.toDouble()) ?: of(this.value + other.toDouble())
override suspend fun minus(scope: Scope, other: Obj): Obj = override suspend fun minus(scope: Scope, other: Obj): Obj =
OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Minus) ObjDecimalSupport.mixedRealDecimalArithmeticFallback(this, other, InteropOperator.Minus)
?: OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Minus)
?: of(this.value - other.toDouble()) ?: of(this.value - other.toDouble())
override suspend fun mul(scope: Scope, other: Obj): Obj = override suspend fun mul(scope: Scope, other: Obj): Obj =
OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Mul) ObjDecimalSupport.mixedRealDecimalArithmeticFallback(this, other, InteropOperator.Mul)
?: OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Mul)
?: of(this.value * other.toDouble()) ?: of(this.value * other.toDouble())
override suspend fun div(scope: Scope, other: Obj): Obj = override suspend fun div(scope: Scope, other: Obj): Obj =
OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Div) ObjDecimalSupport.mixedRealDecimalArithmeticFallback(this, other, InteropOperator.Div)
?: OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Div)
?: of(this.value / other.toDouble()) ?: of(this.value / other.toDouble())
override suspend fun mod(scope: Scope, other: Obj): Obj = override suspend fun mod(scope: Scope, other: Obj): Obj =
OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Mod) ObjDecimalSupport.mixedRealDecimalArithmeticFallback(this, other, InteropOperator.Mod)
?: OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Mod)
?: of(this.value % other.toDouble()) ?: of(this.value % other.toDouble())
/** /**
@@ -149,6 +155,22 @@ data class ObjReal(val value: Double) : Obj(), Numeric {
) { ) {
ObjInt.of(thisAs<ObjReal>().value.toLong()) ObjInt.of(thisAs<ObjReal>().value.toLong())
} }
addFnDoc(
name = "isInfinite",
doc = "Return true if this real number is positive or negative infinity.",
returns = type("lyng.Bool"),
moduleName = "lyng.stdlib"
) {
ObjBool(thisAs<ObjReal>().value.isInfinite())
}
addFnDoc(
name = "isNaN",
doc = "Return true if this real number is NaN (not a number).",
returns = type("lyng.Bool"),
moduleName = "lyng.stdlib"
) {
ObjBool(thisAs<ObjReal>().value.isNaN())
}
} }
} }
} }
@@ -48,7 +48,7 @@ enum DecimalRounding {
/** /**
* Dynamic decimal arithmetic settings. * Dynamic decimal arithmetic settings.
* *
* A decimal context is not attached permanently to a `BigDecimal` value. Instead, it is applied dynamically * A decimal context is not attached permanently to a `Decimal` value. Instead, it is applied dynamically
* inside `withDecimalContext(...)`, which makes the rule local to a block of code. * inside `withDecimalContext(...)`, which makes the rule local to a block of code.
* *
* Default context: * Default context:
@@ -76,7 +76,7 @@ class DecimalContext(
/** /**
* Arbitrary-precision decimal value. * Arbitrary-precision decimal value.
* *
* `BigDecimal` is intended for decimal arithmetic where binary floating-point (`Real`) is the wrong tool: * `Decimal` is intended for decimal arithmetic where binary floating-point (`Real`) is the wrong tool:
* - money * - money
* - human-entered decimal values * - human-entered decimal values
* - ratios that should round in decimal, not in binary * - ratios that should round in decimal, not in binary
@@ -84,10 +84,10 @@ class DecimalContext(
* *
* Creating values: * Creating values:
* *
* - `1.d` converts `Int -> BigDecimal` * - `1.d` converts `Int -> Decimal`
* - `2.2.d` converts `Real -> BigDecimal` by preserving the current IEEE-754 value * - `2.2.d` converts `Real -> Decimal` by preserving the current IEEE-754 value
* - `"2.2".d` parses exact decimal text * - `"2.2".d` parses exact decimal text
* - `BigDecimal.fromInt(...)`, `fromReal(...)`, `fromString(...)` are explicit factory forms * - `Decimal.fromInt(...)`, `fromReal(...)`, `fromString(...)` are explicit factory forms
* *
* Important distinction: * Important distinction:
* *
@@ -109,7 +109,7 @@ class DecimalContext(
* *
* Mixed arithmetic: * Mixed arithmetic:
* *
* `BigDecimal` defines its own operators against decimal-compatible values, and the decimal module also registers * `Decimal` defines its own operators against decimal-compatible values, and the decimal module also registers
* interop bridges so built-in left-hand operands work naturally: * interop bridges so built-in left-hand operands work naturally:
* *
* import lyng.decimal * import lyng.decimal
@@ -134,15 +134,15 @@ class DecimalContext(
* *
* "2.2".d * "2.2".d
* *
* That is the precise form. `2.2.d` remains a `Real -> BigDecimal` conversion by design. * That is the precise form. `2.2.d` remains a `Real -> Decimal` conversion by design.
*/ */
extern class BigDecimal() { extern class Decimal() {
/** Add another decimal-compatible value. */ /** Add another decimal-compatible value. */
extern fun plus(other: Object): BigDecimal extern fun plus(other: Object): Decimal
/** Subtract another decimal-compatible value. */ /** Subtract another decimal-compatible value. */
extern fun minus(other: Object): BigDecimal extern fun minus(other: Object): Decimal
/** Multiply by another decimal-compatible value. */ /** Multiply by another decimal-compatible value. */
extern fun mul(other: Object): BigDecimal extern fun mul(other: Object): Decimal
/** /**
* Divide by another decimal-compatible value. * Divide by another decimal-compatible value.
* *
@@ -150,17 +150,21 @@ extern class BigDecimal() {
* - by default: `34` significant digits, `HalfEven` * - by default: `34` significant digits, `HalfEven`
* - inside `withDecimalContext(...)`: the context active for the current block * - inside `withDecimalContext(...)`: the context active for the current block
*/ */
extern fun div(other: Object): BigDecimal extern fun div(other: Object): Decimal
/** Remainder with another decimal-compatible value. */ /** Remainder with another decimal-compatible value. */
extern fun mod(other: Object): BigDecimal extern fun mod(other: Object): Decimal
/** Compare with another decimal-compatible value. */ /** Compare with another decimal-compatible value. */
extern fun compareTo(other: Object): Int extern fun compareTo(other: Object): Int
/** Unary minus. */ /** Unary minus. */
extern fun negate(): BigDecimal extern fun negate(): Decimal
/** Convert to `Int` by dropping the fractional part according to backend conversion rules. */ /** Convert to `Int` by dropping the fractional part according to backend conversion rules. */
extern fun toInt(): Int extern fun toInt(): Int
/** Convert to `Real`. */ /** Convert to `Real`. */
extern fun toReal(): Real extern fun toReal(): Real
/** Return true if this decimal is positive or negative infinity. Always false for Decimal. */
extern fun isInfinite(): Bool
/** Return true if this decimal is NaN (not a number). Always false for Decimal. */
extern fun isNaN(): Bool
/** /**
* Convert to a plain decimal string without scientific notation. * Convert to a plain decimal string without scientific notation.
* *
@@ -169,16 +173,16 @@ extern class BigDecimal() {
extern fun toStringExpanded(): String extern fun toStringExpanded(): String
/** Create a decimal from an `Int`. */ /** Create a decimal from an `Int`. */
static extern fun fromInt(value: Int): BigDecimal static extern fun fromInt(value: Int): Decimal
/** /**
* Create a decimal from a `Real`. * Create a decimal from a `Real`.
* *
* This preserves the current IEEE-754 value using a round-trip-safe decimal conversion. * This preserves the current IEEE-754 value using a round-trip-safe decimal conversion.
* It does not try to recover the original source text. * It does not try to recover the original source text.
*/ */
static extern fun fromReal(value: Real): BigDecimal static extern fun fromReal(value: Real): Decimal
/** Parse exact decimal text. */ /** Parse exact decimal text. */
static extern fun fromString(value: String): BigDecimal static extern fun fromString(value: String): Decimal
} }
/** /**
@@ -97,7 +97,7 @@ enum BinaryOperator {
* The registry is symmetric for the converted values, but not for the original syntax. * The registry is symmetric for the converted values, but not for the original syntax.
* Its job is specifically to fill the gap where your custom type appears on the right: * Its job is specifically to fill the gap where your custom type appears on the right:
* *
* - `myDecimal + 1` usually already works if `BigDecimal.plus(Int)` exists * - `myDecimal + 1` usually already works if `Decimal.plus(Int)` exists
* - `1 + myDecimal` needs registration because `Int` itself is not rewritten * - `1 + myDecimal` needs registration because `Int` itself is not rewritten
* *
* Typical pattern for a custom type: * Typical pattern for a custom type:
@@ -135,7 +135,7 @@ enum BinaryOperator {
* - `3 > Rational(5, 2)` works * - `3 > Rational(5, 2)` works
* - `2 == Rational(2, 1)` works * - `2 == Rational(2, 1)` works
* *
* Decimal uses the same mechanism internally to make `Int + BigDecimal` and `Real + BigDecimal` * Decimal uses the same mechanism internally to make `Int + Decimal` and `Real + Decimal`
* work without changing the built-in `Int` or `Real` classes. * work without changing the built-in `Int` or `Real` classes.
*/ */
extern object OperatorInterop { extern object OperatorInterop {
@@ -0,0 +1,55 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
import kotlinx.coroutines.test.runTest
import net.sergeych.lyng.ScriptError
import net.sergeych.lyng.eval
import kotlin.test.Test
import kotlin.test.assertContains
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith
class CalculusDiagnosticRegressionTest {
@Test
fun undefinedHInCalculusSnippetReportsPreciseDiagnostic() = runTest {
val ex = assertFailsWith<ScriptError> {
eval(
"""
var x = 7.0
// глубина по звуку падения
val m = 1 // kg
val d = 0.06 // 6 cm
val c = 340 // скор. звука
val g = 9.82
var cnt = 0
var t = x
var message = ""
val hinv = 1/h
var h = c*c/g*(1 + g*t/c -sqrt(1+2*g*t/c))
assert(h is Real)
assert(!h.isNaN())
""".trimIndent()
)
}
assertEquals(9, ex.pos.line)
assertEquals(13, ex.pos.column)
assertContains(ex.errorMessage, "symbol 'h' is not defined")
assertContains(ex.message ?: "", "val hinv = 1/h")
}
}
@@ -58,6 +58,30 @@ class TestCoroutines {
) )
} }
@Test
fun testDeferredCancel() = runTest {
eval(
"""
var reached = false
val d = launch {
delay(100)
reached = true
"ok"
}
d.cancel()
d.cancel()
assertThrows(CancellationException) { d.await() }
delay(150)
assert(d.isCancelled)
assert(!d.isActive)
assert(!reached)
""".trimIndent()
)
}
@Test @Test
fun testMutex() = runTest { fun testMutex() = runTest {
eval( eval(
@@ -0,0 +1,185 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
import kotlinx.coroutines.async
import kotlinx.coroutines.launch
import kotlinx.coroutines.test.advanceTimeBy
import kotlinx.coroutines.test.runTest
import net.sergeych.lyng.EvalSession
import net.sergeych.lyng.Scope
import net.sergeych.lyng.Script
import net.sergeych.lyng.obj.ObjBool
import net.sergeych.lyng.obj.ObjFlow
import net.sergeych.lyng.obj.ObjInt
import net.sergeych.lyng.obj.ObjList
import kotlin.test.*
class EvalSessionTest {
@Test
fun sessionCreatesAndReusesScope() = runTest {
val session = EvalSession()
assertEquals(null, session.scope)
assertEquals(10L, (session.eval("var x = 10; x") as ObjInt).value)
assertNotNull(session.scope)
assertEquals(session.scope, session.getScope())
assertEquals(15L, (session.eval("x += 5; x") as ObjInt).value)
}
@Test
fun sessionCancelStopsLaunchedCoroutines() = runTest {
val scope = Script.newScope()
scope.eval("var exportedVal=0")
val session = EvalSession(scope)
session.eval(
"""
var touched = false
launch {
while(true) {
delay(100)
touched = true
}
}
"""
.trimIndent()
)
session.cancelAndJoin()
advanceTimeBy(150)
assertFalse((scope.eval("touched") as ObjBool).value)
}
@Test
fun cancelAndJoinStopsLaunchedCoroutinesForUserProvidedScriptScope() = runTest {
val scope = Script.newScope()
val session = EvalSession(scope)
session.eval(
"""
var counter = 0
launch {
delay(10)
counter += 1
}
"""
.trimIndent()
)
session.cancelAndJoin()
advanceTimeBy(20)
assertEquals(0L, (scope.eval("counter") as ObjInt).value)
}
@Test
fun joinObservesWorkStartedByLaterEval() = runTest {
val session = EvalSession(Scope())
session.eval("launch { delay(100) }")
var joined = false
val waiter = launch {
session.join()
joined = true
}
advanceTimeBy(50)
assertFalse(joined)
session.eval("launch { delay(100) }")
advanceTimeBy(60)
assertFalse(joined)
advanceTimeBy(50)
waiter.join()
assertTrue(joined)
}
@Test
fun concurrentEvalCallsAreSerialized() = runTest {
val session = EvalSession(Scope())
session.eval("var counter = 0")
val first = async {
session.eval(
"""
delay(100)
counter += 1
counter
"""
.trimIndent()
) as ObjInt
}
val second = async {
session.eval(
"""
counter += 10
counter
"""
.trimIndent()
) as ObjInt
}
advanceTimeBy(150)
assertEquals(1L, first.await().value)
assertEquals(11L, second.await().value)
assertEquals(11L, (session.eval("counter") as ObjInt).value)
}
@Test
fun joinWaitsForActiveFlowProducer() = runTest {
val scope = Scope()
val session = EvalSession(scope)
val flow = session.eval(
"""
flow {
delay(100)
emit(1)
delay(100)
emit(2)
}
"""
.trimIndent()
) as ObjFlow
var joined = false
var collected: ObjList? = null
val collector = launch {
collected = flow.callMethod(scope, "toList")
}
val waiter = launch {
session.join()
joined = true
}
advanceTimeBy(150)
assertFalse(joined)
advanceTimeBy(100)
collector.join()
waiter.join()
assertTrue(joined)
assertEquals(listOf(1L, 2L), collected!!.list.map { (it as ObjInt).value })
}
}
@@ -17,14 +17,15 @@
package net.sergeych.lyng package net.sergeych.lyng
import com.ionspin.kotlin.bignum.decimal.BigDecimal
import kotlinx.coroutines.test.runTest import kotlinx.coroutines.test.runTest
import net.sergeych.lyng.bridge.bindGlobalFun1 import net.sergeych.lyng.bridge.*
import net.sergeych.lyng.bridge.bindGlobalFun3 import net.sergeych.lyng.obj.ObjInstance
import net.sergeych.lyng.bridge.bindGlobalVar
import net.sergeych.lyng.bridge.globalBinder
import net.sergeych.lyng.obj.ObjInt import net.sergeych.lyng.obj.ObjInt
import net.sergeych.lyng.obj.ObjReal
import net.sergeych.lyng.obj.ObjString import net.sergeych.lyng.obj.ObjString
import kotlin.test.Test import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertTrue import kotlin.test.assertTrue
class GlobalBindingTest { class GlobalBindingTest {
@@ -136,4 +137,87 @@ class GlobalBindingTest {
assertTrue(readonlySetter) assertTrue(readonlySetter)
} }
} }
@Test
fun rawDecimalExternBindingDoesNotBreakDecimalLiteralRendering() = runTest {
val scope = Script.newScope()
var x = BigDecimal.ZERO
scope.eval(
"""
import lyng.decimal
extern var X: Decimal
""".trimIndent()
)
scope.globalBinder().bindGlobalVarRaw(
name = "X",
get = { it.newDecimal(x) },
set = { _, value ->
x = when (value) {
is ObjInt -> BigDecimal.fromLong(value.value)
is ObjReal -> BigDecimal.fromDouble(value.value)
is ObjInstance -> value.data as BigDecimal
else -> error("unexpected value: $value")
}
}
)
scope.eval(
"""
fun main() {
assertEquals("42", 42.d.toStringExpanded())
}
main()
""".trimIndent()
)
assertEquals(BigDecimal.ZERO, x)
}
@Test
fun externDecimalDeclarationAloneDoesNotBreakDecimalLiteralRendering() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.decimal
extern var X: Decimal
fun main() {
assertEquals("42", 42.d.toStringExpanded())
}
main()
""".trimIndent()
)
}
@Test
fun parserKeeps42DotDAsIntDotIdentifierAfterExternDecimalDeclaration() = runTest {
val tokens = parseLyng(
Source(
"test",
"""
import lyng.decimal
extern var X: Decimal
fun main() {
42.d.toStringExpanded()
}
""".trimIndent()
)
)
val tokenTexts = tokens.map { it.type to it.value }
val needle = listOf(
Token.Type.INT to "42",
Token.Type.DOT to ".",
Token.Type.ID to "d",
Token.Type.DOT to ".",
Token.Type.ID to "toStringExpanded",
)
val found = tokenTexts.windowed(needle.size).any { it == needle }
assertTrue(found, tokenTexts.joinToString())
}
} }
@@ -18,8 +18,14 @@
package net.sergeych.lyng package net.sergeych.lyng
import kotlinx.coroutines.test.runTest import kotlinx.coroutines.test.runTest
import net.sergeych.lyng.bridge.bind
import net.sergeych.lyng.obj.ObjRecord
import net.sergeych.lyng.bridge.data
import net.sergeych.lyng.bridge.bindGlobalVar import net.sergeych.lyng.bridge.bindGlobalVar
import net.sergeych.lyng.bridge.globalBinder import net.sergeych.lyng.bridge.globalBinder
import net.sergeych.lyng.obj.ObjFalse
import net.sergeych.lyng.obj.ObjInstance
import net.sergeych.lyng.obj.ObjTrue
import kotlin.test.Test import kotlin.test.Test
import kotlin.test.assertEquals import kotlin.test.assertEquals
@@ -49,4 +55,97 @@ class GlobalPropertyCaptureRegressionTest {
assertEquals(2.0, x, "bound extern var should stay live inside function bodies") assertEquals(2.0, x, "bound extern var should stay live inside function bodies")
} }
@Test
fun externGlobalVarShouldStayLiveWhenScriptRunsInChildScope() = runTest {
val base = Script.newScope() as ModuleScope
var x = 1.0
base.eval("extern var X: Real")
base.globalBinder().bindGlobalVar(
name = "X",
get = { x },
set = { x = it }
)
val child = base.createChildScope()
child.eval(
Source(
"child-scope-probe",
"""
fun main() {
X = X + 1.0
}
""".trimIndent()
)
)
val mainRecord = child["main"]
check(mainRecord?.type == ObjRecord.Type.Fun)
child.eval("main()")
assertEquals(2.0, x, "bound extern var should stay live in child-scope execution")
}
@Test
fun externGlobalVarShouldStayLiveAfterExternClassPropertyBranchInChildScope() = runTest {
val base = Script.newScope() as ModuleScope
var x = 3.0
base.eval(
"""
extern var X: Real
class ChoiceInputResult {
extern val isSkip: Bool
}
extern fun requestChoice(): ChoiceInputResult
""".trimIndent()
)
base.bind("ChoiceInputResult") {
addVal("isSkip") {
if (thisObjData<ChoicePayload>().isSkip) ObjTrue else ObjFalse
}
}
base.globalBinder().bindGlobalVar(
name = "X",
get = { x },
set = { x = it }
)
base.globalBinder().bindGlobalFunRaw("requestChoice") { _, _ ->
val instance = base.requireClass("ChoiceInputResult").callOn(base.createChildScope()) as ObjInstance
instance.data = ChoicePayload(isSkip = true)
instance
}
val child = base.createChildScope()
child.eval(
"""
fun main() {
val c: ChoiceInputResult = requestChoice()
if (c.isSkip) {
X = 77.0
}
}
""".trimIndent()
)
child.eval("main()")
assertEquals(77.0, x, "bound extern var should stay live after extern class property branch in child scope")
}
}
private data class ChoicePayload(
val isSkip: Boolean,
)
@Suppress("UNCHECKED_CAST")
private fun <T> ScopeFacade.thisObjData(): T {
val instance = thisObj as? ObjInstance ?: raiseClassCastError("Expected result object instance")
return instance.data as? T ?: raiseIllegalState("Bridge payload is not initialized")
} }
@@ -0,0 +1,49 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
import kotlinx.coroutines.test.runTest
import net.sergeych.lyng.eval
import net.sergeych.lyng.obj.ObjBool
import kotlin.test.Test
import kotlin.test.assertEquals
class LocalRealMemberInferenceRegressionTest {
@Test
fun sqrtInitializedLocalVarKeepsRealReceiverTypeForMembers() = runTest {
val result = eval(
"""
fun probe(T: Real, c: Real, g: Real): Bool {
fun passthrough(h: Real): Real = h / c
val term = 1.0 + g * T / c
val sqrtTerm = sqrt(1.0 + 2.0 * g * T / c)
assert(sqrtTerm is Real)
assert(!sqrtTerm.isNaN())
var h = (c * c / g) * (term - sqrtTerm)
assert(passthrough(h) >= 0.0)
assert(h is Real)
!h.isNaN()
}
probe(6.0, 340.0, 9.81)
""".trimIndent()
)
assertEquals(ObjBool(true), result)
}
}
+122
View File
@@ -5271,6 +5271,19 @@ class ScriptTest {
) )
} }
@Test
fun testRealIsInfiniteAndIsNaN() = runTest {
eval(
"""
assertEquals(false, 1.0.isInfinite())
assertEquals(true, (1.0 / 0.0).isInfinite())
assertEquals(true, (-1.0 / 0.0).isInfinite())
assertEquals(false, 1.0.isNaN())
assertEquals(true, (0.0 / 0.0).isNaN())
""".trimIndent()
)
}
@Test @Test
fun testEmptySpreadList() = runTest { fun testEmptySpreadList() = runTest {
eval( eval(
@@ -5460,4 +5473,113 @@ class ScriptTest {
""".trimIndent() """.trimIndent()
) )
} }
@Test
fun testFromCalcurus1() = runTest {
eval($$"""
/*
Рассчитывает глубину провала по времени падения камня и прихода звука.
@param T измеренное полное время (с)
@param m масса камня (кг)
@param d диаметр камня (м) (предполагается сферическая форма)
@param rho плотность воздуха (кг/м³), по умолчанию 1.2
@param c скорость звука (м/с), по умолчанию 340.0
@param g ускорение свободного падения (м/с²), по умолчанию 9.81
@param Cd коэффициент лобового сопротивления, по умолчанию 0.5
@param epsilon относительная точность (м), по умолчанию 1e-3
@param maxIter максимальное число итераций, по умолчанию 20
@return глубина h (м), или null если расчёт не сошёлся
*/
fun calculateDepth(
T: Real,
m: Real,
d: Real,
rho: Real = 1.2,
c: Real = 340.0,
g: Real = 9.81,
Cd: Real = 0.5,
epsilon: Real = 1e-3,
maxIter: Int = 20
): Real? {
// Площадь миделя
val r = d / 2.0
val A = π * r * r
// Коэффициент сопротивления
val k = 0.5 * Cd * rho * A
// Предельная скорость
val vTerm = sqrt(m * g / k)
// Функция времени падения с высоты h
fun tFall(h: Real): Real {
val arg = exp(g * h / (vTerm * vTerm))
// arcosh(x) = ln(x + sqrt(x^2 - 1))
val arcosh = ln(arg + sqrt(arg * arg - 1.0))
return vTerm / g * arcosh
}
// Производная времени падения по h
fun dtFall_dh(h: Real): Real {
val expArg = exp(2.0 * g * h / (vTerm * vTerm))
return 1.0 / (vTerm * sqrt(expArg - 1.0))
}
// Полное расчётное время T_calc(h) = tFall(h) + h/c
fun Tcalc(h: Real): Real = tFall(h) + h / c
// Производная T_calc по h
fun dTcalc_dh(h: Real): Real = dtFall_dh(h) + 1.0 / c
// Начальное приближение (без сопротивления)
val term = 1.0 + g * T / c
val sqrtTerm = sqrt(1.0 + 2.0 * g * T / c)
var h = (c * c / g) * (term - sqrtTerm)
// Проверка на валидность начального приближения
if (h.isNaN() || h <= 0.0) {
// Если формула дала некорректный результат, используем оценку по свободному падению
h = 0.5 * g * T * T // грубая оценка, всё равно будет уточняться
if (h.isNaN() || h <= 0.0) return null
}
// Итерации Ньютона
var iter = 0
while (iter < maxIter) {
val f = Tcalc(h) - T
val df = dTcalc_dh(h)
// Если производная близка к нулю, выходим
if (abs(df) < 1e-12) return null
val hNew = h - f / df
// Проверка сходимости
if (abs(hNew - h) < epsilon) {
return hNew
}
h = hNew
iter++
}
// Не сошлось за maxIter
return null
}
// Пример использования
val T = 6.0 // секунды
val m = 1.0 // кг
val d = 0.1 // м (10 см)
val depth = calculateDepth(T, m, d)
if (depth != null) {
println("Глубина: %.2f м"(depth))
} else {
println("Расчёт не сошёлся")
}
""".trimIndent())
}
} }
@@ -1,5 +1,5 @@
/* /*
* Copyright 2026 Sergey S. Chernov * Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -12,17 +12,14 @@
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*
*/ */
import kotlinx.coroutines.test.runTest import kotlinx.coroutines.test.runTest
import net.sergeych.lyng.FrameSlotRef import net.sergeych.lyng.FrameSlotRef
import net.sergeych.lyng.Pos import net.sergeych.lyng.Pos
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.bytecode.BytecodeConst import net.sergeych.lyng.bytecode.*
import net.sergeych.lyng.bytecode.CmdFrame
import net.sergeych.lyng.bytecode.CmdFunction
import net.sergeych.lyng.bytecode.CmdVm
import net.sergeych.lyng.bytecode.seedFrameLocalsFromScope
import kotlin.test.Test import kotlin.test.Test
import kotlin.test.assertNull import kotlin.test.assertNull
@@ -39,6 +36,8 @@ class SeedLocalsRegressionTest {
scopeSlotIndices = intArrayOf(0), scopeSlotIndices = intArrayOf(0),
scopeSlotNames = arrayOf(null), scopeSlotNames = arrayOf(null),
scopeSlotIsModule = booleanArrayOf(false), scopeSlotIsModule = booleanArrayOf(false),
scopeSlotRequiresPreparedBinding = booleanArrayOf(false),
scopeSlotRefPos = arrayOfNulls(1),
localSlotNames = arrayOf("x"), localSlotNames = arrayOf("x"),
localSlotMutables = booleanArrayOf(true), localSlotMutables = booleanArrayOf(true),
localSlotDelegated = booleanArrayOf(false), localSlotDelegated = booleanArrayOf(false),
@@ -0,0 +1,44 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
import kotlinx.coroutines.test.runTest
import net.sergeych.lyng.ScriptError
import net.sergeych.lyng.eval
import kotlin.test.Test
import kotlin.test.assertContains
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith
class UndefinedSymbolDiagnosticTest {
@Test
fun laterDeclaredTopLevelSymbolReportsUndefinedNameAtUseSite() = runTest {
val ex = assertFailsWith<ScriptError> {
eval(
"""
var x = 7.0
val hinv = 1/h
var h = x
""".trimIndent()
)
}
assertEquals(1, ex.pos.line)
assertEquals(13, ex.pos.column)
assertContains(ex.errorMessage, "symbol 'h' is not defined")
}
}
@@ -1,138 +0,0 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng
import kotlinx.coroutines.test.runTest
import kotlin.test.Test
class BigDecimalModuleTest {
@Test
fun testDecimalModuleFactoriesAndConversions() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.decimal
assertEquals("12.34", BigDecimal.fromString("12.34").toStringExpanded())
assertEquals("1", BigDecimal.fromInt(1).toStringExpanded())
assertEquals("2.5", "2.5".d.toStringExpanded())
assertEquals("1", 1.d.toStringExpanded())
assertEquals("2.2", 2.2.d.toStringExpanded())
assertEquals("3", (1 + 2).d.toStringExpanded())
assertEquals("1.5", (1 + 0.5).d.toStringExpanded())
assertEquals("3", (1 + 2.d).toStringExpanded())
assertEquals("3", (2.d + 1).toStringExpanded())
assertEquals(2.5, "2.5".d.toReal())
assertEquals(2, "2.5".d.toInt())
assertEquals(2.2, 2.2.d.toReal())
assertEquals("0.30000000000000004", (0.1 + 0.2).d.toStringExpanded())
""".trimIndent()
)
}
@Test
fun testDecimalModuleMixedIntOperators() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.decimal
assertEquals(3.d, 1 + 2.d)
assertEquals(3.d, 2.d + 1)
assertEquals(1.d, 3 - 2.d)
assertEquals(1.d, 3.d - 2)
assertEquals(8.d, 4 * 2.d)
assertEquals(8.d, 4.d * 2)
assertEquals(4.d, 8 / 2.d)
assertEquals(4.d, 8.d / 2)
assertEquals(1.d, 7 % 2.d)
assertEquals(1.d, 7.d % 2)
assert(1 < 2.d)
assert(2 <= 2.d)
assert(3 > 2.d)
assert(3.d > 2)
assert(2 == 2.d)
assert(2.d == 2)
""".trimIndent()
)
}
@Test
fun testDecimalDivisionUsesDefaultContext() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.decimal
assertEquals("0.125", (1.d / 8.d).toStringExpanded())
assertEquals("0.3333333333333333333333333333333333", (1.d / 3.d).toStringExpanded())
assertEquals("0.6666666666666666666666666666666667", ("2".d / 3.d).toStringExpanded())
""".trimIndent()
)
}
@Test
fun testWithDecimalContextOverridesDivisionContext() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.decimal
assertEquals("0.3333333333333333333333333333333333", (1.d / 3.d).toStringExpanded())
assertEquals("0.3333333333", withDecimalContext(10) { (1.d / 3.d).toStringExpanded() })
assertEquals("0.666667", withDecimalContext(6) { ("2".d / 3.d).toStringExpanded() })
assertEquals("0.666667", withDecimalContext(DecimalContext(6)) { ("2".d / 3.d).toStringExpanded() })
assertEquals("0.12", withDecimalContext(2) { (1.d / 8.d).toStringExpanded() })
assertEquals("0.13", withDecimalContext(2, DecimalRounding.HalfAwayFromZero) { (1.d / 8.d).toStringExpanded() })
assertEquals("0.13", withDecimalContext(DecimalContext(2, DecimalRounding.HalfAwayFromZero)) { (1.d / 8.d).toStringExpanded() })
assertEquals("0.3333333333333333333333333333333333", (1.d / 3.d).toStringExpanded())
""".trimIndent()
)
}
@Test
fun testDecimalDivisionRoundingMatrix() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.decimal
assertEquals("0.12", withDecimalContext(2, DecimalRounding.HalfEven) { (1.d / 8.d).toStringExpanded() })
assertEquals("-0.12", withDecimalContext(2, DecimalRounding.HalfEven) { (-1.d / 8.d).toStringExpanded() })
assertEquals("0.13", withDecimalContext(2, DecimalRounding.HalfAwayFromZero) { (1.d / 8.d).toStringExpanded() })
assertEquals("-0.13", withDecimalContext(2, DecimalRounding.HalfAwayFromZero) { (-1.d / 8.d).toStringExpanded() })
assertEquals("0.12", withDecimalContext(2, DecimalRounding.HalfTowardsZero) { (1.d / 8.d).toStringExpanded() })
assertEquals("-0.12", withDecimalContext(2, DecimalRounding.HalfTowardsZero) { (-1.d / 8.d).toStringExpanded() })
assertEquals("0.13", withDecimalContext(2, DecimalRounding.Ceiling) { (1.d / 8.d).toStringExpanded() })
assertEquals("-0.12", withDecimalContext(2, DecimalRounding.Ceiling) { (-1.d / 8.d).toStringExpanded() })
assertEquals("0.12", withDecimalContext(2, DecimalRounding.Floor) { (1.d / 8.d).toStringExpanded() })
assertEquals("-0.13", withDecimalContext(2, DecimalRounding.Floor) { (-1.d / 8.d).toStringExpanded() })
assertEquals("0.13", withDecimalContext(2, DecimalRounding.AwayFromZero) { (1.d / 8.d).toStringExpanded() })
assertEquals("-0.13", withDecimalContext(2, DecimalRounding.AwayFromZero) { (-1.d / 8.d).toStringExpanded() })
assertEquals("0.12", withDecimalContext(2, DecimalRounding.TowardsZero) { (1.d / 8.d).toStringExpanded() })
assertEquals("-0.12", withDecimalContext(2, DecimalRounding.TowardsZero) { (-1.d / 8.d).toStringExpanded() })
""".trimIndent()
)
}
}
@@ -0,0 +1,113 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng
import kotlinx.coroutines.test.runTest
import kotlin.test.Test
class ComplexModuleTest {
@Test
fun testComplexArithmeticAndInterop() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.complex
assertEquals(Complex(0.0, 2.0), 2.i)
assertEquals(Complex(2.0, 0.0), 2.re)
assertEquals(Complex(1.0, 2.0), 1 + 2.i)
assertEquals(Complex(1.5, 2.0), 1.5 + 2.i)
assertEquals(Complex(3.0, 2.0), 1 + Complex(2.0, 2.0))
val product: Complex = Complex(1.0, 2.0) * Complex(3.0, -1.0)
assertEquals(5.0, product.re)
assertEquals(5.0, product.im)
val quotient: Complex = Complex(5.0, 5.0) / Complex(3.0, -1.0)
assertEquals(1.0, quotient.re)
assertEquals(2.0, quotient.im)
assertEquals(Complex(1.0, -2.0), Complex(1.0, 2.0).conjugate)
""".trimIndent()
)
}
@Test
fun testComplexMemberMathFunctions() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.complex
val eps = 1e-9
val eipi = Complex.imaginary(π).exp()
assert(abs(eipi.re + 1.0) < eps)
assert(abs(eipi.im) < eps)
val iy: Complex = 2.i
val sinIy = iy.sin()
assert(abs(sinIy.re) < eps)
assert(abs(sinIy.im - sinh(2.0)) < eps)
val minusOne: Complex = (-1).re
val root = minusOne.sqrt()
assert(abs(root.re) < eps)
assert(abs(root.im - 1.0) < eps)
val unitLeft: Complex = cis(π)
assert(abs(unitLeft.re + 1.0) < eps)
assert(abs(unitLeft.im) < eps)
""".trimIndent()
)
}
@Test
fun testInferences() = runTest {
eval(
$$"""
import lyng.decimal
import lyng.complex
assert( 1.i is Complex )
assert( 5 + 1.i is Complex )
""".trimIndent()
)
}
@Test
fun testDecimalInferences() = runTest {
eval(
$$"""
import lyng.decimal
import lyng.complex
assert( 1.d.i is Complex )
assert( 5 + 1.d.i is Complex )
assert( 5.d + 1.i is Complex )
assert( 5.d + 2.d.i is Complex )
assertEquals("0.0+1.0i", 1.d.i.toString())
assertEquals("1.0+0.0i", 1.d.re.toString())
var c = 1 + 2.i
assert(c is Complex)
assertEquals("1.0+2.0i", c.toString())
c = 1.d + 2.i
assertEquals("1.0+2.0i", c.toString())
""".trimIndent()
)
}
}
@@ -0,0 +1,441 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng
import com.ionspin.kotlin.bignum.decimal.BigDecimal
import kotlinx.coroutines.test.runTest
import net.sergeych.lyng.obj.ObjException
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith
class DecimalModuleTest {
@Test
fun testDecimalModuleFactoriesAndConversions() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.decimal
assertEquals("12.34", Decimal.fromString("12.34").toStringExpanded())
assertEquals("1", Decimal.fromInt(1).toStringExpanded())
assertEquals("42", Decimal.fromInt(42).toStringExpanded())
assertEquals("2.5", "2.5".d.toStringExpanded())
assertEquals("1", 1.d.toStringExpanded())
assertEquals("42", 42.d.toStringExpanded())
assertEquals("2.2", 2.2.d.toStringExpanded())
assertEquals("3", (1 + 2).d.toStringExpanded())
assertEquals("1.5", (1 + 0.5).d.toStringExpanded())
assertEquals("3", (1 + 2.d).toStringExpanded())
assertEquals("3", (2.d + 1).toStringExpanded())
assertEquals(2.5, "2.5".d.toReal())
assertEquals(2, "2.5".d.toInt())
assertEquals(2.2, 2.2.d.toReal())
assertEquals("0.30000000000000004", (0.1 + 0.2).d.toStringExpanded())
""".trimIndent()
)
}
@Test
fun testDecimalIsInfiniteAndIsNaN() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.decimal
assertEquals(false, 0.d.isInfinite())
assertEquals(false, "12.34".d.isInfinite())
assertEquals(false, 0.d.isNaN())
assertEquals(false, "12.34".d.isNaN())
""".trimIndent()
)
}
@Test
fun testDecimalModuleMixedIntOperators() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.decimal
assertEquals(3.d, 1 + 2.d)
assertEquals(3.d, 2.d + 1)
assertEquals(1.d, 3 - 2.d)
assertEquals(1.d, 3.d - 2)
assertEquals(8.d, 4 * 2.d)
assertEquals(8.d, 4.d * 2)
assertEquals(4.d, 8 / 2.d)
assertEquals(4.d, 8.d / 2)
assertEquals(1.d, 7 % 2.d)
assertEquals(1.d, 7.d % 2)
assert(1 < 2.d)
assert(2 <= 2.d)
assert(3 > 2.d)
assert(3.d > 2)
assert(2 == 2.d)
assert(2.d == 2)
""".trimIndent()
)
}
@Test
fun testDecimalModuleMixedRealOperators() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.decimal
assertEquals(3.5.d, 1.5 + 2.d)
assertEquals(3.5.d, 2.d + 1.5)
assertEquals(1.5.d, 3.5 - 2.d)
assertEquals(1.5.d, 3.5.d - 2.0)
assertEquals(7.d, 3.5 * 2.d)
assertEquals(7.d, 3.5.d * 2.0)
assertEquals(1.75.d, 3.5 / 2.d)
assertEquals(1.75.d, 3.5.d / 2.0)
assert(1.5 < 2.d)
assert(2.5.d > 2.0)
assert(2.5 == 2.5.d)
assert(2.5.d == 2.5)
""".trimIndent()
)
}
@Test
fun testMixedRealDecimalNonFiniteResultsStayReal() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.decimal
val inf1 = 1.0 / 0.d
val inf2 = 1.d / 0.0
val inf3 = (1.0 / 0.0) * 2.d
val negInf = -1.d / 0.0
val nan1 = 0.0 / 0.d
val nan2 = (0.0 / 0.0) + 1.d
assert(inf1 is Real)
assert(inf2 is Real)
assert(inf3 is Real)
assert(negInf is Real)
assert(nan1 is Real)
assert(nan2 is Real)
assertEquals("Infinity", inf1.toString())
assertEquals("Infinity", inf2.toString())
assertEquals("Infinity", inf3.toString())
assertEquals("-Infinity", negInf.toString())
assertEquals("NaN", nan1.toString())
assertEquals("NaN", nan2.toString())
assert(inf1 > 999999999.d)
assert(negInf < -999999999.d)
assert(!(nan1 == 1.d))
""".trimIndent()
)
}
@Test
fun testDecimalRejectsExplicitNonFiniteRealConversions() = runTest {
val scope = Script.newScope()
val ex1 = assertFailsWith<ExecutionError> {
scope.eval(
"""
import lyng.decimal
(1.0 / 0.0).d
""".trimIndent()
)
}
val ex2 = assertFailsWith<ExecutionError> {
scope.eval(
"""
import lyng.decimal
Decimal.fromReal(0.0 / 0.0)
""".trimIndent()
)
}
assertEquals(
"cannot convert non-finite Real to Decimal: Infinity",
(ex1.errorObject as ObjException).message.value
)
assertEquals(
"cannot convert non-finite Real to Decimal: NaN",
(ex2.errorObject as ObjException).message.value
)
}
@Test
fun testDecimalDivisionUsesDefaultContext() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.decimal
assertEquals("0.125", (1.d / 8.d).toStringExpanded())
assertEquals("0.3333333333333333333333333333333333", (1.d / 3.d).toStringExpanded())
assertEquals("0.6666666666666666666666666666666667", ("2".d / 3.d).toStringExpanded())
""".trimIndent()
)
}
@Test
fun testWithDecimalContextOverridesDivisionContext() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.decimal
assertEquals("0.3333333333333333333333333333333333", (1.d / 3.d).toStringExpanded())
assertEquals("0.3333333333", withDecimalContext(10) { (1.d / 3.d).toStringExpanded() })
assertEquals("0.666667", withDecimalContext(6) { ("2".d / 3.d).toStringExpanded() })
assertEquals("0.666667", withDecimalContext(DecimalContext(6)) { ("2".d / 3.d).toStringExpanded() })
assertEquals("0.12", withDecimalContext(2) { (1.d / 8.d).toStringExpanded() })
assertEquals("0.13", withDecimalContext(2, DecimalRounding.HalfAwayFromZero) { (1.d / 8.d).toStringExpanded() })
assertEquals("0.13", withDecimalContext(DecimalContext(2, DecimalRounding.HalfAwayFromZero)) { (1.d / 8.d).toStringExpanded() })
assertEquals("0.3333333333333333333333333333333333", (1.d / 3.d).toStringExpanded())
""".trimIndent()
)
}
@Test
fun testDecimalDivisionRoundingMatrix() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.decimal
assertEquals("0.12", withDecimalContext(2, DecimalRounding.HalfEven) { (1.d / 8.d).toStringExpanded() })
assertEquals("-0.12", withDecimalContext(2, DecimalRounding.HalfEven) { (-1.d / 8.d).toStringExpanded() })
assertEquals("0.13", withDecimalContext(2, DecimalRounding.HalfAwayFromZero) { (1.d / 8.d).toStringExpanded() })
assertEquals("-0.13", withDecimalContext(2, DecimalRounding.HalfAwayFromZero) { (-1.d / 8.d).toStringExpanded() })
assertEquals("0.12", withDecimalContext(2, DecimalRounding.HalfTowardsZero) { (1.d / 8.d).toStringExpanded() })
assertEquals("-0.12", withDecimalContext(2, DecimalRounding.HalfTowardsZero) { (-1.d / 8.d).toStringExpanded() })
assertEquals("0.13", withDecimalContext(2, DecimalRounding.Ceiling) { (1.d / 8.d).toStringExpanded() })
assertEquals("-0.12", withDecimalContext(2, DecimalRounding.Ceiling) { (-1.d / 8.d).toStringExpanded() })
assertEquals("0.12", withDecimalContext(2, DecimalRounding.Floor) { (1.d / 8.d).toStringExpanded() })
assertEquals("-0.13", withDecimalContext(2, DecimalRounding.Floor) { (-1.d / 8.d).toStringExpanded() })
assertEquals("0.13", withDecimalContext(2, DecimalRounding.AwayFromZero) { (1.d / 8.d).toStringExpanded() })
assertEquals("-0.13", withDecimalContext(2, DecimalRounding.AwayFromZero) { (-1.d / 8.d).toStringExpanded() })
assertEquals("0.12", withDecimalContext(2, DecimalRounding.TowardsZero) { (1.d / 8.d).toStringExpanded() })
assertEquals("-0.12", withDecimalContext(2, DecimalRounding.TowardsZero) { (-1.d / 8.d).toStringExpanded() })
""".trimIndent()
)
}
@Test
fun testDefaultToString() = runTest {
eval("""
import lyng.decimal
var s0 = "0.1".d + "0.1".d
assertEquals("0.2", s0.toStringExpanded())
assertEquals("0.2", s0.toString())
""".trimIndent())
}
@Test
fun testDecimalMathHelpersUseExactImplementationsWhenAvailable() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.decimal
val absValue = abs("-2.5".d) as Decimal
val floorPos = floor("2.9".d) as Decimal
val floorNeg = floor("-2.1".d) as Decimal
val ceilPos = ceil("2.1".d) as Decimal
val ceilNeg = ceil("-2.1".d) as Decimal
val roundPos = round("2.5".d) as Decimal
val roundNeg = round("-2.5".d) as Decimal
val powInt = pow("1.5".d, 2) as Decimal
assertEquals("2.5", absValue.toStringExpanded())
assertEquals("2", floorPos.toStringExpanded())
assertEquals("-3", floorNeg.toStringExpanded())
assertEquals("3", ceilPos.toStringExpanded())
assertEquals("-2", ceilNeg.toStringExpanded())
assertEquals("3", roundPos.toStringExpanded())
assertEquals("-2", roundNeg.toStringExpanded())
assertEquals("2.25", powInt.toStringExpanded())
""".trimIndent()
)
}
@Test
fun testDecimalTruncateToTwoFractionDigitsViaGlobalRound() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.decimal
fun trunc2(x: Decimal): Decimal {
val scaled = x * 100.d
val whole = if (scaled >= 0.d) {
floor(scaled) as Decimal
} else {
ceil(scaled) as Decimal
}
whole / 100.d
}
assertEquals("12.34", trunc2("12.349".d).toStringExpanded())
assertEquals("12.34", trunc2("12.340".d).toStringExpanded())
assertEquals("-12.34", trunc2("-12.349".d).toStringExpanded())
assertEquals("-12.34", trunc2("-12.340".d).toStringExpanded())
""".trimIndent()
)
}
@Test
fun testDecimalMathHelpersFallbackThroughRealTemporarily() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.decimal
val sinDecimal = sin("0.5".d) as Decimal
val expDecimal = exp("1.25".d) as Decimal
val sqrtDecimal = sqrt("2".d) as Decimal
val lnDecimal = ln("2".d) as Decimal
val log10Decimal = log10("2".d) as Decimal
val log2Decimal = log2("2".d) as Decimal
val powDecimal = pow("2".d, "0.5".d) as Decimal
assertEquals((sin(0.5) as Real).d.toStringExpanded(), sinDecimal.toStringExpanded())
assertEquals((exp(1.25) as Real).d.toStringExpanded(), expDecimal.toStringExpanded())
assertEquals((sqrt(2.0) as Real).d.toStringExpanded(), sqrtDecimal.toStringExpanded())
assertEquals((ln(2.0) as Real).d.toStringExpanded(), lnDecimal.toStringExpanded())
assertEquals((log10(2.0) as Real).d.toStringExpanded(), log10Decimal.toStringExpanded())
assertEquals((log2(2.0) as Real).d.toStringExpanded(), log2Decimal.toStringExpanded())
assertEquals((pow(2.0, 0.5) as Real).d.toStringExpanded(), powDecimal.toStringExpanded())
""".trimIndent()
)
}
@Test
fun decimalMustBeObj() = runTest {
eval("""
import lyng.decimal
val decimal = 42.d
val context = DecimalContext(12)
assert(decimal is Decimal)
assertEquals(Decimal, decimal::class)
assert(context is DecimalContext)
assertEquals(DecimalContext, context::class)
""".trimIndent())
}
@Test
fun testFromRealLife1() = runTest {
eval("""
import lyng.decimal
var X = 42.d
X += 11
assertEquals(53.d, X)
""")
}
@Test
fun decimalPropertyWorksInsideFunctionBody() = runTest {
eval("""
import lyng.decimal
fun main() {
val x = 42.d
assertEquals(42.d, x)
assertEquals(53.d, x + 11)
}
main()
""".trimIndent())
}
@Test
fun kotlinHelperCanWrapIonBigDecimal() = runTest {
val scope = Script.newScope()
val decimal = scope.asFacade().newDecimal(BigDecimal.parseStringWithMode("12.34"))
assertEquals("Decimal", decimal.objClass.className)
assertEquals("12.34", decimal.toString(scope).value)
assertEquals("12.34", decimal.invokeInstanceMethod(scope, "toStringExpanded").cast<net.sergeych.lyng.obj.ObjString>(scope).value)
}
@Test
fun testDecimalComparisons() = runTest {
eval("""
import lyng.decimal
val X = 42.d
assert(X < 43.d)
assert(X < 43)
assert(X == 42)
""".trimIndent())
}
@Test
fun testDecimalStringInterpolation() = runTest {
eval(
$$"""
import lyng.decimal
var X = "2".d
var re = 50.d
var im = X
val s = "$re + ${im}i"
assertEquals("50 + 2i", s)
""".trimIndent())
}
@Test
fun testDecimalInterpolationSyntaxErrorKeepsOriginalSourcePosition() = runTest {
val ex = assertFailsWith<ScriptError> {
eval(
$$"""
import lyng.decimal
var re = 50.d
val s = "${re + }"
""".trimIndent()
)
}
assertEquals(2, ex.pos.line)
}
@Test
fun testOverloading() = runTest {
eval("""
import lyng.decimal
assert( 1.d is Decimal )
assertEquals(Decimal, abs(1.d)::class)
// here the inference must work:
val t = abs(-10.d)
assert(t is Decimal)
assertEquals(10,t)
""".trimIndent())
}
}
@@ -0,0 +1,188 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng
import kotlinx.coroutines.test.runTest
import kotlin.test.Test
class MatrixModuleTest {
@Test
fun testMatrixConstructionAndShape() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.matrix
val a: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
val v: Vector = vector([1, 2, 3])
assertEquals(2, a.rows)
assertEquals(3, a.cols)
assertEquals([2, 3], a.shape)
assertEquals(false, a.isSquare)
assertEquals([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], a.toList())
assertEquals("Matrix(2x3, [[1, 2, 3], [4, 5, 6]])", a.toString())
assertEquals(3, v.size)
assertEquals([1.0, 2.0, 3.0], v.toList())
assertEquals("Vector([1, 2, 3])", v.toString())
assertEquals([0.2672612419124244, 0.5345224838248488, 0.8017837257372732], v.normalize().toList())
""".trimIndent()
)
}
@Test
fun testMatrixArithmeticAndTranspose() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.matrix
val a: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
val b: Matrix = matrix([[7, 8], [9, 10], [11, 12]])
val product: Matrix = a * b
assertEquals([[58.0, 64.0], [139.0, 154.0]], product.toList())
val scaled: Matrix = product * 0.5
assertEquals([[29.0, 32.0], [69.5, 77.0]], scaled.toList())
val sum: Matrix = matrix([[1, 2], [3, 4]]) + Matrix.identity(2)
assertEquals([[2.0, 2.0], [3.0, 5.0]], sum.toList())
val transposed: Matrix = a.transpose()
assertEquals([[1.0, 4.0], [2.0, 5.0], [3.0, 6.0]], transposed.toList())
assertEquals([4.0, 5.0, 6.0], a.row(1))
assertEquals([2.0, 5.0], a.column(1))
val x: Vector = vector([1, 0.5, -1])
val y: Vector = a * x
assertEquals([-1.0, 0.5], y.toList())
val shifted: Vector = x + vector([2, 2, 2])
assertEquals([3.0, 2.5, 1.0], shifted.toList())
val d0: Vector = vector([1, 2, 3])
val d1: Vector = vector([2, 0, 0])
assertEquals(2.0, d0.dot(d1))
val cx0: Vector = vector([1, 0, 0])
val cx1: Vector = vector([0, 1, 0])
assertEquals([0.0, 0.0, 1.0], cx0.cross(cx1).toList())
val o0: Vector = vector([1.5, 3.0])
val o1: Vector = vector([2, 2.6666666666666665])
assertEquals([[3.0, 4.0], [6.0, 8.0]], o0.outer(o1).toList())
""".trimIndent()
)
}
@Test
fun testMatrixDeterminantAndInverse() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.matrix
val eps = 1e-9
val a: Matrix = matrix([[4, 7], [2, 6]])
assert(abs(a.determinant() - 10.0) < eps)
assertEquals(10.0, a.trace())
assertEquals(2, a.rank())
val inv: Matrix = a.inverse()
assert(abs(inv.get(0, 0) - 0.6) < eps)
assert(abs(inv.get(0, 1) + 0.7) < eps)
assert(abs(inv.get(1, 0) + 0.2) < eps)
assert(abs(inv.get(1, 1) - 0.4) < eps)
val identity: Matrix = a * inv
assert(abs(identity.get(0, 0) - 1.0) < eps)
assert(abs(identity.get(0, 1)) < eps)
assert(abs(identity.get(1, 0)) < eps)
assert(abs(identity.get(1, 1) - 1.0) < eps)
val rhs: Vector = vector([1, 0])
val solution: Vector = a.solve(rhs)
assert(abs(solution.get(0) - 0.6) < eps)
assert(abs(solution.get(1) + 0.2) < eps)
val rhsMatrix: Matrix = Matrix.identity(2)
val solvedMatrix: Matrix = a.solve(rhsMatrix)
assert(abs(solvedMatrix.get(0, 0) - 0.6) < eps)
assert(abs(solvedMatrix.get(1, 1) - 0.4) < eps)
val lowRank: Matrix = matrix([[1, 2], [2, 4]])
assertEquals(1, lowRank.rank())
""".trimIndent()
)
}
@Test
fun testMatrixBracketIndexingAndSlices() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.matrix
val m: Matrix = matrix([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
assertEquals(7.0, m[1, 2])
val columnSlice: Matrix = m[0..2, 2]
assertEquals([[3.0], [7.0], [11.0]], columnSlice.toList())
val topLeft: Matrix = m[0..1, 0..1]
assertEquals([[1.0, 2.0], [5.0, 6.0]], topLeft.toList())
val tail: Matrix = m[1.., 1..]
assertEquals([[6.0, 7.0, 8.0], [10.0, 11.0, 12.0]], tail.toList())
val rowSlice: Matrix = m[1, 1..2]
assertEquals([[6.0, 7.0]], rowSlice.toList())
""".trimIndent()
)
}
@Test
fun matrixAndVectorMustBeObjs() = runTest {
eval("""
import lyng.matrix
val matrixValue = matrix([[1, 2], [3, 4]])
val vectorValue = vector([1, 2, 3])
assert(matrixValue is Matrix)
assertEquals(Matrix, matrixValue::class)
assert(vectorValue is Vector)
assertEquals(Vector, vectorValue::class)
""".trimIndent())
}
@Test
fun testMatrixAndVectorComparisons() = runTest {
eval("""
import lyng.matrix
val v0 = vector([1, 2, 3])
val v1 = vector([1, 2, 4])
assert(v0 < v1)
assert(v0 == vector([1, 2, 3]))
val m0 = matrix([[1, 2], [3, 4]])
val m1 = matrix([[1, 2], [3, 5]])
assert(m0 < m1)
assert(m0 == matrix([[1, 2], [3, 4]]))
""".trimIndent())
}
}
@@ -0,0 +1,33 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng
import kotlinx.coroutines.test.runTest
import kotlin.test.Test
class RandomModuleTest {
@Test
fun seededRandomMustBeObj() = runTest {
eval("""
val rng = Random.seeded(12345)
assert(rng is SeededRandom)
assertEquals(SeededRandom, rng::class)
""".trimIndent())
}
}
@@ -0,0 +1,53 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.matrix
import org.jetbrains.kotlinx.multik.api.mk
import org.jetbrains.kotlinx.multik.api.ndarray
import org.jetbrains.kotlinx.multik.api.linalg.dot
import org.jetbrains.kotlinx.multik.api.linalg.inv
import org.jetbrains.kotlinx.multik.ndarray.data.get
internal actual object PlatformMatrixBackend {
actual fun multiply(left: MatrixData, right: MatrixData): MatrixData {
require(left.cols == right.rows) {
"matrix multiplication shape mismatch: ${left.rows}x${left.cols} cannot multiply ${right.rows}x${right.cols}"
}
val leftArray = mk.ndarray(left.values, left.rows, left.cols)
val rightArray = mk.ndarray(right.values, right.rows, right.cols)
val product = leftArray dot rightArray
return MatrixData(left.rows, right.cols, extract(product, left.rows, right.cols))
}
actual fun inverse(matrix: MatrixData): MatrixData {
require(matrix.isSquare) { "matrix inverse requires a square matrix, got ${matrix.rows}x${matrix.cols}" }
val source = mk.ndarray(matrix.values, matrix.rows, matrix.cols)
val inverse = mk.linalg.inv(source)
return MatrixData(matrix.rows, matrix.cols, extract(inverse, matrix.rows, matrix.cols))
}
private fun extract(array: org.jetbrains.kotlinx.multik.ndarray.data.D2Array<Double>, rows: Int, cols: Int): DoubleArray {
val out = DoubleArray(rows * cols)
for (row in 0 until rows) {
for (col in 0 until cols) {
out[row * cols + col] = array[row, col]
}
}
return out
}
}
@@ -0,0 +1,26 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.matrix
internal actual object PlatformMatrixBackend {
actual fun multiply(left: MatrixData, right: MatrixData): MatrixData =
PureMatrixAlgorithms.multiply(left, right)
actual fun inverse(matrix: MatrixData): MatrixData =
PureMatrixAlgorithms.inverse(matrix)
}
+134
View File
@@ -0,0 +1,134 @@
package lyng.complex
import lyng.operators
/*
Complex number backed by `Real` components.
This module intentionally keeps the storage model simple:
- `re`: real part
- `im`: imaginary part
The algebra is implemented in pure Lyng and interoperates with `Int` and `Real`
through `lyng.operators`, so expressions like `1 + 2.i` and `0.5 * (1 + 2.i)` work.
For transcendental functions, use the member-style API for now:
- `z.exp()`
- `z.ln()`
- `z.sin()`
- `z.cos()`
- `z.tan()`
- `z.sqrt()`
This avoids collisions with the built-in real-valued top-level math functions
such as `exp(x)` and `sin(x)`.
*/
class Complex(val real: Real, val imag: Real = 0.0) {
val re get() = real
val im get() = imag
fun plus(other: Complex): Complex = Complex(real + other.real, imag + other.imag)
fun minus(other: Complex): Complex = Complex(real - other.real, imag - other.imag)
fun mul(other: Complex): Complex =
Complex(
real * other.real - imag * other.imag,
real * other.imag + imag * other.real
)
fun div(other: Complex): Complex {
val denominator = other.real * other.real + other.imag * other.imag
Complex(
(real * other.real + imag * other.imag) / denominator,
(imag * other.real - real * other.imag) / denominator
)
}
fun negate(): Complex = Complex(-real, -imag)
val conjugate get() = Complex(real, -imag)
val magnitude2 get() = real * real + imag * imag
val magnitude get() = Math.sqrt(magnitude2)
val phase: Real
get() = if (real > 0.0) {
Math.atan(imag / real)
} else if (real < 0.0 && imag >= 0.0) {
Math.atan(imag / real) + π
} else if (real < 0.0 && imag < 0.0) {
Math.atan(imag / real) - π
} else if (real == 0.0 && imag > 0.0) {
π / 2.0
} else if (real == 0.0 && imag < 0.0) {
-π / 2.0
} else {
0.0
}
fun exp(): Complex {
val scale = Math.exp(real)
Complex(scale * Math.cos(imag), scale * Math.sin(imag))
}
fun ln(): Complex = Complex(Math.ln(magnitude), phase)
fun sin(): Complex =
Complex(
Math.sin(real) * Math.cosh(imag),
Math.cos(real) * Math.sinh(imag)
)
fun cos(): Complex =
Complex(
Math.cos(real) * Math.cosh(imag),
-Math.sin(real) * Math.sinh(imag)
)
fun tan(): Complex = sin() / cos()
fun sqrt(): Complex = if (imag == 0.0 && real >= 0.0) {
Complex(Math.sqrt(real), 0.0)
} else {
val radius = magnitude
val imagPart = Math.sqrt((radius - real) / 2.0)
Complex(Math.sqrt((radius + real) / 2.0), if (imag < 0.0) -imagPart else imagPart)
}
override fun toString() =
real.toString() +
(if (imag < 0.0) imag.toString() else "+" + imag.toString()) +
"i"
static fun fromInt(value: Int): Complex = Complex(value + 0.0, 0.0)
static fun fromReal(value: Real): Complex = Complex(value, 0.0)
static fun imaginary(value: Real): Complex = Complex(0.0, value)
static fun fromPolar(radius: Real, angle: Real): Complex =
Complex(radius * Math.cos(angle), radius * Math.sin(angle))
}
fun complex(re: Real, im: Real = 0.0): Complex = Complex(re, im)
fun cis(angle: Real): Complex = Complex.fromPolar(1.0, angle)
val Int.re: Complex get() = Complex.fromInt(this)
val Real.re: Complex get() = Complex.fromReal(this)
val Int.i: Complex get() = Complex.imaginary(this + 0.0)
val Real.i: Complex get() = Complex.imaginary(this)
OperatorInterop.register(
Int,
Complex,
Complex,
[BinaryOperator.Plus, BinaryOperator.Minus, BinaryOperator.Mul, BinaryOperator.Div],
{ x: Int -> Complex.fromInt(x) },
{ x: Complex -> x }
)
OperatorInterop.register(
Real,
Complex,
Complex,
[BinaryOperator.Plus, BinaryOperator.Minus, BinaryOperator.Mul, BinaryOperator.Div],
{ x: Real -> Complex.fromReal(x) },
{ x: Complex -> x }
)
+157
View File
@@ -0,0 +1,157 @@
package lyng.matrix
type MatrixScalar = Real | Int
/** Dense immutable vector backed by double-precision elements. */
extern class Vector() {
/** Number of elements. */
val size: Int
/** Alias to `size`. */
val length: Int
/** Convert to a plain list. */
extern fun toList(): List<Real>
/** Get one element by zero-based index. */
extern fun get(index: Int): Real
/** Element-wise addition. */
extern fun plus(other: Vector): Vector
/** Element-wise subtraction. */
extern fun minus(other: Vector): Vector
/** Scale every element. */
extern fun mul(other: MatrixScalar): Vector
/** Divide every element by a scalar. */
extern fun div(other: MatrixScalar): Vector
/** Dot product. */
extern fun dot(other: Vector): Real
/** Euclidean norm. */
extern fun norm(): Real
/** Return a unit-length vector in the same direction. */
extern fun normalize(): Vector
/** 3D cross product. Both vectors must have length 3. */
extern fun cross(other: Vector): Vector
/** Outer product, returning a matrix of shape `(this.size, other.size)`. */
extern fun outer(other: Vector): Matrix
/** Build a vector from numeric values. */
static extern fun fromList(values: List<MatrixScalar>): Vector
/** Zero-filled vector. */
static extern fun zeros(size: Int): Vector
}
/**
* Dense immutable matrix backed by double-precision elements.
*
* `Matrix` supports arbitrary rectangular geometry (`rows x cols`), matrix arithmetic,
* transpose, determinant, and inversion.
*
* Use this type for numeric linear algebra where contiguous dense storage is appropriate.
*/
extern class Matrix() {
/** Number of rows. */
val rows: Int
/** Number of columns. */
val cols: Int
/** Two-element shape `[rows, cols]`. */
val shape: List<Int>
/** Whether `rows == cols`. */
val isSquare: Bool
/** Element-wise addition. Shapes must match. */
extern fun plus(other: Matrix): Matrix
/** Element-wise subtraction. Shapes must match. */
extern fun minus(other: Matrix): Matrix
/**
* Multiply by another matrix, by a vector, or by a scalar.
*
* - `Matrix * Matrix`: matrix product (`A.cols == B.rows`)
* - `Matrix * Vector`: matrix-vector product (`A.cols == x.size`)
* - `Matrix * MatrixScalar`: scale every element
*/
extern fun mul(other: Matrix | Vector | MatrixScalar): Matrix | Vector
/** Divide every element by a scalar. */
extern fun div(other: MatrixScalar): Matrix
/** Matrix transpose. */
extern fun transpose(): Matrix
/** Sum of diagonal elements of a square matrix. */
extern fun trace(): Real
/** Row rank computed numerically via row-echelon reduction. */
extern fun rank(): Int
/**
* Determinant of a square matrix.
*
* Raises an error for non-square matrices.
*/
extern fun determinant(): Real
/**
* Inverse of a square matrix.
*
* Raises an error for non-square or singular matrices.
*/
extern fun inverse(): Matrix
/**
* Solve `A * x = rhs`.
*
* - with a `Vector` right-hand side, returns a `Vector`
* - with a `Matrix` right-hand side, returns a `Matrix`
*/
extern fun solve(rhs: Vector | Matrix): Vector | Matrix
/**
* Bracket indexing by `[row, col]`.
*
* Each selector may be an `Int` or a `Range`:
* - `m[1, 2]` returns one scalar
* - `m[0..2, 2]` returns a `3x1` matrix
* - `m[0..2, 0..2]` returns a sub-matrix
* - `m[1.., 1..]` returns the bottom-right tail
*/
override extern fun getAt(index: List<Int | Range>): Real | Matrix
/** Get one element by zero-based row and column indices. */
extern fun get(row: Int, col: Int): Real
/** Return one row as a `List<Real>`. */
extern fun row(index: Int): List<Real>
/** Return one column as a `List<Real>`. */
extern fun column(index: Int): List<Real>
/** Convert to nested row lists. */
extern fun toList(): List<List<Real>>
/** Build a matrix from nested row lists. All rows must have the same length. */
static extern fun fromRows(rows: List<List<MatrixScalar>>): Matrix
/** Create a zero-filled matrix. */
static extern fun zeros(rows: Int, cols: Int): Matrix
/** Create an identity matrix of shape `(size, size)`. */
static extern fun identity(size: Int): Matrix
}
fun vector(values: List<MatrixScalar>): Vector = Vector.fromList(values)
fun matrix(rows: List<List<MatrixScalar>>): Matrix = Matrix.fromRows(rows)
+47 -3
View File
@@ -1,11 +1,48 @@
package lyng.stdlib package lyng.stdlib
/* Launch `code` asynchronously and return its result handle. */
extern fun launch(code): Deferred
/* Yield execution so other scheduled coroutines can run. */
extern fun yield(): void
/* Build a lazy asynchronous sequence. */
extern fun flow(builder: FlowBuilder.()->void): Flow extern fun flow(builder: FlowBuilder.()->void): Flow
/* Built-in exception type. */ /* Built-in exception type. */
extern class Exception extern class Exception
extern class IllegalArgumentException extern class IllegalArgumentException
extern class NotImplementedException extern class NotImplementedException
/* Raised when an awaited asynchronous task was cancelled before producing a value. */
extern class CancellationException : Exception
/* A handle to a running asynchronous task. */
extern class Deferred {
/* Cancel the task if it is still active. Safe to call multiple times. */
fun cancel(): void
/* Suspend until the task finishes and return its value.
Throws `CancellationException` if the task was cancelled. */
fun await(): Object
/* True when the task has finished, failed, or otherwise reached a terminal state. */
val isCompleted: Bool
/* True while the task is still running and has not been cancelled. */
val isActive: Bool
/* True when the task was cancelled. */
val isCancelled: Bool
}
/* A deferred result that can be completed manually. */
extern class CompletableDeferred : Deferred {
fun complete(value: Object): void
}
/* Receiver passed into `flow { ... }` builders. */
extern class FlowBuilder {
fun emit(value: Object): void
}
/* A cold asynchronous iterable sequence. */
extern class Flow<T> : Iterable<T> {
}
extern class Delegate extern class Delegate
extern class Iterable<T> { extern class Iterable<T> {
fun iterator(): Iterator<T> fun iterator(): Iterator<T>
@@ -77,9 +114,16 @@ extern class MapEntry<K,V> : Array<Object> {
} }
// Built-in math helpers (implemented in host runtime). // Built-in math helpers (implemented in host runtime).
extern fun abs(x: Object): Real //
extern fun ln(x: Object): Real // Decimal note:
extern fun pow(x: Object, y: Object): Real // - these helpers accept `Decimal` values too
// - `abs`, `floor`, `ceil`, `round`, and `pow(x, y)` with integral `y` keep decimal arithmetic
// - the remaining decimal cases currently use a temporary bridge:
// `Decimal -> Real -> host math -> Decimal`
// - this is temporary and will be replaced with dedicated decimal implementations
extern fun abs(x: Object): Object
extern fun ln(x: Object): Object
extern fun pow(x: Object, y: Object): Object
extern fun sqrt(x: Object): Real extern fun sqrt(x: Object): Real
extern fun clamp<T>(value: T, range: Range<T>): T extern fun clamp<T>(value: T, range: Range<T>): T
+2 -2
View File
@@ -1,5 +1,5 @@
/* /*
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com * Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -21,7 +21,7 @@
plugins { plugins {
alias(libs.plugins.kotlinMultiplatform) alias(libs.plugins.kotlinMultiplatform)
id("org.jetbrains.kotlin.plugin.compose") version "2.2.21" id("org.jetbrains.kotlin.plugin.compose") version "2.3.20"
id("org.jetbrains.compose") version "1.9.3" id("org.jetbrains.compose") version "1.9.3"
`maven-publish` `maven-publish`
} }
+36
View File
@@ -0,0 +1,36 @@
# Decimal Math TODO
These stdlib math helpers currently accept `Decimal`, but some still use the temporary compatibility path
`Decimal -> Real -> host math -> Decimal`
instead of a native decimal implementation.
## Still Using The Temporary Real Bridge
- `sin(x)`
- `cos(x)`
- `tan(x)`
- `asin(x)`
- `acos(x)`
- `atan(x)`
- `sinh(x)`
- `cosh(x)`
- `tanh(x)`
- `asinh(x)`
- `acosh(x)`
- `atanh(x)`
- `exp(x)`
- `ln(x)`
- `log10(x)`
- `log2(x)`
- `sqrt(x)`
- `pow(x, y)` when the decimal case is not reducible to an integral exponent
## Already Native For Decimal
- `abs(x)`
- `floor(x)`
- `ceil(x)`
- `round(x)`
- `pow(x, y)` with integral exponent `y`
+21 -4
View File
@@ -1,5 +1,5 @@
/* /*
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com * Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -21,8 +21,8 @@
plugins { plugins {
alias(libs.plugins.kotlinMultiplatform) alias(libs.plugins.kotlinMultiplatform)
// Compose compiler plugin for Kotlin 2.2.21 (matches version catalog) // Compose compiler plugin aligned with the project Kotlin version.
id("org.jetbrains.kotlin.plugin.compose") version "2.2.21" id("org.jetbrains.kotlin.plugin.compose") version "2.3.20"
// Compose Multiplatform plugin for convenient dependencies (compose.html.core, etc.) // Compose Multiplatform plugin for convenient dependencies (compose.html.core, etc.)
id("org.jetbrains.compose") version "1.9.3" id("org.jetbrains.compose") version "1.9.3"
} }
@@ -117,10 +117,27 @@ val generateDocsIndex by tasks.registering {
} }
} }
val generateSiteVersion by tasks.registering(Copy::class) {
group = "documentation"
description = "Generates lyng-version.js from :lynglib version"
val outDir = layout.buildDirectory.dir("generated-resources")
val versionText = project(":lynglib").version.toString()
inputs.property("lyngVersion", versionText)
from(layout.projectDirectory.dir("src/version-template")) {
include("lyng-version.js")
filter<org.apache.tools.ant.filters.ReplaceTokens>(
"tokens" to mapOf("LYNG_VERSION" to versionText)
)
}
into(outDir)
}
// Ensure any ProcessResources task depends on docs index generation so the JSON is packaged // Ensure any ProcessResources task depends on docs index generation so the JSON is packaged
tasks.configureEach { tasks.configureEach {
if (name.endsWith("ProcessResources")) { if (name.endsWith("ProcessResources")) {
dependsOn(generateDocsIndex) dependsOn(generateDocsIndex, generateSiteVersion)
} }
} }
+2
View File
@@ -70,6 +70,7 @@ fun App() {
PageTemplate(title = when { PageTemplate(title = when {
isDocsRoute -> null isDocsRoute -> null
route.startsWith("authors") -> "Authors"
route.startsWith("reference") -> "Reference" route.startsWith("reference") -> "Reference"
route.isBlank() -> null route.isBlank() -> null
else -> null else -> null
@@ -118,6 +119,7 @@ fun App() {
Div({ classes("col-12", if (isDocsRoute) "col-lg-9" else "col-lg-12") }) { Div({ classes("col-12", if (isDocsRoute) "col-lg-9" else "col-lg-12") }) {
when { when {
route.isBlank() -> HomePage() route.isBlank() -> HomePage()
route.startsWith("authors") -> AuthorsPage()
route.startsWith("tryling") -> TryLyngPage(route) route.startsWith("tryling") -> TryLyngPage(route)
route.startsWith("search") -> SearchPage(route) route.startsWith("search") -> SearchPage(route)
!isDocsRoute -> ReferencePage() !isDocsRoute -> ReferencePage()
+63
View File
@@ -0,0 +1,63 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
import androidx.compose.runtime.Composable
import org.jetbrains.compose.web.dom.*
@Composable
fun AuthorsPage() {
Div({ classes("text-center", "mb-4") }) {
P({
classes("lead", "text-muted", "mb-0", "mx-auto")
attr("style", "max-width: 42rem;")
}) {
Text("Designed and built with care. Special thanks to everyone around Lyng who helped shape the language, the tools, and the site into what it is now.")
}
}
Div({ classes("row", "g-4", "justify-content-center") }) {
listOf(
Triple(
"Sergey Chernov",
"Initial idea and architecture, language concept, design, implementation.",
Pair("@sergeych", "https://www.gravatar.com/avatar/7e3a56ff8a090fc9ffbd1909dea94904?s=128&d=identicon")
),
Triple(
"Yulia Nezhinskaya",
"System analysis, math and feature design.",
Pair("@AlterEgoJuliaN", "https://www.gravatar.com/avatar/53a90bca30c85a81db8f0c0d8dea43a1?s=128&d=identicon")
)
).forEach { (name, bio, profile) ->
Div({ classes("col-12", "col-lg-5") }) {
Div({ classes("h-100", "p-4", "border", "rounded-4", "bg-body-tertiary", "text-center") }) {
Img(
src = profile.second,
alt = name,
attrs = {
classes("rounded-circle", "mb-3")
attr("width", "88")
attr("height", "88")
}
)
H2({ classes("h4", "mb-1") }) { Text(name) }
P({ classes("text-primary", "small", "mb-2") }) { Text(profile.first) }
P({ classes("text-muted", "mb-0") }) { Text(bio) }
}
}
}
}
}
+9 -2
View File
@@ -287,8 +287,8 @@ fun HomePage() {
} }
} }
// Bottom section with a small Telegram button // Bottom section with Telegram and authors links
Div({ classes("text-center", "mt-5", "pb-4") }) { Div({ classes("text-center", "mt-5", "d-flex", "justify-content-center", "gap-2", "flex-wrap") }) {
A(attrs = { A(attrs = {
classes("btn", "btn-outline-primary", "btn-sm") classes("btn", "btn-outline-primary", "btn-sm")
attr("href", "https://t.me/lynglang") attr("href", "https://t.me/lynglang")
@@ -298,6 +298,13 @@ fun HomePage() {
I({ classes("bi", "bi-telegram", "me-1") }) I({ classes("bi", "bi-telegram", "me-1") })
Text("Join our Telegram channel") Text("Join our Telegram channel")
} }
A(attrs = {
classes("btn", "btn-outline-secondary", "btn-sm")
attr("href", "#/authors")
}) {
I({ classes("bi", "bi-people", "me-1") })
Text("Meet the authors")
}
} }
} }
+9 -6
View File
@@ -512,8 +512,9 @@ internal fun plainFromMarkdown(md: String): String {
// Use non-greedy dot-all equivalents ("[\n\r\s\S]") instead of character classes with ']' where possible. // Use non-greedy dot-all equivalents ("[\n\r\s\S]") instead of character classes with ']' where possible.
try { try {
// Safer patterns (avoid unescaped ']' inside character classes): // Safer patterns (avoid unescaped ']' inside character classes):
val reCodeBlocks = Regex("```[\\s\\S]*?```") val reBacktickCodeBlocks = Regex("```[\\s\\S]*?```")
val reInlineCode = Regex("`[^`]*`") val reTildeCodeBlocks = Regex("~~~[\\s\\S]*?~~~")
val reInlineCode = Regex("`([^`]*)`")
val reBlockquote = Regex("^> +", setOf(RegexOption.MULTILINE)) val reBlockquote = Regex("^> +", setOf(RegexOption.MULTILINE))
val reHeadings = Regex("^#+ +", setOf(RegexOption.MULTILINE)) val reHeadings = Regex("^#+ +", setOf(RegexOption.MULTILINE))
// Images: ![alt](url) — capture alt lazily with [\s\S]*? to avoid character class pitfalls // Images: ![alt](url) — capture alt lazily with [\s\S]*? to avoid character class pitfalls
@@ -523,9 +524,10 @@ internal fun plainFromMarkdown(md: String): String {
var t = md var t = md
// Triple-backtick code blocks across lines // Triple-backtick code blocks across lines
t = t.replace(reCodeBlocks, " ") t = t.replace(reBacktickCodeBlocks, " ")
// Inline code t = t.replace(reTildeCodeBlocks, " ")
t = t.replace(reInlineCode, " ") // Keep inline code content so API names in prose and headings remain searchable
t = t.replace(reInlineCode, "\$1")
// Strip blockquotes and headings markers // Strip blockquotes and headings markers
t = t.replace(reBlockquote, "") t = t.replace(reBlockquote, "")
t = t.replace(reHeadings, "") t = t.replace(reHeadings, "")
@@ -539,7 +541,8 @@ internal fun plainFromMarkdown(md: String): String {
// Minimal safe fallback: strip code blocks and inline code, then normalize // Minimal safe fallback: strip code blocks and inline code, then normalize
var t = md var t = md
t = t.replace(Regex("```[\\s\\S]*?```"), " ") t = t.replace(Regex("```[\\s\\S]*?```"), " ")
t = t.replace(Regex("`[^`]*`"), " ") t = t.replace(Regex("~~~[\\s\\S]*?~~~"), " ")
t = t.replace(Regex("`([^`]*)`"), "\$1")
return norm(t) return norm(t)
} }
} }
+10 -3
View File
@@ -332,16 +332,22 @@
<script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.11.1/highlight.min.js"></script> <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.11.1/highlight.min.js"></script>
<!-- and it's easy to individually load additional languages --> <!-- and it's easy to individually load additional languages -->
<script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.11.1/languages/go.min.js"></script> <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.11.1/languages/go.min.js"></script>
<script src="lyng-version.js"></script>
</head> </head>
<body> <body>
<!-- Top-left version ribbon --> <!-- Top-left version ribbon -->
<div class="corner-ribbon bg-danger text-white"> <div class="corner-ribbon bg-danger text-white">
<span style="margin-left: -5em"> <span id="lyng-version-ribbon" style="margin-left: -5em">
v1.5.1
</span> </span>
</div> </div>
<script>
document.addEventListener("DOMContentLoaded", function () {
var ribbon = document.getElementById("lyng-version-ribbon");
if (ribbon) ribbon.textContent = "v" + (window.LYNG_VERSION || "");
});
</script>
<!-- Fixed top navbar for the whole site --> <!-- Fixed top navbar for the whole site -->
<a href="#root" class="visually-hidden-focusable position-absolute top-0 start-0 m-2 px-2 py-1 bg-body border rounded">Skip <a href="#root" class="visually-hidden-focusable position-absolute top-0 start-0 m-2 px-2 py-1 bg-body border rounded">Skip
to content</a> to content</a>
@@ -384,6 +390,7 @@
<!-- Will be populated at runtime --> <!-- Will be populated at runtime -->
<li><a class="dropdown-item" href="#/docs/tutorial.md" data-route="docs">Tutorial</a></li> <li><a class="dropdown-item" href="#/docs/tutorial.md" data-route="docs">Tutorial</a></li>
<li><a class="dropdown-item" href="#/reference" data-route="reference">Reference</a></li> <li><a class="dropdown-item" href="#/reference" data-route="reference">Reference</a></li>
<li><a class="dropdown-item" href="#/authors" data-route="authors">Authors</a></li>
<li> <li>
<hr class="dropdown-divider"> <hr class="dropdown-divider">
</li> </li>
@@ -485,7 +492,7 @@
var activeLink = null; var activeLink = null;
if (!hash || hash === '#' || hash === '#/') { if (!hash || hash === '#' || hash === '#/') {
activeLink = document.querySelector('#topbarNav .nav-link[data-route="home"]'); activeLink = document.querySelector('#topbarNav .nav-link[data-route="home"]');
} else if (hash.startsWith('#/docs/')) { } else if (hash.startsWith('#/docs/') || hash.startsWith('#/authors')) {
// Mark Docs menu root as active // Mark Docs menu root as active
activeLink = document.querySelector('#topbarNav .nav-link.dropdown-toggle'); activeLink = document.querySelector('#topbarNav .nav-link.dropdown-toggle');
} else if (hash.startsWith('#/reference')) { } else if (hash.startsWith('#/reference')) {
@@ -1,5 +1,23 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
import kotlin.test.Test import kotlin.test.Test
import kotlin.test.assertEquals import kotlin.test.assertEquals
import kotlin.test.assertFalse
import kotlin.test.assertTrue import kotlin.test.assertTrue
class SearchScoringTest { class SearchScoringTest {
@@ -26,4 +44,31 @@ class SearchScoringTest {
val sFar = scoreQueryAdvanced(listOf("alp", "bet"), far) val sFar = scoreQueryAdvanced(listOf("alp", "bet"), far)
assertTrue(sNear > sFar, "closer terms should have higher score") assertTrue(sNear > sFar, "closer terms should have higher score")
} }
@Test
fun preservesInlineCodeTermsInHeadingsAndText() {
val plain = plainFromMarkdown(
"""
### Preferred runtime: `EvalSession`
For host applications, prefer `EvalSession` as the main way to run scripts.
""".trimIndent()
)
assertTrue(plain.contains("evalsession"), "inline code terms should remain in searchable text")
assertTrue(scoreQueryAdvanced(listOf("evalsession"), rec(plain)) > 0)
}
@Test
fun stripsTildeCodeFencesLikeBacktickFences() {
val plain = plainFromMarkdown(
"""
~~~kotlin
val session = EvalSession()
~~~
""".trimIndent()
)
assertFalse(plain.contains("evalsession"), "fenced code should not leak into the search corpus")
}
} }
+18
View File
@@ -0,0 +1,18 @@
#!/binenv lyng
import lyng.decimal
val x = "0.1".d
val y = 0.1
var s0 = 0.d
var s1 = 0.0
for( i in 1..100 ) {
s0 += x
s1 += y
}
println("$s0")
println("$s1")
println(":: ${sin(3.14)}")