Compare commits
34
Commits
1.5.1
..
446c8d9a6e
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
446c8d9a6e | ||
|
|
c140567e0c | ||
|
|
311cf6ee44 | ||
|
|
3e338f3d53 | ||
|
|
c097464750 | ||
|
|
6e9333844e | ||
|
|
a976702caf | ||
|
|
850efedb72 | ||
|
|
f845213332 | ||
|
|
cdd48ec871 | ||
|
|
286ec30422 | ||
|
|
8a560f5417 | ||
|
|
966b6a31ae | ||
|
|
c3c0a3292b | ||
|
|
aa9565b40b | ||
|
|
05d7432b37 | ||
|
|
c7c333b71a | ||
|
|
e55d9c835a | ||
|
|
83d8c8b71f | ||
|
|
a72991d1b7 | ||
|
|
cd007050a8 | ||
|
|
418b1ae2b6 | ||
|
|
b0fb65a036 | ||
|
|
86e8b2e2bc | ||
|
|
a98fe51983 | ||
|
|
f8d36beae1 | ||
|
|
580256d520 | ||
|
|
5ab074ba9e | ||
|
|
4269310beb | ||
|
|
7c059b4741 | ||
|
|
217787e17a | ||
|
|
9ddc7dbee6 | ||
|
|
24937c7cf5 | ||
|
|
ecc4d8b9ed |
No files matched your search
@@ -27,3 +27,4 @@ debug.log
|
||||
/compile_jvm_output.txt
|
||||
/compile_metadata_output.txt
|
||||
test_output*.txt
|
||||
/site/src/version-template/lyng-version.js
|
||||
@@ -221,17 +221,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] kotlin part public API good docs, integration focused
|
||||
- [ ] type specifications
|
||||
- [x] type specifications
|
||||
- [x] Textmate Bundle
|
||||
- [x] IDEA plugin
|
||||
- [ ] source docs and maybe lyng.md to a standard
|
||||
- [ ] metadata first class access from lyng
|
||||
- [x] source docs and maybe lyng.md to a standard
|
||||
- [x] aggressive optimizations
|
||||
- [ ] compile to JVM bytecode optimization
|
||||
|
||||
## After 1.5 "Ideal scripting"
|
||||
|
||||
Estimated summer 2026
|
||||
* __we are here now ;)__
|
||||
|
||||
- propose your feature!
|
||||
|
||||
@@ -239,8 +237,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.
|
||||
|
||||
__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
|
||||
@@ -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)
|
||||
@@ -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
|
||||
[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:
|
||||
|
||||
## Binary search
|
||||
|
||||
@@ -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.
|
||||
+325
@@ -0,0 +1,325 @@
|
||||
# Decimal (`lyng.decimal`)
|
||||
|
||||
`lyng.decimal` adds an arbitrary-precision decimal type to Lyng as a normal library module.
|
||||
|
||||
Import it when you need decimal arithmetic that should not inherit `Real`'s binary floating-point behavior:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
```
|
||||
|
||||
## What `Decimal` Is For
|
||||
|
||||
Use `Decimal` when values are fundamentally decimal:
|
||||
|
||||
- money
|
||||
- human-entered quantities
|
||||
- exact decimal text
|
||||
- predictable decimal rounding
|
||||
- user-facing formatting and tests
|
||||
|
||||
Do not use it just because a number has a fractional part. `Real` is still the right type for ordinary double-precision numeric work.
|
||||
|
||||
## Creating Decimal Values
|
||||
|
||||
There are three supported conversions:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
val a = 1.d
|
||||
val b = 2.2.d
|
||||
val c = "2.2".d
|
||||
|
||||
assertEquals("1", a.toStringExpanded())
|
||||
assertEquals("2.2", b.toStringExpanded())
|
||||
assertEquals("2.2", c.toStringExpanded())
|
||||
```
|
||||
|
||||
The three forms mean different things:
|
||||
|
||||
- `1.d`: convert `Int -> Decimal`
|
||||
- `2.2.d`: convert `Real -> Decimal`
|
||||
- `"2.2".d`: parse exact decimal text
|
||||
|
||||
That distinction is intentional.
|
||||
|
||||
### `Real.d` vs `"..." .d`
|
||||
|
||||
`Real.d` preserves the current `Real` value. It does not pretend the source code was exact decimal text.
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
assertEquals("0.30000000000000004", (0.1 + 0.2).d.toStringExpanded())
|
||||
assertEquals("0.3", "0.3".d.toStringExpanded())
|
||||
```
|
||||
|
||||
This follows the "minimal confusion" rule:
|
||||
|
||||
- if you start from a `Real`, you get a decimal representation of that `Real`
|
||||
- if you want exact decimal source text, use a `String`
|
||||
|
||||
## Factory Functions
|
||||
|
||||
The explicit factory methods are:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
Decimal.fromInt(10)
|
||||
Decimal.fromReal(2.5)
|
||||
Decimal.fromString("12.34")
|
||||
```
|
||||
|
||||
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.Script
|
||||
import net.sergeych.lyng.asFacade
|
||||
import net.sergeych.lyng.newDecimal
|
||||
|
||||
val scope = Script.newScope()
|
||||
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
|
||||
|
||||
`Decimal` supports:
|
||||
|
||||
- `+`
|
||||
- `-`
|
||||
- `*`
|
||||
- `/`
|
||||
- `%`
|
||||
- unary `-`
|
||||
- comparison operators
|
||||
- equality operators
|
||||
|
||||
Examples:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
assertEquals("3.75", ("1.5".d + "2.25".d).toStringExpanded())
|
||||
assertEquals("1.25", ("2.5".d - "1.25".d).toStringExpanded())
|
||||
assertEquals("3.0", ("1.5".d * 2.d).toStringExpanded())
|
||||
assertEquals("0.5", (1.d / 2.d).toStringExpanded())
|
||||
assert("2.0".d > "1.5".d)
|
||||
assert("2.0".d == 2.d)
|
||||
```
|
||||
|
||||
## Interoperability With `Int` and `Real`
|
||||
|
||||
The decimal module registers mixed-operand operator bridges so both sides read naturally:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
assertEquals(3.d, 1 + 2.d)
|
||||
assertEquals(3.d, 2.d + 1)
|
||||
assertEquals(1.5.d, 1.d + 0.5)
|
||||
assertEquals(1.5.d, 0.5 + 1.d)
|
||||
assert(2 == 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 + Decimal` and `Real + Decimal`.
|
||||
|
||||
See [OperatorInterop.md](OperatorInterop.md) for the generic mechanism behind that.
|
||||
|
||||
## String Representation
|
||||
|
||||
Use `toStringExpanded()` when you want plain decimal output without scientific notation:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
assertEquals("12.34", "12.34".d.toStringExpanded())
|
||||
```
|
||||
|
||||
This is the recommended representation for:
|
||||
|
||||
- tests
|
||||
- user-visible diagnostics
|
||||
- decimal formatting checks
|
||||
|
||||
## Conversions Back To Built-ins
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
assertEquals(2, "2.9".d.toInt())
|
||||
assertEquals(2.9, "2.9".d.toReal())
|
||||
```
|
||||
|
||||
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 is the operation where precision and rounding matter most.
|
||||
|
||||
By default, decimal division uses:
|
||||
|
||||
- precision: `34` significant digits
|
||||
- rounding: `HalfEven`
|
||||
|
||||
Example:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
assertEquals("0.3333333333333333333333333333333333", (1.d / 3.d).toStringExpanded())
|
||||
assertEquals("0.6666666666666666666666666666666667", ("2".d / 3.d).toStringExpanded())
|
||||
```
|
||||
|
||||
## `withDecimalContext(...)`
|
||||
|
||||
Use `withDecimalContext(...)` to override decimal division rules inside a block:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
assertEquals(
|
||||
"0.3333333333",
|
||||
withDecimalContext(10) { (1.d / 3.d).toStringExpanded() }
|
||||
)
|
||||
```
|
||||
|
||||
You can also pass an explicit context object:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
val ctx = DecimalContext(6, DecimalRounding.HalfAwayFromZero)
|
||||
assertEquals("0.666667", withDecimalContext(ctx) { ("2".d / 3.d).toStringExpanded() })
|
||||
```
|
||||
|
||||
The context is dynamic and local to the block. After the block exits, the previous context is restored.
|
||||
|
||||
## Rounding Modes
|
||||
|
||||
Available rounding modes:
|
||||
|
||||
- `HalfEven`
|
||||
- `HalfAwayFromZero`
|
||||
- `HalfTowardsZero`
|
||||
- `Ceiling`
|
||||
- `Floor`
|
||||
- `AwayFromZero`
|
||||
- `TowardsZero`
|
||||
|
||||
Tie example at precision `2`:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
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.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.Floor) { (1.d / 8.d).toStringExpanded() })
|
||||
```
|
||||
|
||||
Negative values follow the same named policy in the obvious direction:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
assertEquals("-0.13", withDecimalContext(2, DecimalRounding.HalfAwayFromZero) { (-1.d / 8.d).toStringExpanded() })
|
||||
assertEquals("-0.12", withDecimalContext(2, DecimalRounding.HalfTowardsZero) { (-1.d / 8.d).toStringExpanded() })
|
||||
```
|
||||
|
||||
## 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:
|
||||
|
||||
```lyng
|
||||
"12.34".d
|
||||
```
|
||||
|
||||
If you intentionally convert an existing binary floating-point value:
|
||||
|
||||
```lyng
|
||||
someReal.d
|
||||
```
|
||||
|
||||
If you want local control over division:
|
||||
|
||||
```lyng
|
||||
withDecimalContext(precision, rounding) { ... }
|
||||
```
|
||||
|
||||
If you want custom mixed operators for your own type, follow the same pattern as Decimal and use the operator registry:
|
||||
|
||||
- define the operators on your own class
|
||||
- choose a common class
|
||||
- register mixed operand bridges
|
||||
|
||||
See [OperatorInterop.md](OperatorInterop.md).
|
||||
@@ -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.
|
||||
|
||||
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
|
||||
|
||||
You can concatenate lists or iterable objects:
|
||||
|
||||
+192
@@ -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
@@ -1183,8 +1183,24 @@ collection's sugar won't work with it:
|
||||
assertEquals("buzz", x[0])
|
||||
>>> void
|
||||
|
||||
If you want dynamic to function like an array, create a [feature
|
||||
request](https://gitea.sergeych.net/SergeychWorks/lyng/issues).
|
||||
Multiple selectors are packed into one list index object:
|
||||
|
||||
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
|
||||
|
||||
|
||||
@@ -0,0 +1,309 @@
|
||||
# Operator Interop Registry
|
||||
|
||||
`lyng.operators` provides a runtime registry for mixed-class binary operators.
|
||||
|
||||
Import it when you want expressions such as:
|
||||
|
||||
- `1 + MyType(...)`
|
||||
- `2 < MyType(...)`
|
||||
- `3 == MyType(...)`
|
||||
|
||||
to work without modifying the built-in `Int` or `Real` classes.
|
||||
|
||||
```lyng
|
||||
import lyng.operators
|
||||
```
|
||||
|
||||
## Why This Exists
|
||||
|
||||
If your class defines:
|
||||
|
||||
```lyng
|
||||
class Amount(val value: Int) {
|
||||
fun plus(other: Amount) = Amount(value + other.value)
|
||||
}
|
||||
```
|
||||
|
||||
then:
|
||||
|
||||
```lyng
|
||||
Amount(1) + Amount(2)
|
||||
```
|
||||
|
||||
works, because the left operand already knows how to add another `Amount`.
|
||||
|
||||
But:
|
||||
|
||||
```lyng
|
||||
1 + Amount(2)
|
||||
```
|
||||
|
||||
does not naturally work, because `Int` has not been rewritten to know about `Amount`.
|
||||
|
||||
The operator interop registry solves exactly that problem.
|
||||
|
||||
## Mental Model
|
||||
|
||||
Registration describes a mixed pair:
|
||||
|
||||
- left class `L`
|
||||
- right class `R`
|
||||
- common class `C`
|
||||
|
||||
When Lyng sees `L op R`, it:
|
||||
|
||||
1. converts `L -> C`
|
||||
2. converts `R -> C`
|
||||
3. evaluates the operator as `C op C`
|
||||
|
||||
So the registry is a bridge, not a separate arithmetic engine.
|
||||
|
||||
## API
|
||||
|
||||
```lyng
|
||||
OperatorInterop.register(
|
||||
leftClass,
|
||||
rightClass,
|
||||
commonClass,
|
||||
operators,
|
||||
leftToCommon,
|
||||
rightToCommon
|
||||
)
|
||||
```
|
||||
|
||||
Parameters:
|
||||
|
||||
- `leftClass`: original left operand class
|
||||
- `rightClass`: original right operand class
|
||||
- `commonClass`: class that will actually execute the operator methods
|
||||
- `operators`: list of operators enabled for this pair
|
||||
- `leftToCommon`: conversion from left operand to common class
|
||||
- `rightToCommon`: conversion from right operand to common class
|
||||
|
||||
## Supported Operators
|
||||
|
||||
`BinaryOperator` values:
|
||||
|
||||
- `Plus`
|
||||
- `Minus`
|
||||
- `Mul`
|
||||
- `Div`
|
||||
- `Mod`
|
||||
- `Compare`
|
||||
- `Equals`
|
||||
|
||||
Meaning:
|
||||
|
||||
- `Compare` enables `<`, `<=`, `>`, `>=`, and `<=>`
|
||||
- `Equals` enables `==` and `!=`
|
||||
|
||||
## Minimal Working Example
|
||||
|
||||
```lyng
|
||||
package test.decimalbox
|
||||
import lyng.operators
|
||||
|
||||
class DecimalBox(val value: Int) {
|
||||
fun plus(other: DecimalBox) = DecimalBox(value + other.value)
|
||||
fun minus(other: DecimalBox) = DecimalBox(value - other.value)
|
||||
fun mul(other: DecimalBox) = DecimalBox(value * other.value)
|
||||
fun div(other: DecimalBox) = DecimalBox(value / other.value)
|
||||
fun mod(other: DecimalBox) = DecimalBox(value % other.value)
|
||||
fun compareTo(other: DecimalBox) = value <=> other.value
|
||||
}
|
||||
|
||||
OperatorInterop.register(
|
||||
Int,
|
||||
DecimalBox,
|
||||
DecimalBox,
|
||||
[
|
||||
BinaryOperator.Plus,
|
||||
BinaryOperator.Minus,
|
||||
BinaryOperator.Mul,
|
||||
BinaryOperator.Div,
|
||||
BinaryOperator.Mod,
|
||||
BinaryOperator.Compare,
|
||||
BinaryOperator.Equals
|
||||
],
|
||||
{ x: Int -> DecimalBox(x) },
|
||||
{ x: DecimalBox -> x }
|
||||
)
|
||||
```
|
||||
|
||||
Then:
|
||||
|
||||
```lyng
|
||||
import test.decimalbox
|
||||
|
||||
assertEquals(DecimalBox(3), 1 + DecimalBox(2))
|
||||
assertEquals(DecimalBox(1), 3 - DecimalBox(2))
|
||||
assertEquals(DecimalBox(8), 4 * DecimalBox(2))
|
||||
assertEquals(DecimalBox(4), 8 / DecimalBox(2))
|
||||
assertEquals(DecimalBox(1), 7 % DecimalBox(2))
|
||||
assert(1 < DecimalBox(2))
|
||||
assert(2 <= DecimalBox(2))
|
||||
assert(3 > DecimalBox(2))
|
||||
assert(2 == DecimalBox(2))
|
||||
assert(2 != DecimalBox(3))
|
||||
```
|
||||
|
||||
## How Decimal Uses It
|
||||
|
||||
`lyng.decimal` uses this same mechanism so that:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
1 + 2.d
|
||||
0.5 + 1.d
|
||||
2 == 2.d
|
||||
3 > 2.d
|
||||
```
|
||||
|
||||
work naturally even though `Int` and `Real` themselves were not edited to know `Decimal`.
|
||||
|
||||
The shape is:
|
||||
|
||||
- `leftClass = Int` or `Real`
|
||||
- `rightClass = Decimal`
|
||||
- `commonClass = Decimal`
|
||||
- convert built-ins into `Decimal`
|
||||
- leave `Decimal` values unchanged
|
||||
|
||||
## Step-By-Step Pattern For Your Own Type
|
||||
|
||||
### 1. Pick the common class
|
||||
|
||||
Choose one class that will be the actual arithmetic domain.
|
||||
|
||||
For numeric-like types, that is usually your own class:
|
||||
|
||||
```lyng
|
||||
class Rational(...)
|
||||
```
|
||||
|
||||
### 2. Implement operators on that class
|
||||
|
||||
The common class should define the operations you plan to register.
|
||||
|
||||
Example:
|
||||
|
||||
```lyng
|
||||
class Rational(val num: Int, val den: Int) {
|
||||
fun plus(other: Rational) = Rational(num * other.den + other.num * den, den * other.den)
|
||||
fun minus(other: Rational) = Rational(num * other.den - other.num * den, den * other.den)
|
||||
fun mul(other: Rational) = Rational(num * other.num, den * other.den)
|
||||
fun div(other: Rational) = Rational(num * other.den, den * other.num)
|
||||
fun compareTo(other: Rational) = (num * other.den) <=> (other.num * den)
|
||||
|
||||
static fun fromInt(value: Int) = Rational(value, 1)
|
||||
}
|
||||
```
|
||||
|
||||
### 3. Register the mixed pair
|
||||
|
||||
```lyng
|
||||
import lyng.operators
|
||||
|
||||
OperatorInterop.register(
|
||||
Int,
|
||||
Rational,
|
||||
Rational,
|
||||
[
|
||||
BinaryOperator.Plus,
|
||||
BinaryOperator.Minus,
|
||||
BinaryOperator.Mul,
|
||||
BinaryOperator.Div,
|
||||
BinaryOperator.Compare,
|
||||
BinaryOperator.Equals
|
||||
],
|
||||
{ x: Int -> Rational.fromInt(x) },
|
||||
{ x: Rational -> x }
|
||||
)
|
||||
```
|
||||
|
||||
### 4. Use it
|
||||
|
||||
```lyng
|
||||
assertEquals(Rational(3, 2), 1 + Rational(1, 2))
|
||||
assert(Rational(3, 2) == Rational(3, 2))
|
||||
assert(2 > Rational(3, 2))
|
||||
```
|
||||
|
||||
## Registering More Than One Built-in Type
|
||||
|
||||
If you want both `Int + MyType` and `Real + MyType`, register both pairs explicitly:
|
||||
|
||||
```lyng
|
||||
OperatorInterop.register(
|
||||
Int,
|
||||
MyType,
|
||||
MyType,
|
||||
[BinaryOperator.Plus, BinaryOperator.Compare, BinaryOperator.Equals],
|
||||
{ x: Int -> MyType.fromInt(x) },
|
||||
{ x: MyType -> x }
|
||||
)
|
||||
|
||||
OperatorInterop.register(
|
||||
Real,
|
||||
MyType,
|
||||
MyType,
|
||||
[BinaryOperator.Plus, BinaryOperator.Compare, BinaryOperator.Equals],
|
||||
{ x: Real -> MyType.fromReal(x) },
|
||||
{ x: MyType -> x }
|
||||
)
|
||||
```
|
||||
|
||||
Each mixed pair is independent.
|
||||
|
||||
## Pure Lyng Registration
|
||||
|
||||
This mechanism is intentionally useful from pure Lyng code, not only from Kotlin-backed modules.
|
||||
|
||||
That means you can:
|
||||
|
||||
- declare a class in Lyng
|
||||
- define its operators in Lyng
|
||||
- register mixed operand bridges in Lyng
|
||||
|
||||
without touching compiler internals.
|
||||
|
||||
## Where To Register
|
||||
|
||||
Register once during module initialization.
|
||||
|
||||
Top-level module code is a good place:
|
||||
|
||||
```lyng
|
||||
package my.rational
|
||||
import lyng.operators
|
||||
|
||||
class Rational(...)
|
||||
|
||||
OperatorInterop.register(...)
|
||||
```
|
||||
|
||||
That keeps registration close to the type declaration and makes importing the module enough to activate the interop.
|
||||
|
||||
## What Registration Does Not Do
|
||||
|
||||
The registry does not:
|
||||
|
||||
- invent operators your common class does not implement
|
||||
- change the original `Int`, `Real`, or other built-ins
|
||||
- automatically cover every class pair
|
||||
- replace normal method overload resolution when the left-hand class already knows what to do
|
||||
|
||||
It only teaches Lyng how to bridge a specific mixed pair into a common class for the listed operators.
|
||||
|
||||
## Recommended Design Rules
|
||||
|
||||
If you want interop to feel natural:
|
||||
|
||||
- choose one obvious common class
|
||||
- make conversions explicit and unsurprising
|
||||
- implement `compareTo` if you want ordering operators
|
||||
- register `Equals` whenever mixed equality should work
|
||||
- keep the registered operator list minimal and accurate
|
||||
|
||||
For decimal-like semantics, also read [Decimal.md](Decimal.md).
|
||||
@@ -19,6 +19,8 @@ you can use it's class to ensure type:
|
||||
|-----------------|-------------------------------------------------------------|------|
|
||||
| `.roundToInt()` | round to nearest int like round(x) | 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 |
|
||||
| | | |
|
||||
| | | |
|
||||
|
||||
@@ -82,11 +82,16 @@ Primary sources used: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/{Parser,T
|
||||
- Type/containment: `is`, `!is`, `in`, `!in`, `as`, `as?`.
|
||||
- Null-safe family:
|
||||
- member access: `?.`
|
||||
- safe index: `?[i]`
|
||||
- safe index: `?[i]`, `?[i, j]`
|
||||
- safe invoke: `?(...)`
|
||||
- safe block invoke: `?{ ... }`
|
||||
- elvis: `?:` and `??`.
|
||||
- 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
|
||||
- Variables:
|
||||
|
||||
@@ -14,7 +14,13 @@ Sources: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt`, `lynglib/s
|
||||
- Assertions/tests: `assert`, `assertEquals`/`assertEqual`, `assertNotEquals`, `assertThrows`.
|
||||
- Preconditions: `require`, `check`.
|
||||
- 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`.
|
||||
- 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
|
||||
- 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`.
|
||||
- Random: singleton `Random` and class `SeededRandom`.
|
||||
- Async types: `Deferred`, `CompletableDeferred`, `Mutex`, `Flow`, `FlowBuilder`.
|
||||
- Async exception: `CancellationException`.
|
||||
- Delegation types: `Delegate`, `DelegateContext`.
|
||||
- Regex types: `Regex`, `RegexMatch`.
|
||||
- Also present: `Math.PI` namespace constant.
|
||||
|
||||
## 4. `lyng.stdlib` Module Surface (from `root.lyng`)
|
||||
### 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>`.
|
||||
- Host iterator bridge: `KotlinIterator<T>`.
|
||||
- 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)
|
||||
- `import lyng.observable`
|
||||
- `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`
|
||||
- `Buffer`, `MutableBuffer`.
|
||||
- `import lyng.serialization`
|
||||
|
||||
@@ -72,6 +72,14 @@ For module-level APIs, the default workflow is:
|
||||
1. declare globals in Lyng using `extern fun` / `extern val` / `extern var`;
|
||||
2. bind Kotlin implementation via `ModuleScope.globalBinder()`.
|
||||
|
||||
This is also the recommended way to expose a Kotlin-backed value that should behave like a true
|
||||
Lyng global variable/property. If you need `x` to read/write through Kotlin on every access, use
|
||||
`extern var` / `extern val` plus `bindGlobalVar(...)`.
|
||||
|
||||
Do not use `addConst(...)` for this case: `addConst(...)` installs a value, not a Kotlin-backed
|
||||
property accessor. It is appropriate for fixed values and objects, but not for a global that should
|
||||
delegate reads/writes back into Kotlin state.
|
||||
|
||||
```kotlin
|
||||
import net.sergeych.lyng.bridge.*
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
@@ -117,6 +125,12 @@ assertEquals("changed", globalProp)
|
||||
assertEquals("1.0.0", globalVersion)
|
||||
```
|
||||
|
||||
Minimal rule of thumb:
|
||||
|
||||
- use `bindGlobalFun(...)` for global functions
|
||||
- use `bindGlobalVar(...)` for Kotlin-backed global variables/properties
|
||||
- use `addConst(...)` only for fixed values/objects that do not need getter/setter behavior
|
||||
|
||||
For custom argument handling and full runtime access:
|
||||
|
||||
```kotlin
|
||||
@@ -169,6 +183,72 @@ 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.
|
||||
|
||||
### 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
|
||||
|
||||
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.
|
||||
@@ -462,14 +542,21 @@ im.addPackage("my.tools") { module: ModuleScope ->
|
||||
module.eval(
|
||||
"""
|
||||
extern val version: String
|
||||
extern var status: String
|
||||
extern fun triple(x: Int): Int
|
||||
""".trimIndent()
|
||||
)
|
||||
val binder = module.globalBinder()
|
||||
var status = "ready"
|
||||
binder.bindGlobalVar(
|
||||
name = "version",
|
||||
get = { "1.0" }
|
||||
)
|
||||
binder.bindGlobalVar(
|
||||
name = "status",
|
||||
get = { status },
|
||||
set = { status = it }
|
||||
)
|
||||
binder.bindGlobalFun1<Int>("triple") { x ->
|
||||
ObjInt.of((x * 3).toLong())
|
||||
}
|
||||
@@ -479,6 +566,7 @@ im.addPackage("my.tools") { module: ModuleScope ->
|
||||
scope.eval("""
|
||||
import my.tools.*
|
||||
val v = triple(14)
|
||||
status = "busy"
|
||||
""")
|
||||
val v = scope.eval("v").toKotlin(scope) // -> 42
|
||||
```
|
||||
|
||||
+73
-3
@@ -60,8 +60,13 @@ but:
|
||||
|
||||
## Round and range
|
||||
|
||||
The following functions return its argument if it is `Int`,
|
||||
or transformed `Real` otherwise.
|
||||
The following functions return the argument unchanged if it is `Int`.
|
||||
|
||||
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 |
|
||||
|----------------|--------------------------------------------------------|
|
||||
@@ -72,6 +77,14 @@ or transformed `Real` otherwise.
|
||||
|
||||
## 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 |
|
||||
|-----------|------------------------------------------------------|
|
||||
| sin(x) | sine |
|
||||
@@ -91,7 +104,7 @@ or transformed `Real` otherwise.
|
||||
| log10(x) | $log_{10}(x)$ |
|
||||
| pow(x, y) | ${x^y}$ |
|
||||
| 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 |
|
||||
|
||||
For example:
|
||||
@@ -104,12 +117,69 @@ For example:
|
||||
assert( abs(-1) is Int)
|
||||
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:
|
||||
assert( clamp(15, 0..10) == 10 )
|
||||
assert( clamp(-5, 0..10) == 0 )
|
||||
assert( 5.clamp(0..10) == 5 )
|
||||
>>> 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
|
||||
|
||||
Lyng stdlib provides a global random singleton and deterministic seeded generators:
|
||||
|
||||
+16
-1
@@ -32,10 +32,25 @@ Depending on the platform, these coroutines may be executed on different CPU and
|
||||
assert(xIsCalled)
|
||||
>>> void
|
||||
|
||||
This example shows how to launch a coroutine with `launch` which returns [Deferred] instance, the latter have ways to await for the coroutine completion and retrieve possible result.
|
||||
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.
|
||||
|
||||
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
|
||||
|
||||
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:
|
||||
|
||||
@@ -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.
|
||||
|
||||
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
|
||||
|
||||
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).
|
||||
|
||||
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:
|
||||
|
||||
[1, ...[2,3], 4]
|
||||
@@ -1699,6 +1719,14 @@ Open-ended ranges could be used to get start and end too:
|
||||
assertEquals( "pult", "catapult"[ 4.. ])
|
||||
>>> 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
|
||||
|
||||
Concatenation is a `+`: `"hello " + name` works as expected. No confusion. There is also
|
||||
|
||||
@@ -5,6 +5,120 @@ For a programmer-focused migration summary, see `docs/whats_new_1_5.md`.
|
||||
|
||||
## 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`)
|
||||
Lyng now ships a first-class decimal module built as a regular extension library rather than a deep core special case.
|
||||
|
||||
It provides:
|
||||
|
||||
- `Decimal`
|
||||
- convenient `.d` conversions from `Int`, `Real`, and `String`
|
||||
- mixed arithmetic with `Int` and `Real`
|
||||
- local division precision and rounding control via `withDecimalContext(...)`
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
assertEquals("3", (1 + 2.d).toStringExpanded())
|
||||
assertEquals("0.30000000000000004", (0.1 + 0.2).d.toStringExpanded())
|
||||
assertEquals("0.3", "0.3".d.toStringExpanded())
|
||||
|
||||
assertEquals(
|
||||
"0.3333333333",
|
||||
withDecimalContext(10) { (1.d / 3.d).toStringExpanded() }
|
||||
)
|
||||
```
|
||||
|
||||
The distinction between `Real -> Decimal` and exact decimal parsing is explicit by design:
|
||||
|
||||
- `2.2.d` converts the current `Real` value
|
||||
- `"2.2".d` parses exact decimal text
|
||||
|
||||
See [Decimal](Decimal.md).
|
||||
|
||||
### Binary Operator Interop Registry
|
||||
Lyng now provides a general mechanism for mixed binary operators through `lyng.operators`.
|
||||
|
||||
This solves cases like:
|
||||
|
||||
- `Int + MyType`
|
||||
- `Real < MyType`
|
||||
- `Int == MyType`
|
||||
|
||||
without requiring changes to built-in classes.
|
||||
|
||||
```lyng
|
||||
import lyng.operators
|
||||
|
||||
class DecimalBox(val value: Int) {
|
||||
fun plus(other: DecimalBox) = DecimalBox(value + other.value)
|
||||
fun compareTo(other: DecimalBox) = value <=> other.value
|
||||
}
|
||||
|
||||
OperatorInterop.register(
|
||||
Int,
|
||||
DecimalBox,
|
||||
DecimalBox,
|
||||
[BinaryOperator.Plus, BinaryOperator.Compare, BinaryOperator.Equals],
|
||||
{ x: Int -> DecimalBox(x) },
|
||||
{ x: DecimalBox -> x }
|
||||
)
|
||||
|
||||
assertEquals(DecimalBox(3), 1 + DecimalBox(2))
|
||||
assert(1 < DecimalBox(2))
|
||||
assert(2 == DecimalBox(2))
|
||||
```
|
||||
|
||||
`lyng.decimal` uses this same mechanism internally to interoperate with `Int` and `Real`.
|
||||
|
||||
See [Operator Interop Registry](OperatorInterop.md).
|
||||
|
||||
### Class Properties with Accessors
|
||||
Classes now support properties with custom `get()` and `set()` accessors. Properties in Lyng do **not** have automatic backing fields; they are pure accessors.
|
||||
|
||||
|
||||
@@ -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("Расчёт не сошёлся")
|
||||
}
|
||||
+2
-5
@@ -27,9 +27,6 @@ kotlin.mpp.enableCInteropCommonization=true
|
||||
android.useAndroidX=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.
|
||||
# On this environment, the system JDK 21 installation lacks `jlink`, causing
|
||||
# :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
|
||||
android.experimental.lint.migrateToK2=false
|
||||
android.lint.useK2Uast=false
|
||||
kotlin.mpp.applyDefaultHierarchyTemplate=true
|
||||
kotlin.mpp.applyDefaultHierarchyTemplate=false
|
||||
|
||||
org.gradle.parallel=true
|
||||
org.gradle.parallel=true
|
||||
@@ -2,12 +2,14 @@
|
||||
agp = "8.5.2"
|
||||
clikt = "5.0.3"
|
||||
mordant = "3.0.2"
|
||||
kotlin = "2.3.0"
|
||||
kotlin = "2.3.20"
|
||||
android-minSdk = "24"
|
||||
android-compileSdk = "34"
|
||||
kotlinx-coroutines = "1.10.2"
|
||||
kotlinx-datetime = "0.6.1"
|
||||
mp_bintools = "0.3.2"
|
||||
ionspin-bignum = "0.3.10"
|
||||
multik = "0.3.0"
|
||||
firebaseCrashlyticsBuildtools = "3.0.3"
|
||||
okioVersion = "3.10.2"
|
||||
compiler = "3.2.0-alpha11"
|
||||
@@ -22,6 +24,8 @@ kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-t
|
||||
kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx-coroutines" }
|
||||
kotlinx-datetime = { module = "org.jetbrains.kotlinx:kotlinx-datetime", version.ref = "kotlinx-datetime" }
|
||||
mp_bintools = { module = "net.sergeych:mp_bintools", version.ref = "mp_bintools" }
|
||||
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" }
|
||||
okio = { module = "com.squareup.okio:okio", 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.AnActionEvent
|
||||
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.wm.ToolWindow
|
||||
import com.intellij.openapi.wm.ToolWindowAnchor
|
||||
@@ -36,9 +38,10 @@ import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.SupervisorJob
|
||||
import kotlinx.coroutines.launch
|
||||
import net.sergeych.lyng.idea.LyngIcons
|
||||
import java.io.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? {
|
||||
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) {
|
||||
val psiFile = getPsiFile(e)
|
||||
val isLyng = psiFile?.name?.endsWith(".lyng") == true
|
||||
e.presentation.isEnabledAndVisible = isLyng
|
||||
if (isLyng) {
|
||||
e.presentation.isEnabled = false
|
||||
e.presentation.text = "Run '${psiFile.name}' (disabled)"
|
||||
e.presentation.description = "Running scripts from the IDE is disabled; use the CLI."
|
||||
val psiFile = getRunnableFile(e)
|
||||
val isRunnable = psiFile != null
|
||||
e.presentation.isEnabledAndVisible = isRunnable
|
||||
if (isRunnable) {
|
||||
e.presentation.text = "Run '${psiFile.name}'"
|
||||
e.presentation.description = "Run the current Lyng script using the Lyng CLI"
|
||||
} else {
|
||||
e.presentation.text = "Run Lyng Script"
|
||||
e.presentation.description = "Run the current Lyng script"
|
||||
}
|
||||
}
|
||||
|
||||
override fun actionPerformed(e: AnActionEvent) {
|
||||
val project = e.project ?: return
|
||||
val psiFile = getPsiFile(e) ?: return
|
||||
val fileName = psiFile.name
|
||||
val psiFile = getRunnableFile(e) ?: return
|
||||
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)
|
||||
console.clear()
|
||||
|
||||
toolWindow.show {
|
||||
scope.launch {
|
||||
console.print("--- Run is disabled ---\n", ConsoleViewContentType.SYSTEM_OUTPUT)
|
||||
console.print("Lyng now runs in bytecode-only mode; the IDE no longer evaluates scripts.\n", ConsoleViewContentType.NORMAL_OUTPUT)
|
||||
console.print("Use the CLI to run scripts, e.g. `lyng run $fileName`.\n", ConsoleViewContentType.NORMAL_OUTPUT)
|
||||
val command = startLyngProcess(filePath, workingDir)
|
||||
if (command == null) {
|
||||
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> {
|
||||
val toolWindowManager = ToolWindowManager.getInstance(project)
|
||||
var toolWindow = toolWindowManager.getToolWindow(ToolWindowId.RUN)
|
||||
@@ -106,4 +172,10 @@ class RunLyngScriptAction : AnAction(LyngIcons.FILE) {
|
||||
contentManager.setSelectedContent(content)
|
||||
return console to actualToolWindow
|
||||
}
|
||||
|
||||
private data class StartedProcess(
|
||||
val process: Process,
|
||||
val commandLine: String,
|
||||
val workingDir: String
|
||||
)
|
||||
}
|
||||
+10
-10
@@ -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");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -34,8 +34,10 @@ kotlin {
|
||||
// Suppress Beta warning for expect/actual classes across all targets in this module
|
||||
targets.configureEach {
|
||||
compilations.configureEach {
|
||||
compilerOptions.configure {
|
||||
freeCompilerArgs.add("-Xexpect-actual-classes")
|
||||
compileTaskProvider.configure {
|
||||
compilerOptions {
|
||||
freeCompilerArgs.add("-Xexpect-actual-classes")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -75,19 +77,17 @@ kotlin {
|
||||
implementation(libs.okio.fakefilesystem)
|
||||
}
|
||||
}
|
||||
val nativeMain by creating {
|
||||
dependsOn(commonMain)
|
||||
}
|
||||
val jvmTest by getting {
|
||||
dependencies {
|
||||
implementation(kotlin("test"))
|
||||
implementation(kotlin("test-junit"))
|
||||
}
|
||||
}
|
||||
// val nativeMain by getting {
|
||||
// dependencies {
|
||||
// implementation(kotlin("stdlib-common"))
|
||||
// }
|
||||
// }
|
||||
val linuxX64Main by getting {
|
||||
|
||||
dependsOn(nativeMain)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -158,6 +158,7 @@ private class Fmt : CliktCommand(name = "fmt") {
|
||||
|
||||
private class Lyng(val launcher: (suspend () -> Unit) -> Unit) : CliktCommand() {
|
||||
|
||||
override val invokeWithoutSubcommand = true
|
||||
override val printHelpOnEmptyArgs = true
|
||||
|
||||
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");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -131,4 +131,18 @@ class CliFmtJvmTest {
|
||||
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)
|
||||
}
|
||||
}
|
||||
+26
-3
@@ -44,7 +44,6 @@ kotlin {
|
||||
iosX64()
|
||||
iosArm64()
|
||||
iosSimulatorArm64()
|
||||
macosX64()
|
||||
macosArm64()
|
||||
mingwX64()
|
||||
linuxX64()
|
||||
@@ -62,8 +61,10 @@ kotlin {
|
||||
// Keep expect/actual warning suppressed consistently with other modules
|
||||
targets.configureEach {
|
||||
compilations.configureEach {
|
||||
compilerOptions.configure {
|
||||
freeCompilerArgs.add("-Xexpect-actual-classes")
|
||||
compileTaskProvider.configure {
|
||||
compilerOptions {
|
||||
freeCompilerArgs.add("-Xexpect-actual-classes")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -81,11 +82,33 @@ kotlin {
|
||||
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 {
|
||||
dependencies {
|
||||
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
|
||||
val jsMain by getting {
|
||||
|
||||
+76
-22
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
|
||||
import org.jetbrains.kotlin.gradle.dsl.JvmTarget
|
||||
|
||||
group = "net.sergeych"
|
||||
version = "1.5.1"
|
||||
version = "1.5.3-SNAPSHOT"
|
||||
|
||||
// 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.androidLibrary)
|
||||
// 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"
|
||||
`maven-publish`
|
||||
}
|
||||
@@ -58,7 +58,6 @@ kotlin {
|
||||
iosX64()
|
||||
iosArm64()
|
||||
iosSimulatorArm64()
|
||||
macosX64()
|
||||
macosArm64()
|
||||
mingwX64()
|
||||
linuxX64()
|
||||
@@ -76,8 +75,10 @@ kotlin {
|
||||
// Suppress Beta warning for expect/actual classes across all targets
|
||||
targets.configureEach {
|
||||
compilations.configureEach {
|
||||
compilerOptions.configure {
|
||||
freeCompilerArgs.add("-Xexpect-actual-classes")
|
||||
compileTaskProvider.configure {
|
||||
compilerOptions {
|
||||
freeCompilerArgs.add("-Xexpect-actual-classes")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -94,13 +95,14 @@ kotlin {
|
||||
}
|
||||
|
||||
val commonMain by getting {
|
||||
kotlin.srcDir("$buildDir/generated/buildConfig/commonMain/kotlin")
|
||||
kotlin.srcDir(layout.buildDirectory.dir("generated/buildConfig/commonMain/kotlin"))
|
||||
dependencies {
|
||||
implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.9.0")
|
||||
implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.6.1")
|
||||
//put your multiplatform dependencies here
|
||||
api(libs.kotlinx.coroutines.core)
|
||||
api(libs.mp.bintools)
|
||||
implementation(libs.ionspin.bignum)
|
||||
}
|
||||
}
|
||||
val commonTest by getting {
|
||||
@@ -109,6 +111,51 @@ kotlin {
|
||||
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 {
|
||||
dependencies {
|
||||
// Allow tests to load external docs like lyng.io.fs via registrar
|
||||
@@ -148,6 +195,9 @@ abstract class GenerateLyngStdlib : DefaultTask() {
|
||||
val outBase = outputDir.get().asFile
|
||||
val targetDir = outBase.resolve(pkgPath)
|
||||
targetDir.mkdirs()
|
||||
targetDir.listFiles()
|
||||
?.filter { it.isFile && it.name.endsWith(".generated.kt") }
|
||||
?.forEach { it.delete() }
|
||||
|
||||
val srcDir = sourceDir.get().asFile
|
||||
val files = srcDir.walkTopDown()
|
||||
@@ -155,34 +205,38 @@ abstract class GenerateLyngStdlib : DefaultTask() {
|
||||
.sortedBy { it.name }
|
||||
.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 {
|
||||
for (ch in s) when (ch) {
|
||||
'\\' -> append("\\\\")
|
||||
'"' -> append("\\\"")
|
||||
'$' -> append("\\$")
|
||||
'\n' -> append("\\n")
|
||||
'\r' -> {}
|
||||
'\t' -> append("\\t")
|
||||
else -> append(ch)
|
||||
}
|
||||
}
|
||||
val body = escapeForQuoted(content)
|
||||
|
||||
val sb = StringBuilder()
|
||||
sb.append("package ").append(targetPkg).append("\n\n")
|
||||
sb.append("@Suppress(\"Unused\", \"MemberVisibilityCanBePrivate\")\n")
|
||||
sb.append("internal val rootLyng = \"")
|
||||
sb.append(body)
|
||||
sb.append("\"\n")
|
||||
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"
|
||||
}
|
||||
|
||||
targetDir.resolve("root_lyng.generated.kt").writeText(sb.toString())
|
||||
for (file in files) {
|
||||
val body = escapeForQuoted(file.readText())
|
||||
val sb = StringBuilder()
|
||||
sb.append("package ").append(targetPkg).append("\n\n")
|
||||
sb.append("@Suppress(\"Unused\", \"MemberVisibilityCanBePrivate\")\n")
|
||||
sb.append("internal val ").append(constantName(file.nameWithoutExtension)).append(" = \"")
|
||||
sb.append(body)
|
||||
sb.append("\"\n")
|
||||
targetDir.resolve("${file.nameWithoutExtension}_lyng.generated.kt").writeText(sb.toString())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -172,6 +172,7 @@ class Compiler(
|
||||
private val callReturnTypeDeclByRef: MutableMap<CallRef, TypeDecl> = mutableMapOf()
|
||||
private val callableReturnTypeByScopeId: MutableMap<Int, MutableMap<Int, 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 lambdaCaptureEntriesByRef: MutableMap<ValueFnRef, List<net.sergeych.lyng.bytecode.LambdaCaptureEntry>> =
|
||||
mutableMapOf()
|
||||
@@ -184,7 +185,10 @@ class Compiler(
|
||||
private val encodedPayloadTypeByName: MutableMap<String, ObjClass> = mutableMapOf()
|
||||
private val objectDeclNames: MutableSet<String> = mutableSetOf()
|
||||
private val externCallableNames: MutableSet<String> = mutableSetOf()
|
||||
private val externBindingNames: 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 fun moduleForcedLocalSlotInfo(): Map<String, ForcedLocalSlotInfo> {
|
||||
@@ -192,6 +196,7 @@ class Compiler(
|
||||
if (plan.slots.isEmpty()) return emptyMap()
|
||||
val result = LinkedHashMap<String, ForcedLocalSlotInfo>(plan.slots.size)
|
||||
for ((name, entry) in plan.slots) {
|
||||
if (externBindingNames.contains(name)) continue
|
||||
result[name] = ForcedLocalSlotInfo(
|
||||
index = entry.index,
|
||||
isMutable = entry.isMutable,
|
||||
@@ -338,6 +343,73 @@ class Compiler(
|
||||
}
|
||||
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 {
|
||||
while (cc.hasNext()) {
|
||||
val t = cc.next()
|
||||
@@ -350,65 +422,11 @@ class Compiler(
|
||||
Token.Type.RBRACKET -> if (bracketDepth > 0) bracketDepth--
|
||||
Token.Type.ID -> if (depth == 0) {
|
||||
if (parenDepth > 0 || bracketDepth > 0) continue
|
||||
when (t.value) {
|
||||
"fun", "fn" -> {
|
||||
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
|
||||
}
|
||||
declareSlotNameIn(plan, nameToken.value, isMutable = false, isDelegated = false)
|
||||
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)
|
||||
}
|
||||
}
|
||||
if (t.value == "extern") {
|
||||
handleTopLevelKeyword(nextNonWs())
|
||||
continue
|
||||
}
|
||||
handleTopLevelKeyword(t)
|
||||
}
|
||||
else -> {}
|
||||
}
|
||||
@@ -418,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>) {
|
||||
val saved = cc.savePos()
|
||||
var depth = 0
|
||||
@@ -581,7 +605,7 @@ class Compiler(
|
||||
val baseNames = cls.directParents.map { it.className }
|
||||
val nextFieldId = (fieldIds.values.maxOrNull() ?: -1) + 1
|
||||
val nextMethodId = (methodIds.values.maxOrNull() ?: -1) + 1
|
||||
return CompileClassInfo(name, fieldIds, methodIds, nextFieldId, nextMethodId, baseNames)
|
||||
return CompileClassInfo(name, cls.logicalPackageName, fieldIds, methodIds, nextFieldId, nextMethodId, baseNames)
|
||||
}
|
||||
|
||||
private data class BaseMemberIds(
|
||||
@@ -885,6 +909,7 @@ class Compiler(
|
||||
name = declaredName,
|
||||
isMutable = false,
|
||||
visibility = Visibility.Public,
|
||||
actualExtern = false,
|
||||
initializer = initStmt,
|
||||
isTransient = false,
|
||||
typeDecl = null,
|
||||
@@ -929,6 +954,7 @@ class Compiler(
|
||||
}
|
||||
}
|
||||
captureLocalRef(name, slotLoc, pos)?.let { ref ->
|
||||
rememberModuleReferencePos(name, pos)
|
||||
resolutionSink?.reference(name, pos)
|
||||
return ref
|
||||
}
|
||||
@@ -974,8 +1000,11 @@ class Compiler(
|
||||
if (moduleLoc != null) {
|
||||
val moduleDeclaredNames = localNamesStack.firstOrNull()
|
||||
if (moduleDeclaredNames == null || !moduleDeclaredNames.contains(name)) {
|
||||
resolveImportBinding(name, pos)?.let { resolved ->
|
||||
registerImportBinding(name, resolved.binding, pos)
|
||||
val resolvedImport = resolveImportBinding(name, 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(
|
||||
@@ -1004,8 +1033,11 @@ class Compiler(
|
||||
if (moduleEntry != null) {
|
||||
val moduleDeclaredNames = localNamesStack.firstOrNull()
|
||||
if (moduleDeclaredNames == null || !moduleDeclaredNames.contains(name)) {
|
||||
resolveImportBinding(name, pos)?.let { resolved ->
|
||||
registerImportBinding(name, resolved.binding, pos)
|
||||
val resolvedImport = resolveImportBinding(name, 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(
|
||||
@@ -1016,6 +1048,7 @@ class Compiler(
|
||||
moduleEntry.isDelegated
|
||||
)
|
||||
captureLocalRef(name, moduleLoc, pos)?.let { ref ->
|
||||
rememberModuleReferencePos(name, pos)
|
||||
resolutionSink?.reference(name, pos)
|
||||
return ref
|
||||
}
|
||||
@@ -1042,6 +1075,7 @@ class Compiler(
|
||||
strictSlotRefs
|
||||
)
|
||||
}
|
||||
rememberModuleReferencePos(name, pos)
|
||||
resolutionSink?.reference(name, pos)
|
||||
return ref
|
||||
}
|
||||
@@ -1072,13 +1106,14 @@ class Compiler(
|
||||
)
|
||||
}
|
||||
}
|
||||
registerImportBinding(name, resolved.binding, pos)
|
||||
val slot = lookupSlotLocation(name)
|
||||
if (slot != null) {
|
||||
captureLocalRef(name, slot, pos)?.let { ref ->
|
||||
resolutionSink?.reference(name, pos)
|
||||
return ref
|
||||
}
|
||||
registerImportBinding(name, resolved.binding, pos)
|
||||
val slot = lookupSlotLocation(name)
|
||||
if (slot != null) {
|
||||
captureLocalRef(name, slot, pos)?.let { ref ->
|
||||
rememberModuleReferencePos(name, pos)
|
||||
resolutionSink?.reference(name, pos)
|
||||
return ref
|
||||
}
|
||||
val ref = if (!useScopeSlots && capturePlanStack.isEmpty() && slot.depth > 0) {
|
||||
LocalSlotRef(
|
||||
name,
|
||||
@@ -1102,6 +1137,7 @@ class Compiler(
|
||||
strictSlotRefs
|
||||
)
|
||||
}
|
||||
rememberModuleReferencePos(name, pos)
|
||||
resolutionSink?.reference(name, pos)
|
||||
return ref
|
||||
}
|
||||
@@ -1278,23 +1314,11 @@ class Compiler(
|
||||
}
|
||||
}
|
||||
if (seedRecord != null) {
|
||||
val value = seedRecord.value
|
||||
if (!nameObjClass.containsKey(name)) {
|
||||
when (value) {
|
||||
is ObjClass -> nameObjClass[name] = value
|
||||
is ObjInstance -> nameObjClass[name] = value.objClass
|
||||
}
|
||||
}
|
||||
seedImportTypeMetadata(name, seedRecord)
|
||||
return ImportBindingResolution(ImportBinding(name, ImportBindingSource.Seed), seedRecord)
|
||||
}
|
||||
if (rootRecord != null) {
|
||||
val value = rootRecord.value
|
||||
if (!nameObjClass.containsKey(name)) {
|
||||
when (value) {
|
||||
is ObjClass -> nameObjClass[name] = value
|
||||
is ObjInstance -> nameObjClass[name] = value.objClass
|
||||
}
|
||||
}
|
||||
seedImportTypeMetadata(name, rootRecord)
|
||||
return ImportBindingResolution(ImportBinding(name, ImportBindingSource.Root), rootRecord)
|
||||
}
|
||||
if (moduleMatches.isEmpty()) return null
|
||||
@@ -1309,13 +1333,7 @@ class Compiler(
|
||||
val candidates = byOrigin[origin] ?: mutableListOf()
|
||||
val preferred = candidates.firstOrNull { it.first.scope.packageName == origin } ?: candidates.first()
|
||||
val binding = ImportBinding(name, ImportBindingSource.Module(origin, preferred.first.pos))
|
||||
val value = preferred.second.value
|
||||
if (!nameObjClass.containsKey(name)) {
|
||||
when (value) {
|
||||
is ObjClass -> nameObjClass[name] = value
|
||||
is ObjInstance -> nameObjClass[name] = value.objClass
|
||||
}
|
||||
}
|
||||
seedImportTypeMetadata(name, preferred.second)
|
||||
return ImportBindingResolution(binding, preferred.second)
|
||||
}
|
||||
val moduleNames = moduleMatches.keys.toList()
|
||||
@@ -1323,14 +1341,24 @@ class Compiler(
|
||||
}
|
||||
val (module, record) = moduleMatches.values.first()
|
||||
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)) {
|
||||
when (value) {
|
||||
record.typeDecl?.let { resolveTypeDeclObjClass(it) }?.let {
|
||||
nameObjClass[name] = it
|
||||
return
|
||||
}
|
||||
when (val value = record.value) {
|
||||
is ObjClass -> nameObjClass[name] = value
|
||||
is ObjInstance -> nameObjClass[name] = value.objClass
|
||||
}
|
||||
}
|
||||
return ImportBindingResolution(binding, record)
|
||||
}
|
||||
|
||||
private fun collectModuleRecordMatches(
|
||||
@@ -1550,6 +1578,7 @@ class Compiler(
|
||||
|
||||
private data class CompileClassInfo(
|
||||
val name: String,
|
||||
val packageName: String?,
|
||||
val fieldIds: Map<String, Int>,
|
||||
val methodIds: Map<String, Int>,
|
||||
val nextFieldId: Int,
|
||||
@@ -1751,6 +1780,9 @@ class Compiler(
|
||||
enumEntriesByName = enumEntriesByName,
|
||||
callableReturnTypeByScopeId = callableReturnTypeByScopeId,
|
||||
callableReturnTypeByName = callableReturnTypeByName,
|
||||
externBindingNames = externBindingNames,
|
||||
preparedModuleBindingNames = importBindings.keys,
|
||||
scopeRefPosByName = moduleReferencePosByName,
|
||||
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
|
||||
) as BytecodeStatement
|
||||
unwrapped to bytecodeStmt.bytecodeFunction()
|
||||
@@ -1957,6 +1989,9 @@ class Compiler(
|
||||
val scopeIndex = slotPlanStack.indexOfLast { it.id == slotLoc.scopeId }
|
||||
if (functionIndex >= 0 && scopeIndex >= functionIndex) return null
|
||||
val modulePlan = moduleSlotPlan()
|
||||
if (modulePlan != null && slotLoc.scopeId == modulePlan.id && externBindingNames.contains(name)) {
|
||||
return null
|
||||
}
|
||||
if (useScopeSlots && modulePlan != null && slotLoc.scopeId == modulePlan.id) {
|
||||
return null
|
||||
}
|
||||
@@ -2075,6 +2110,9 @@ class Compiler(
|
||||
callableReturnTypeByScopeId = callableReturnTypeByScopeId,
|
||||
callableReturnTypeByName = callableReturnTypeByName,
|
||||
externCallableNames = externCallableNames,
|
||||
externBindingNames = externBindingNames,
|
||||
preparedModuleBindingNames = importBindings.keys,
|
||||
scopeRefPosByName = moduleReferencePosByName,
|
||||
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
|
||||
)
|
||||
}
|
||||
@@ -2105,6 +2143,9 @@ class Compiler(
|
||||
callableReturnTypeByScopeId = callableReturnTypeByScopeId,
|
||||
callableReturnTypeByName = callableReturnTypeByName,
|
||||
externCallableNames = externCallableNames,
|
||||
externBindingNames = externBindingNames,
|
||||
preparedModuleBindingNames = importBindings.keys,
|
||||
scopeRefPosByName = moduleReferencePosByName,
|
||||
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
|
||||
)
|
||||
}
|
||||
@@ -2160,6 +2201,9 @@ class Compiler(
|
||||
callableReturnTypeByScopeId = callableReturnTypeByScopeId,
|
||||
callableReturnTypeByName = callableReturnTypeByName,
|
||||
externCallableNames = externCallableNames,
|
||||
externBindingNames = externBindingNames,
|
||||
preparedModuleBindingNames = importBindings.keys,
|
||||
scopeRefPosByName = moduleReferencePosByName,
|
||||
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
|
||||
)
|
||||
}
|
||||
@@ -2343,6 +2387,7 @@ class Compiler(
|
||||
stmt.name,
|
||||
stmt.isMutable,
|
||||
stmt.visibility,
|
||||
stmt.actualExtern,
|
||||
init,
|
||||
stmt.isTransient,
|
||||
stmt.typeDecl,
|
||||
@@ -2903,9 +2948,9 @@ class Compiler(
|
||||
operand?.let { left ->
|
||||
// array access via ObjRef
|
||||
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")
|
||||
operand = IndexRef(left, StatementRef(index), isOptional)
|
||||
operand = IndexRef(left, index, isOptional)
|
||||
} ?: run {
|
||||
// array literal
|
||||
val entries = parseArrayLiteral()
|
||||
@@ -3400,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> {
|
||||
// it should be called after Token.Type.LBRACKET is consumed
|
||||
val entries = mutableListOf<ListEntry>()
|
||||
@@ -4287,14 +4346,22 @@ class Compiler(
|
||||
is MapLiteralRef -> inferMapLiteralTypeDecl(ref)
|
||||
is ConstRef -> inferTypeDeclFromConst(ref.constValue)
|
||||
is CallRef -> {
|
||||
val targetDecl = resolveReceiverTypeDecl(ref.target)
|
||||
val targetName = when (val target = ref.target) {
|
||||
is LocalVarRef -> target.name
|
||||
is FastLocalVarRef -> target.name
|
||||
is LocalSlotRef -> target.name
|
||||
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 {
|
||||
val targetName = when (val target = ref.target) {
|
||||
is LocalVarRef -> target.name
|
||||
is FastLocalVarRef -> target.name
|
||||
is LocalSlotRef -> target.name
|
||||
else -> null
|
||||
}
|
||||
if (targetName != null && targetName.firstOrNull()?.isUpperCase() == true) {
|
||||
TypeDecl.Simple(targetName, false)
|
||||
} else {
|
||||
@@ -4625,6 +4692,17 @@ class Compiler(
|
||||
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? {
|
||||
return when (ref) {
|
||||
is LocalSlotRef -> {
|
||||
@@ -4634,8 +4712,12 @@ class Compiler(
|
||||
?: nameTypeDecl[ref.name]
|
||||
?: seedTypeDeclByName(ref.name)
|
||||
}
|
||||
is LocalVarRef -> nameTypeDecl[ref.name] ?: seedTypeDeclByName(ref.name)
|
||||
is FastLocalVarRef -> nameTypeDecl[ref.name] ?: seedTypeDeclByName(ref.name)
|
||||
is LocalVarRef -> nameTypeDecl[ref.name]
|
||||
?: lookupLocalTypeDeclByName(ref.name)
|
||||
?: seedTypeDeclByName(ref.name)
|
||||
is FastLocalVarRef -> nameTypeDecl[ref.name]
|
||||
?: lookupLocalTypeDeclByName(ref.name)
|
||||
?: seedTypeDeclByName(ref.name)
|
||||
is FieldRef -> {
|
||||
val targetDecl = resolveReceiverTypeDecl(ref.target) ?: return null
|
||||
val targetClass = resolveTypeDeclObjClass(targetDecl) ?: resolveReceiverClassForMember(ref.target)
|
||||
@@ -4655,6 +4737,7 @@ class Compiler(
|
||||
}
|
||||
is MethodCallRef -> methodReturnTypeDeclByRef[ref]
|
||||
is CallRef -> callReturnTypeDeclByRef[ref]
|
||||
is BinaryOpRef -> inferBinaryOpReturnTypeDecl(ref)
|
||||
is StatementRef -> (ref.statement as? ExpressionStatement)?.let { resolveReceiverTypeDecl(it.ref) }
|
||||
else -> null
|
||||
}
|
||||
@@ -4680,11 +4763,13 @@ class Compiler(
|
||||
is LocalVarRef -> nameObjClass[ref.name]
|
||||
?.takeIf { it == ObjDynamic.type }
|
||||
?: nameObjClass[ref.name]
|
||||
?: lookupLocalObjClassByName(ref.name)
|
||||
?: nameTypeDecl[ref.name]?.let { resolveTypeDeclObjClass(it) }
|
||||
?: resolveClassByName(ref.name)
|
||||
is FastLocalVarRef -> nameObjClass[ref.name]
|
||||
?.takeIf { it == ObjDynamic.type }
|
||||
?: nameObjClass[ref.name]
|
||||
?: lookupLocalObjClassByName(ref.name)
|
||||
?: nameTypeDecl[ref.name]?.let { resolveTypeDeclObjClass(it) }
|
||||
?: resolveClassByName(ref.name)
|
||||
is ClassScopeMemberRef -> {
|
||||
@@ -4718,6 +4803,7 @@ class Compiler(
|
||||
is ThisMethodSlotCallRef -> inferMethodCallReturnClass(ref.methodName())
|
||||
is QualifiedThisMethodSlotCallRef -> inferMethodCallReturnClass(ref.methodName())
|
||||
is CallRef -> inferCallReturnClass(ref)
|
||||
is BinaryOpRef -> inferBinaryOpReturnClass(ref)
|
||||
is FieldRef -> {
|
||||
val targetClass = resolveReceiverClassForMember(ref.target)
|
||||
inferFieldReturnClass(targetClass, ref.name)
|
||||
@@ -4732,10 +4818,105 @@ class Compiler(
|
||||
}
|
||||
}
|
||||
|
||||
private fun typeDeclOfClass(objClass: ObjClass): TypeDecl = TypeDecl.Simple(objClass.className, false)
|
||||
|
||||
private fun binaryOpMethodName(op: BinOp): String? = when (op) {
|
||||
BinOp.PLUS -> "plus"
|
||||
BinOp.MINUS -> "minus"
|
||||
BinOp.STAR -> "mul"
|
||||
BinOp.SLASH -> "div"
|
||||
BinOp.PERCENT -> "mod"
|
||||
else -> null
|
||||
}
|
||||
|
||||
private fun interopOperatorFor(op: BinOp): InteropOperator? = when (op) {
|
||||
BinOp.PLUS -> InteropOperator.Plus
|
||||
BinOp.MINUS -> InteropOperator.Minus
|
||||
BinOp.STAR -> InteropOperator.Mul
|
||||
BinOp.SLASH -> InteropOperator.Div
|
||||
BinOp.PERCENT -> InteropOperator.Mod
|
||||
BinOp.LT, BinOp.LTE, BinOp.GT, BinOp.GTE -> InteropOperator.Compare
|
||||
BinOp.EQ, BinOp.NEQ -> InteropOperator.Equals
|
||||
else -> null
|
||||
}
|
||||
|
||||
private fun sameClassArithmeticFallback(leftClass: ObjClass, rightClass: ObjClass, op: BinOp): TypeDecl? {
|
||||
if (leftClass !== rightClass) return null
|
||||
val methodName = binaryOpMethodName(op) ?: return null
|
||||
if (leftClass.getInstanceMemberOrNull(methodName, includeAbstract = true) == null) return null
|
||||
return typeDeclOfClass(leftClass)
|
||||
}
|
||||
|
||||
private fun inferBinaryOpReturnTypeDecl(ref: BinaryOpRef): TypeDecl? {
|
||||
val leftClass = resolveReceiverClassForMember(ref.left) ?: inferObjClassFromRef(ref.left)
|
||||
val rightClass = resolveReceiverClassForMember(ref.right) ?: inferObjClassFromRef(ref.right)
|
||||
val boolType = typeDeclOfClass(ObjBool.type)
|
||||
val intType = typeDeclOfClass(ObjInt.type)
|
||||
val realType = typeDeclOfClass(ObjReal.type)
|
||||
val stringType = typeDeclOfClass(ObjString.type)
|
||||
|
||||
when (ref.op) {
|
||||
BinOp.OR, BinOp.AND,
|
||||
BinOp.EQARROW, BinOp.EQ, BinOp.NEQ, BinOp.REF_EQ, BinOp.REF_NEQ, BinOp.MATCH, BinOp.NOTMATCH,
|
||||
BinOp.LTE, BinOp.LT, BinOp.GTE, BinOp.GT,
|
||||
BinOp.IN, BinOp.NOTIN,
|
||||
BinOp.IS, BinOp.NOTIS -> return boolType
|
||||
else -> {}
|
||||
}
|
||||
|
||||
if (leftClass == null || rightClass == null) return null
|
||||
|
||||
val leftIsInt = leftClass == ObjInt.type
|
||||
val rightIsInt = rightClass == ObjInt.type
|
||||
val leftIsReal = leftClass == ObjReal.type
|
||||
val rightIsReal = rightClass == ObjReal.type
|
||||
val leftIsNumeric = leftIsInt || leftIsReal
|
||||
val rightIsNumeric = rightIsInt || rightIsReal
|
||||
|
||||
return when (ref.op) {
|
||||
BinOp.PLUS -> when {
|
||||
leftIsInt && rightIsInt -> intType
|
||||
leftIsNumeric && rightIsNumeric -> realType
|
||||
leftClass == ObjString.type -> stringType
|
||||
interopOperatorFor(ref.op)?.let {
|
||||
OperatorInteropRegistry.commonClassFor(leftClass, rightClass, it)
|
||||
} != null -> typeDeclOfClass(
|
||||
OperatorInteropRegistry.commonClassFor(leftClass, rightClass, interopOperatorFor(ref.op)!!)!!
|
||||
)
|
||||
else -> binaryOpMethodName(ref.op)?.let { classMethodReturnTypeDecl(leftClass, it) }
|
||||
?: sameClassArithmeticFallback(leftClass, rightClass, ref.op)
|
||||
}
|
||||
BinOp.MINUS, BinOp.STAR, BinOp.SLASH, BinOp.PERCENT -> when {
|
||||
leftIsInt && rightIsInt -> intType
|
||||
leftIsNumeric && rightIsNumeric -> realType
|
||||
ref.op == BinOp.STAR && leftClass == ObjString.type && rightIsNumeric -> stringType
|
||||
interopOperatorFor(ref.op)?.let {
|
||||
OperatorInteropRegistry.commonClassFor(leftClass, rightClass, it)
|
||||
} != null -> typeDeclOfClass(
|
||||
OperatorInteropRegistry.commonClassFor(leftClass, rightClass, interopOperatorFor(ref.op)!!)!!
|
||||
)
|
||||
else -> binaryOpMethodName(ref.op)?.let { classMethodReturnTypeDecl(leftClass, it) }
|
||||
?: sameClassArithmeticFallback(leftClass, rightClass, ref.op)
|
||||
}
|
||||
BinOp.BAND, BinOp.BOR, BinOp.BXOR, BinOp.SHL, BinOp.SHR ->
|
||||
if (leftIsInt && rightIsInt) intType else null
|
||||
else -> null
|
||||
}
|
||||
}
|
||||
|
||||
private fun inferBinaryOpReturnClass(ref: BinaryOpRef): ObjClass? {
|
||||
inferBinaryOpReturnTypeDecl(ref)?.let { declared ->
|
||||
resolveTypeDeclObjClass(declared)?.let { return it }
|
||||
}
|
||||
val leftClass = resolveReceiverClassForMember(ref.left) ?: inferObjClassFromRef(ref.left)
|
||||
val rightClass = resolveReceiverClassForMember(ref.right) ?: inferObjClassFromRef(ref.right)
|
||||
if (leftClass == null || rightClass == null) return null
|
||||
interopOperatorFor(ref.op)?.let { op ->
|
||||
OperatorInteropRegistry.commonClassFor(leftClass, rightClass, op)?.let { return it }
|
||||
}
|
||||
sameClassArithmeticFallback(leftClass, rightClass, ref.op)?.let { declared ->
|
||||
resolveTypeDeclObjClass(declared)?.let { return it }
|
||||
}
|
||||
return when (ref.op) {
|
||||
BinOp.PLUS, BinOp.MINUS -> when {
|
||||
leftClass == ObjInstant.type && rightClass == ObjInstant.type && ref.op == BinOp.MINUS -> ObjDuration.type
|
||||
@@ -6446,7 +6627,7 @@ class Compiler(
|
||||
WhenStatement(value, cases, elseCase, whenPos)
|
||||
} else {
|
||||
// when { cond -> ... }
|
||||
TODO("when without object is not yet implemented")
|
||||
throw ScriptError(t.pos, "when without subject is not implemented")
|
||||
}
|
||||
return wrapBytecode(stmt)
|
||||
}
|
||||
@@ -6699,6 +6880,7 @@ class Compiler(
|
||||
)
|
||||
compileClassInfos[qualifiedName] = CompileClassInfo(
|
||||
name = qualifiedName,
|
||||
packageName = packageName,
|
||||
fieldIds = fieldIds,
|
||||
methodIds = methodIds,
|
||||
nextFieldId = fieldIds.size,
|
||||
@@ -6821,6 +7003,7 @@ class Compiler(
|
||||
classCtx?.let { ctx ->
|
||||
compileClassInfos[className] = CompileClassInfo(
|
||||
name = className,
|
||||
packageName = packageName,
|
||||
fieldIds = ctx.memberFieldIds.toMap(),
|
||||
methodIds = ctx.memberMethodIds.toMap(),
|
||||
nextFieldId = ctx.nextFieldId,
|
||||
@@ -6862,6 +7045,7 @@ class Compiler(
|
||||
val baseIds = collectBaseMemberIds(baseSpecs.map { it.name })
|
||||
compileClassInfos[className] = CompileClassInfo(
|
||||
name = className,
|
||||
packageName = packageName,
|
||||
fieldIds = baseIds.fieldIds,
|
||||
methodIds = baseIds.methodIds,
|
||||
nextFieldId = baseIds.nextFieldId,
|
||||
@@ -7110,6 +7294,7 @@ class Compiler(
|
||||
}
|
||||
compileClassInfos[qualifiedName] = CompileClassInfo(
|
||||
name = qualifiedName,
|
||||
packageName = packageName,
|
||||
fieldIds = ctx.memberFieldIds.toMap(),
|
||||
methodIds = ctx.memberMethodIds.toMap(),
|
||||
nextFieldId = ctx.nextFieldId,
|
||||
@@ -7125,6 +7310,7 @@ class Compiler(
|
||||
classCtx?.let { ctx ->
|
||||
compileClassInfos[qualifiedName] = CompileClassInfo(
|
||||
name = qualifiedName,
|
||||
packageName = packageName,
|
||||
fieldIds = ctx.memberFieldIds.toMap(),
|
||||
methodIds = ctx.memberMethodIds.toMap(),
|
||||
nextFieldId = ctx.nextFieldId,
|
||||
@@ -7211,6 +7397,7 @@ class Compiler(
|
||||
}
|
||||
compileClassInfos[qualifiedName] = CompileClassInfo(
|
||||
name = qualifiedName,
|
||||
packageName = packageName,
|
||||
fieldIds = ctx.memberFieldIds.toMap(),
|
||||
methodIds = ctx.memberMethodIds.toMap(),
|
||||
nextFieldId = ctx.nextFieldId,
|
||||
@@ -8028,6 +8215,10 @@ class Compiler(
|
||||
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 ->
|
||||
if (!compileBytecode) return@let stmt
|
||||
val paramKnownClasses = mutableMapOf<String, ObjClass>()
|
||||
@@ -8138,7 +8329,7 @@ class Compiler(
|
||||
?: context.parent?.get(localName)
|
||||
?: context.get(localName)
|
||||
?: 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)
|
||||
} else {
|
||||
record.value
|
||||
@@ -8390,7 +8581,7 @@ class Compiler(
|
||||
is ImplicitThisMethodCallRef -> {
|
||||
when (directRef.methodName()) {
|
||||
"iterator" -> ObjIterator
|
||||
"lazy" -> ObjLazyDelegate.type
|
||||
"lazy" -> resolveClassByName("lazy") ?: inferMethodCallReturnClass(directRef.methodName())
|
||||
else -> inferMethodCallReturnClass(directRef.methodName())
|
||||
}
|
||||
}
|
||||
@@ -8409,7 +8600,7 @@ class Compiler(
|
||||
when {
|
||||
target is LocalSlotRef -> {
|
||||
when (target.name) {
|
||||
"lazy" -> ObjLazyDelegate.type
|
||||
"lazy" -> resolveClassByName("lazy")
|
||||
"iterator" -> ObjIterator
|
||||
"flow" -> ObjFlow.type
|
||||
"launch" -> ObjDeferred.type
|
||||
@@ -8420,7 +8611,7 @@ class Compiler(
|
||||
}
|
||||
target is LocalVarRef -> {
|
||||
when (target.name) {
|
||||
"lazy" -> ObjLazyDelegate.type
|
||||
"lazy" -> resolveClassByName("lazy")
|
||||
"iterator" -> ObjIterator
|
||||
"flow" -> ObjFlow.type
|
||||
"launch" -> ObjDeferred.type
|
||||
@@ -8459,7 +8650,9 @@ class Compiler(
|
||||
?: unwrapDirectRef(initializer)?.let { inferObjClassFromRef(it) }
|
||||
?: throw ScriptError(initializer.pos, "Delegate type must be known at compile time")
|
||||
if (initClass !== delegateClass &&
|
||||
initClass.logicalName != delegateClass.logicalName &&
|
||||
!initClass.allParentsSet.contains(delegateClass) &&
|
||||
!initClass.allParentsSet.any { it.logicalName == delegateClass.logicalName } &&
|
||||
!initClass.allImplementingNames.contains(delegateClass.className)
|
||||
) {
|
||||
throw ScriptError(
|
||||
@@ -8549,7 +8742,9 @@ class Compiler(
|
||||
if (closedParent != null) {
|
||||
throw ScriptError(Pos.builtIn, "can't inherit from closed class ${closedParent.className}")
|
||||
}
|
||||
ObjInstanceClass(info.name, *parents.toTypedArray())
|
||||
ObjInstanceClass(info.name, *parents.toTypedArray()).apply {
|
||||
logicalPackageNameOverride = info.packageName
|
||||
}
|
||||
}
|
||||
if (stub is ObjInstanceClass) {
|
||||
for ((fieldName, fieldId) in info.fieldIds) {
|
||||
@@ -8893,7 +9088,10 @@ class Compiler(
|
||||
val effectiveEqToken = if (isProperty) null else eqToken
|
||||
|
||||
// Register the local name at compile time so that subsequent identifiers can be emitted as fast locals
|
||||
if (!isStatic && declaringClassNameCaptured == null) 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) {
|
||||
SymbolKind.MEMBER
|
||||
} else {
|
||||
@@ -8902,6 +9100,8 @@ class Compiler(
|
||||
resolutionSink?.declareSymbol(name, declKind, isMutable, nameStartPos, isOverride = isOverride)
|
||||
if (declKind == SymbolKind.MEMBER && extTypeName == null) {
|
||||
(codeContexts.lastOrNull() as? CodeContext.ClassBody)?.declaredMembers?.add(name)
|
||||
} else if (actualExtern) {
|
||||
externBindingNames.add(name)
|
||||
}
|
||||
|
||||
val isDelegate = if (isAbstract || actualExtern) {
|
||||
@@ -8967,7 +9167,11 @@ class Compiler(
|
||||
|
||||
if (isDelegate && initialExpression != null) {
|
||||
ensureDelegateType(initialExpression)
|
||||
if (isMutable && resolveInitializerObjClass(initialExpression) == ObjLazyDelegate.type) {
|
||||
val lazyClass = resolveClassByName("lazy")
|
||||
if (isMutable &&
|
||||
lazyClass != null &&
|
||||
resolveInitializerObjClass(initialExpression)?.logicalName == lazyClass.logicalName
|
||||
) {
|
||||
throw ScriptError(initialExpression.pos, "lazy delegate is read-only")
|
||||
}
|
||||
}
|
||||
@@ -9059,6 +9263,7 @@ class Compiler(
|
||||
name,
|
||||
isMutable,
|
||||
visibility,
|
||||
actualExtern,
|
||||
initialExpression,
|
||||
isTransient,
|
||||
declaredType,
|
||||
|
||||
@@ -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 {
|
||||
val resolved = read()
|
||||
if (resolved === this) {
|
||||
@@ -193,4 +206,18 @@ class RecordSlotRef(
|
||||
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
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,109 @@
|
||||
/*
|
||||
* 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 net.sergeych.lyng.obj.Obj
|
||||
import net.sergeych.lyng.obj.ObjClass
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import net.sergeych.lyng.obj.ObjVoid
|
||||
|
||||
internal enum class InteropOperator(val memberName: String?) {
|
||||
Plus("plus"),
|
||||
Minus("minus"),
|
||||
Mul("mul"),
|
||||
Div("div"),
|
||||
Mod("mod"),
|
||||
Compare("compareTo"),
|
||||
Equals("equals");
|
||||
|
||||
companion object {
|
||||
fun fromName(name: String): InteropOperator =
|
||||
entries.firstOrNull { it.name == name }
|
||||
?: throw IllegalArgumentException("unknown interop operator: $name")
|
||||
}
|
||||
}
|
||||
|
||||
private data class InteropRule(
|
||||
val commonClass: ObjClass,
|
||||
val operators: Set<InteropOperator>,
|
||||
val leftToCommon: Obj,
|
||||
val rightToCommon: Obj
|
||||
)
|
||||
|
||||
internal data class PromotedOperands(val left: Obj, val right: Obj)
|
||||
|
||||
internal object OperatorInteropRegistry {
|
||||
private val rules = mutableMapOf<Pair<ObjClass, ObjClass>, InteropRule>()
|
||||
|
||||
fun register(
|
||||
leftClass: ObjClass,
|
||||
rightClass: ObjClass,
|
||||
commonClass: ObjClass,
|
||||
operatorNames: List<String>,
|
||||
leftToCommon: Obj,
|
||||
rightToCommon: Obj
|
||||
) {
|
||||
val operators = operatorNames.mapTo(linkedSetOf(), InteropOperator::fromName)
|
||||
rules[leftClass to rightClass] = InteropRule(commonClass, operators, leftToCommon, rightToCommon)
|
||||
if (leftClass !== rightClass) {
|
||||
rules[rightClass to leftClass] = InteropRule(commonClass, operators, rightToCommon, leftToCommon)
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun promote(scope: Scope, left: Obj, right: Obj, operator: InteropOperator): PromotedOperands? {
|
||||
val leftValue = unwrap(left)
|
||||
val rightValue = unwrap(right)
|
||||
val rule = rules[leftValue.objClass to rightValue.objClass] ?: return null
|
||||
if (operator !in rule.operators) return null
|
||||
val promotedLeft = rule.leftToCommon.invoke(scope, ObjVoid, Arguments(leftValue))
|
||||
val promotedRight = rule.rightToCommon.invoke(scope, ObjVoid, Arguments(rightValue))
|
||||
if (promotedLeft.objClass !== rule.commonClass || promotedRight.objClass !== rule.commonClass) {
|
||||
scope.raiseIllegalState(
|
||||
"Operator interop promotion must return ${rule.commonClass.className}, " +
|
||||
"got ${promotedLeft.objClass.className} and ${promotedRight.objClass.className}"
|
||||
)
|
||||
}
|
||||
return PromotedOperands(promotedLeft, promotedRight)
|
||||
}
|
||||
|
||||
suspend fun invokeBinary(scope: Scope, left: Obj, right: Obj, operator: InteropOperator): Obj? {
|
||||
val promoted = promote(scope, left, right, operator) ?: return null
|
||||
val memberName = operator.memberName ?: return null
|
||||
return promoted.left.invokeInstanceMethod(scope, memberName, Arguments(promoted.right))
|
||||
}
|
||||
|
||||
suspend fun invokeCompare(scope: Scope, left: Obj, right: Obj): Int? {
|
||||
val promoted = promote(scope, left, right, InteropOperator.Compare) ?: return null
|
||||
return promoted.left.invokeInstanceMethod(scope, "compareTo", Arguments(promoted.right))
|
||||
.cast<ObjInt>(scope)
|
||||
.value
|
||||
.toInt()
|
||||
}
|
||||
|
||||
fun commonClassFor(leftClass: ObjClass, rightClass: ObjClass, operator: InteropOperator): ObjClass? {
|
||||
val rule = rules[leftClass to rightClass] ?: return null
|
||||
if (operator !in rule.operators) return null
|
||||
return rule.commonClass
|
||||
}
|
||||
|
||||
private suspend fun unwrap(obj: Obj): Obj = when (obj) {
|
||||
is FrameSlotRef -> obj.read()
|
||||
is RecordSlotRef -> obj.read()
|
||||
else -> obj
|
||||
}
|
||||
}
|
||||
@@ -732,7 +732,8 @@ private class Parser(fromPos: Pos, private val interpolationEnabled: Boolean = t
|
||||
}
|
||||
val expanded = mutableListOf<Token>()
|
||||
expanded += Token("(", tokenPos, Token.Type.LPAREN)
|
||||
var emittedPieces = 0
|
||||
expanded += Token("", tokenPos, Token.Type.STRING)
|
||||
var emittedPieces = 1
|
||||
for (chunk in chunks) {
|
||||
val pieceTokens = when (chunk) {
|
||||
is StringChunk.Literal -> {
|
||||
@@ -755,9 +756,6 @@ private class Parser(fromPos: Pos, private val interpolationEnabled: Boolean = t
|
||||
expanded += pieceTokens
|
||||
emittedPieces++
|
||||
}
|
||||
if (emittedPieces == 0) {
|
||||
expanded += Token("", tokenPos, Token.Type.STRING)
|
||||
}
|
||||
expanded += Token(")", tokenPos, Token.Type.RPAREN)
|
||||
|
||||
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> {
|
||||
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()
|
||||
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 {
|
||||
|
||||
@@ -17,6 +17,7 @@
|
||||
|
||||
package net.sergeych.lyng
|
||||
|
||||
import com.ionspin.kotlin.bignum.decimal.BigDecimal
|
||||
import net.sergeych.lyng.obj.*
|
||||
|
||||
/**
|
||||
@@ -133,3 +134,6 @@ fun ScopeFacade.raiseIllegalOperation(message: String = "Operation is illegal"):
|
||||
|
||||
fun ScopeFacade.raiseIterationFinished(): Nothing =
|
||||
raiseError(ObjIterationFinishedException(requireScope()))
|
||||
|
||||
suspend fun ScopeFacade.newDecimal(value: BigDecimal): ObjInstance =
|
||||
ObjDecimalSupport.newDecimal(this, value)
|
||||
@@ -27,7 +27,11 @@ import net.sergeych.lyng.bytecode.CmdVm
|
||||
import net.sergeych.lyng.miniast.*
|
||||
import net.sergeych.lyng.obj.*
|
||||
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.matrixLyng
|
||||
import net.sergeych.lyng.stdlib_included.observableLyng
|
||||
import net.sergeych.lyng.stdlib_included.operatorsLyng
|
||||
import net.sergeych.lyng.stdlib_included.rootLyng
|
||||
import net.sergeych.lynon.ObjLynonClass
|
||||
import net.sergeych.mp_tools.globalDefer
|
||||
@@ -46,6 +50,28 @@ class Script(
|
||||
// private val catchReturn: Boolean = false,
|
||||
) : Statement() {
|
||||
fun statements(): List<Statement> = statements
|
||||
|
||||
/**
|
||||
* Explicitly apply this script's import/module bindings to [scope] without executing the script.
|
||||
* This is intended for embedding scenarios where the host owns scope lifecycle and wants
|
||||
* script-specific imports to be a separate, opt-in preparation step.
|
||||
*/
|
||||
suspend fun importInto(scope: Scope, seedScope: Scope = scope): Scope {
|
||||
prepareScriptScope(scope, seedScope)
|
||||
return scope
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a fresh raw module scope and apply this script's import/module bindings to it.
|
||||
* If [seedScope] is provided, its import provider is reused and seed-bound imports resolve from it.
|
||||
*/
|
||||
suspend fun instantiateModule(seedScope: Scope? = null, pos: Pos = this.pos): ModuleScope {
|
||||
val provider = seedScope?.currentImportProvider ?: defaultImportManager
|
||||
val module = provider.newModuleAt(pos)
|
||||
prepareScriptScope(module, seedScope ?: module)
|
||||
return module
|
||||
}
|
||||
|
||||
override suspend fun execute(scope: Scope): Obj {
|
||||
scope.pos = pos
|
||||
val execScope = resolveModuleScope(scope) ?: scope
|
||||
@@ -75,6 +101,19 @@ class Script(
|
||||
return ObjVoid
|
||||
}
|
||||
|
||||
private suspend fun prepareScriptScope(scope: Scope, seedScope: Scope) {
|
||||
if (importBindings.isNotEmpty() || importedModules.isNotEmpty()) {
|
||||
seedImportBindings(scope, seedScope)
|
||||
}
|
||||
if (moduleSlotPlan.isNotEmpty()) {
|
||||
scope.applySlotPlan(moduleSlotPlan)
|
||||
for (name in moduleSlotPlan.keys) {
|
||||
val record = scope.objects[name] ?: scope.localBindings[name] ?: continue
|
||||
scope.updateSlotFor(name, record)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private suspend fun seedModuleSlots(scope: Scope, seedScope: Scope) {
|
||||
if (importBindings.isEmpty() && importedModules.isEmpty()) return
|
||||
seedImportBindings(scope, seedScope)
|
||||
@@ -213,6 +252,44 @@ class Script(
|
||||
|
||||
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
|
||||
* suspended as first time invocation requires compilation of standard library or other
|
||||
@@ -250,87 +327,92 @@ class Script(
|
||||
}
|
||||
addFn("floor") {
|
||||
val x = args.firstAndOnly()
|
||||
(if (x is ObjInt) x
|
||||
else ObjReal(floor(x.toDouble())))
|
||||
decimalAwareRoundLike(x, ObjDecimalSupport::exactFloor, ::floor)
|
||||
}
|
||||
addFn("ceil") {
|
||||
val x = args.firstAndOnly()
|
||||
(if (x is ObjInt) x
|
||||
else ObjReal(ceil(x.toDouble())))
|
||||
decimalAwareRoundLike(x, ObjDecimalSupport::exactCeil, ::ceil)
|
||||
}
|
||||
addFn("round") {
|
||||
val x = args.firstAndOnly()
|
||||
(if (x is ObjInt) x
|
||||
else ObjReal(round(x.toDouble())))
|
||||
decimalAwareRoundLike(x, ObjDecimalSupport::exactRound, ::round)
|
||||
}
|
||||
|
||||
addFn("sin") {
|
||||
ObjReal(sin(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sin)
|
||||
}
|
||||
addFn("cos") {
|
||||
ObjReal(cos(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::cos)
|
||||
}
|
||||
addFn("tan") {
|
||||
ObjReal(tan(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::tan)
|
||||
}
|
||||
addFn("asin") {
|
||||
ObjReal(asin(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::asin)
|
||||
}
|
||||
addFn("acos") {
|
||||
ObjReal(acos(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::acos)
|
||||
}
|
||||
addFn("atan") {
|
||||
ObjReal(atan(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::atan)
|
||||
}
|
||||
|
||||
addFn("sinh") {
|
||||
ObjReal(sinh(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sinh)
|
||||
}
|
||||
addFn("cosh") {
|
||||
ObjReal(cosh(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::cosh)
|
||||
}
|
||||
addFn("tanh") {
|
||||
ObjReal(tanh(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::tanh)
|
||||
}
|
||||
addFn("asinh") {
|
||||
ObjReal(asinh(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::asinh)
|
||||
}
|
||||
addFn("acosh") {
|
||||
ObjReal(acosh(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::acosh)
|
||||
}
|
||||
addFn("atanh") {
|
||||
ObjReal(atanh(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::atanh)
|
||||
}
|
||||
|
||||
addFn("exp") {
|
||||
ObjReal(exp(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::exp)
|
||||
}
|
||||
addFn("ln") {
|
||||
ObjReal(ln(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::ln)
|
||||
}
|
||||
|
||||
addFn("log10") {
|
||||
ObjReal(log10(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::log10)
|
||||
}
|
||||
|
||||
addFn("log2") {
|
||||
ObjReal(log2(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::log2)
|
||||
}
|
||||
|
||||
addFn("pow") {
|
||||
requireExactCount(2)
|
||||
ObjReal(
|
||||
(args[0].toDouble()).pow(args[1].toDouble())
|
||||
)
|
||||
decimalAwarePow(args[0], args[1])
|
||||
}
|
||||
addFn("sqrt") {
|
||||
ObjReal(
|
||||
sqrt(args.firstAndOnly().toDouble())
|
||||
addItem(
|
||||
"sqrt",
|
||||
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") {
|
||||
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(
|
||||
@@ -505,10 +587,6 @@ class Script(
|
||||
cachedValue
|
||||
}
|
||||
}
|
||||
addFn("lazy") {
|
||||
val builder = requireOnlyArg<Obj>()
|
||||
ObjLazyDelegate(builder, requireScope())
|
||||
}
|
||||
addVoidFn("delay") {
|
||||
val a = args.firstAndOnly()
|
||||
when (a) {
|
||||
@@ -582,12 +660,88 @@ class Script(
|
||||
type = type("lyng.Real")
|
||||
)
|
||||
getOrCreateNamespace("Math").apply {
|
||||
fun ensureFn(name: String, fn: suspend ScopeFacade.() -> Obj) {
|
||||
if (members.containsKey(name)) return
|
||||
addFn(name, code = fn)
|
||||
}
|
||||
addConstDoc(
|
||||
name = "PI",
|
||||
value = pi,
|
||||
doc = "The mathematical constant pi (π) in the Math namespace.",
|
||||
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 }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -696,6 +850,44 @@ class Script(
|
||||
module.addConst("ChangeRejectionException", ObjChangeRejectionExceptionClass)
|
||||
module.eval(Source("lyng.observable", observableLyng))
|
||||
}
|
||||
addPackage("lyng.operators") { module ->
|
||||
module.eval(Source("lyng.operators", operatorsLyng))
|
||||
module.bindObject("OperatorInterop") {
|
||||
addFun("register") {
|
||||
val leftClass = requiredArg<ObjClass>(0)
|
||||
val rightClass = requiredArg<ObjClass>(1)
|
||||
val commonClass = requiredArg<ObjClass>(2)
|
||||
val operators = requiredArg<ObjList>(3).list.map { value ->
|
||||
val entry = value as? ObjEnumEntry
|
||||
?: requireScope().raiseIllegalArgument(
|
||||
"OperatorInterop.register expects BinaryOperator enum entries"
|
||||
)
|
||||
entry.name.value
|
||||
}
|
||||
OperatorInteropRegistry.register(
|
||||
leftClass = leftClass,
|
||||
rightClass = rightClass,
|
||||
commonClass = commonClass,
|
||||
operatorNames = operators,
|
||||
leftToCommon = args[4],
|
||||
rightToCommon = args[5]
|
||||
)
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
}
|
||||
addPackage("lyng.decimal") { module ->
|
||||
module.eval(Source("lyng.decimal", decimalLyng))
|
||||
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") {
|
||||
it.addConstDoc(
|
||||
name = "Buffer",
|
||||
|
||||
@@ -24,6 +24,7 @@ class VarDeclStatement(
|
||||
val name: String,
|
||||
val isMutable: Boolean,
|
||||
val visibility: Visibility,
|
||||
val actualExtern: Boolean,
|
||||
val initializer: Statement?,
|
||||
val isTransient: Boolean,
|
||||
val typeDecl: TypeDecl?,
|
||||
|
||||
@@ -42,6 +42,9 @@ class BytecodeCompiler(
|
||||
private val callableReturnTypeByScopeId: Map<Int, Map<Int, ObjClass>> = emptyMap(),
|
||||
private val callableReturnTypeByName: Map<String, ObjClass> = emptyMap(),
|
||||
private val externCallableNames: 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 useScopeSlots: Boolean = allowedScopeNames != null || scopeSlotNameSet != null
|
||||
@@ -52,12 +55,15 @@ class BytecodeCompiler(
|
||||
private var scopeSlotIndices = IntArray(0)
|
||||
private var scopeSlotNames = emptyArray<String?>()
|
||||
private var scopeSlotIsModule = BooleanArray(0)
|
||||
private var scopeSlotRequiresPreparedBinding = BooleanArray(0)
|
||||
private var scopeSlotRefPos = emptyArray<Pos?>()
|
||||
private var scopeSlotMutables = BooleanArray(0)
|
||||
private var scopeKeyByIndex = emptyArray<ScopeSlotKey?>()
|
||||
private val scopeSlotMap = LinkedHashMap<ScopeSlotKey, Int>()
|
||||
private val scopeSlotNameMap = LinkedHashMap<ScopeSlotKey, String>()
|
||||
private val scopeSlotMutableMap = LinkedHashMap<ScopeSlotKey, Boolean>()
|
||||
private val scopeSlotIndexByName = LinkedHashMap<String, Int>()
|
||||
private val scopeSlotRefPosByKey = LinkedHashMap<ScopeSlotKey, Pos>()
|
||||
private val pendingScopeNameRefs = LinkedHashSet<String>()
|
||||
private val addrSlotByScopeSlot = LinkedHashMap<Int, Int>()
|
||||
private data class LocalSlotInfo(val name: String, val isMutable: Boolean, val isDelegated: Boolean)
|
||||
@@ -118,6 +124,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices,
|
||||
scopeSlotNames,
|
||||
scopeSlotIsModule,
|
||||
scopeSlotRequiresPreparedBinding,
|
||||
scopeSlotRefPos,
|
||||
localSlotNames,
|
||||
localSlotMutables,
|
||||
localSlotDelegated,
|
||||
@@ -139,6 +147,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices,
|
||||
scopeSlotNames,
|
||||
scopeSlotIsModule,
|
||||
scopeSlotRequiresPreparedBinding,
|
||||
scopeSlotRefPos,
|
||||
localSlotNames,
|
||||
localSlotMutables,
|
||||
localSlotDelegated,
|
||||
@@ -157,6 +167,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices,
|
||||
scopeSlotNames,
|
||||
scopeSlotIsModule,
|
||||
scopeSlotRequiresPreparedBinding,
|
||||
scopeSlotRefPos,
|
||||
localSlotNames,
|
||||
localSlotMutables,
|
||||
localSlotDelegated,
|
||||
@@ -175,6 +187,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices,
|
||||
scopeSlotNames,
|
||||
scopeSlotIsModule,
|
||||
scopeSlotRequiresPreparedBinding,
|
||||
scopeSlotRefPos,
|
||||
localSlotNames,
|
||||
localSlotMutables,
|
||||
localSlotDelegated,
|
||||
@@ -193,6 +207,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices,
|
||||
scopeSlotNames,
|
||||
scopeSlotIsModule,
|
||||
scopeSlotRequiresPreparedBinding,
|
||||
scopeSlotRefPos,
|
||||
localSlotNames,
|
||||
localSlotMutables,
|
||||
localSlotDelegated,
|
||||
@@ -211,6 +227,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices,
|
||||
scopeSlotNames,
|
||||
scopeSlotIsModule,
|
||||
scopeSlotRequiresPreparedBinding,
|
||||
scopeSlotRefPos,
|
||||
localSlotNames,
|
||||
localSlotMutables,
|
||||
localSlotDelegated,
|
||||
@@ -229,6 +247,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices,
|
||||
scopeSlotNames,
|
||||
scopeSlotIsModule,
|
||||
scopeSlotRequiresPreparedBinding,
|
||||
scopeSlotRefPos,
|
||||
localSlotNames,
|
||||
localSlotMutables,
|
||||
localSlotDelegated,
|
||||
@@ -247,6 +267,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices,
|
||||
scopeSlotNames,
|
||||
scopeSlotIsModule,
|
||||
scopeSlotRequiresPreparedBinding,
|
||||
scopeSlotRefPos,
|
||||
localSlotNames,
|
||||
localSlotMutables,
|
||||
localSlotDelegated,
|
||||
@@ -265,6 +287,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices,
|
||||
scopeSlotNames,
|
||||
scopeSlotIsModule,
|
||||
scopeSlotRequiresPreparedBinding,
|
||||
scopeSlotRefPos,
|
||||
localSlotNames,
|
||||
localSlotMutables,
|
||||
localSlotDelegated,
|
||||
@@ -283,6 +307,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices,
|
||||
scopeSlotNames,
|
||||
scopeSlotIsModule,
|
||||
scopeSlotRequiresPreparedBinding,
|
||||
scopeSlotRefPos,
|
||||
localSlotNames,
|
||||
localSlotMutables,
|
||||
localSlotDelegated,
|
||||
@@ -301,6 +327,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices,
|
||||
scopeSlotNames,
|
||||
scopeSlotIsModule,
|
||||
scopeSlotRequiresPreparedBinding,
|
||||
scopeSlotRefPos,
|
||||
localSlotNames,
|
||||
localSlotMutables,
|
||||
localSlotDelegated,
|
||||
@@ -321,6 +349,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices,
|
||||
scopeSlotNames,
|
||||
scopeSlotIsModule,
|
||||
scopeSlotRequiresPreparedBinding,
|
||||
scopeSlotRefPos,
|
||||
localSlotNames,
|
||||
localSlotMutables,
|
||||
localSlotDelegated,
|
||||
@@ -339,6 +369,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices,
|
||||
scopeSlotNames,
|
||||
scopeSlotIsModule,
|
||||
scopeSlotRequiresPreparedBinding,
|
||||
scopeSlotRefPos,
|
||||
localSlotNames,
|
||||
localSlotMutables,
|
||||
localSlotDelegated,
|
||||
@@ -357,6 +389,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices,
|
||||
scopeSlotNames,
|
||||
scopeSlotIsModule,
|
||||
scopeSlotRequiresPreparedBinding,
|
||||
scopeSlotRefPos,
|
||||
localSlotNames,
|
||||
localSlotMutables,
|
||||
localSlotDelegated,
|
||||
@@ -375,6 +409,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices,
|
||||
scopeSlotNames,
|
||||
scopeSlotIsModule,
|
||||
scopeSlotRequiresPreparedBinding,
|
||||
scopeSlotRefPos,
|
||||
localSlotNames,
|
||||
localSlotMutables,
|
||||
localSlotDelegated,
|
||||
@@ -394,6 +430,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices,
|
||||
scopeSlotNames,
|
||||
scopeSlotIsModule,
|
||||
scopeSlotRequiresPreparedBinding,
|
||||
scopeSlotRefPos,
|
||||
localSlotNames,
|
||||
localSlotMutables,
|
||||
localSlotDelegated,
|
||||
@@ -415,6 +453,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices,
|
||||
scopeSlotNames,
|
||||
scopeSlotIsModule,
|
||||
scopeSlotRequiresPreparedBinding,
|
||||
scopeSlotRefPos,
|
||||
localSlotNames,
|
||||
localSlotMutables,
|
||||
localSlotDelegated,
|
||||
@@ -438,6 +478,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices,
|
||||
scopeSlotNames,
|
||||
scopeSlotIsModule,
|
||||
scopeSlotRequiresPreparedBinding,
|
||||
scopeSlotRefPos,
|
||||
localSlotNames,
|
||||
localSlotMutables,
|
||||
localSlotDelegated,
|
||||
@@ -458,6 +500,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices,
|
||||
scopeSlotNames,
|
||||
scopeSlotIsModule,
|
||||
scopeSlotRequiresPreparedBinding,
|
||||
scopeSlotRefPos,
|
||||
localSlotNames,
|
||||
localSlotMutables,
|
||||
localSlotDelegated,
|
||||
@@ -533,6 +577,7 @@ class BytecodeCompiler(
|
||||
resolved = SlotType.INT
|
||||
}
|
||||
if (mapped < scopeSlotCount && resolved != SlotType.UNKNOWN) {
|
||||
noteScopeSlotRef(mapped, ref.pos())
|
||||
val addrSlot = ensureScopeAddr(mapped)
|
||||
val local = allocSlot()
|
||||
emitLoadFromAddr(addrSlot, local, resolved)
|
||||
@@ -543,6 +588,7 @@ class BytecodeCompiler(
|
||||
return CompiledValue(local, resolved)
|
||||
}
|
||||
if (mapped < scopeSlotCount && resolved == SlotType.UNKNOWN) {
|
||||
noteScopeSlotRef(mapped, ref.pos())
|
||||
val addrSlot = ensureScopeAddr(mapped)
|
||||
val local = allocSlot()
|
||||
emitLoadFromAddr(addrSlot, local, SlotType.OBJ)
|
||||
@@ -562,6 +608,7 @@ class BytecodeCompiler(
|
||||
}
|
||||
if (allowLocalSlots) {
|
||||
scopeSlotIndexByName[ref.name]?.let { slot ->
|
||||
noteScopeSlotRef(slot, callSitePos())
|
||||
val resolved = slotTypes[slot] ?: SlotType.UNKNOWN
|
||||
return CompiledValue(slot, resolved)
|
||||
}
|
||||
@@ -584,6 +631,7 @@ class BytecodeCompiler(
|
||||
return CompiledValue(slot, resolved)
|
||||
}
|
||||
scopeSlotIndexByName[ref.name]?.let { slot ->
|
||||
noteScopeSlotRef(slot, callSitePos())
|
||||
val resolved = slotTypes[slot] ?: SlotType.UNKNOWN
|
||||
return CompiledValue(slot, resolved)
|
||||
}
|
||||
@@ -595,6 +643,7 @@ class BytecodeCompiler(
|
||||
val slot = ref.slotIndex()
|
||||
val resolved = slotTypes[slot] ?: SlotType.UNKNOWN
|
||||
if (slot < scopeSlotCount && resolved != SlotType.UNKNOWN) {
|
||||
noteScopeSlotRef(slot, callSitePos())
|
||||
val addrSlot = ensureScopeAddr(slot)
|
||||
val local = allocSlot()
|
||||
emitLoadFromAddr(addrSlot, local, resolved)
|
||||
@@ -1088,7 +1137,6 @@ class BytecodeCompiler(
|
||||
|
||||
private fun isDelegateClass(receiverClass: ObjClass): Boolean =
|
||||
receiverClass.className == "Delegate" ||
|
||||
receiverClass.className == "LazyDelegate" ||
|
||||
receiverClass.implementingNames.contains("Delegate")
|
||||
|
||||
private fun operatorMemberName(op: BinOp): String? = when (op) {
|
||||
@@ -2396,7 +2444,8 @@ class BytecodeCompiler(
|
||||
builder.emit(Opcode.THROW, posId, msgSlot)
|
||||
return value
|
||||
}
|
||||
val slot = resolveSlot(localTarget)
|
||||
val slot = resolveCapturedOwnerScopeSlot(localTarget)
|
||||
?: resolveSlot(localTarget)
|
||||
?: resolveAssignableSlotByName(localTarget.name)?.first
|
||||
?: return null
|
||||
if (slot < scopeSlotCount && value.type != SlotType.UNKNOWN) {
|
||||
@@ -2702,7 +2751,7 @@ class BytecodeCompiler(
|
||||
return CompiledValue(result, SlotType.OBJ)
|
||||
}
|
||||
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
|
||||
if (!localTarget.isMutable) {
|
||||
if (targetType != SlotType.OBJ && targetType != SlotType.UNKNOWN) return compileEvalRef(ref)
|
||||
@@ -4508,7 +4557,7 @@ class BytecodeCompiler(
|
||||
val resolved = slotTypes[slot] ?: SlotType.UNKNOWN
|
||||
return CompiledValue(slot, resolved)
|
||||
}
|
||||
if (useScopeSlots && allowedScopeNames?.contains(name) == true) {
|
||||
if (useScopeSlots && isPreparedScopeName(name)) {
|
||||
scopeSlotIndexByName[name]?.let { slot ->
|
||||
val resolved = slotTypes[slot] ?: SlotType.UNKNOWN
|
||||
return CompiledValue(slot, resolved)
|
||||
@@ -5001,6 +5050,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices,
|
||||
scopeSlotNames,
|
||||
scopeSlotIsModule,
|
||||
scopeSlotRequiresPreparedBinding,
|
||||
scopeSlotRefPos,
|
||||
localSlotNames,
|
||||
localSlotMutables,
|
||||
localSlotDelegated,
|
||||
@@ -5020,6 +5071,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices,
|
||||
scopeSlotNames,
|
||||
scopeSlotIsModule,
|
||||
scopeSlotRequiresPreparedBinding,
|
||||
scopeSlotRefPos,
|
||||
localSlotNames,
|
||||
localSlotMutables,
|
||||
localSlotDelegated,
|
||||
@@ -5040,6 +5093,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices,
|
||||
scopeSlotNames,
|
||||
scopeSlotIsModule,
|
||||
scopeSlotRequiresPreparedBinding,
|
||||
scopeSlotRefPos,
|
||||
localSlotNames,
|
||||
localSlotMutables,
|
||||
localSlotDelegated,
|
||||
@@ -5060,6 +5115,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices,
|
||||
scopeSlotNames,
|
||||
scopeSlotIsModule,
|
||||
scopeSlotRequiresPreparedBinding,
|
||||
scopeSlotRefPos,
|
||||
localSlotNames,
|
||||
localSlotMutables,
|
||||
localSlotDelegated,
|
||||
@@ -5083,6 +5140,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices,
|
||||
scopeSlotNames,
|
||||
scopeSlotIsModule,
|
||||
scopeSlotRequiresPreparedBinding,
|
||||
scopeSlotRefPos,
|
||||
localSlotNames,
|
||||
localSlotMutables,
|
||||
localSlotDelegated,
|
||||
@@ -5102,6 +5161,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices,
|
||||
scopeSlotNames,
|
||||
scopeSlotIsModule,
|
||||
scopeSlotRequiresPreparedBinding,
|
||||
scopeSlotRefPos,
|
||||
localSlotNames,
|
||||
localSlotMutables,
|
||||
localSlotDelegated,
|
||||
@@ -5726,6 +5787,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices,
|
||||
scopeSlotNames,
|
||||
scopeSlotIsModule,
|
||||
scopeSlotRequiresPreparedBinding,
|
||||
scopeSlotRefPos,
|
||||
localSlotNames,
|
||||
localSlotMutables,
|
||||
localSlotDelegated,
|
||||
@@ -7598,6 +7661,14 @@ class BytecodeCompiler(
|
||||
private fun assignValue(ref: AssignRef): ObjRef = ref.value
|
||||
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? {
|
||||
loopSlotOverrides[ref.name]?.let { return it }
|
||||
val scopeId = refScopeId(ref)
|
||||
@@ -7605,8 +7676,18 @@ class BytecodeCompiler(
|
||||
val key = ScopeSlotKey(scopeId, refSlot(ref))
|
||||
val localIndex = localSlotIndexByKey[key]
|
||||
if (localIndex != null) return scopeSlotCount + localIndex
|
||||
scopeSlotMap[key]?.let { return it }
|
||||
scopeSlotIndexByName[ref.name]?.let { return it }
|
||||
scopeSlotMap[key]?.let {
|
||||
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) {
|
||||
val scopeKey = ScopeSlotKey(refScopeId(ref), refSlot(ref))
|
||||
@@ -7616,7 +7697,13 @@ class BytecodeCompiler(
|
||||
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) {
|
||||
val localKey = ScopeSlotKey(refScopeId(ref), refSlot(ref))
|
||||
@@ -7627,7 +7714,20 @@ class BytecodeCompiler(
|
||||
val localIndex = localSlotIndexByKey[localKey]
|
||||
if (localIndex != null) return scopeSlotCount + localIndex
|
||||
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) {
|
||||
@@ -7850,6 +7950,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices = IntArray(scopeSlotCount)
|
||||
scopeSlotNames = arrayOfNulls(scopeSlotCount)
|
||||
scopeSlotIsModule = BooleanArray(scopeSlotCount)
|
||||
scopeSlotRequiresPreparedBinding = BooleanArray(scopeSlotCount)
|
||||
scopeSlotRefPos = arrayOfNulls(scopeSlotCount)
|
||||
scopeSlotMutables = BooleanArray(scopeSlotCount) { true }
|
||||
scopeKeyByIndex = arrayOfNulls(scopeSlotCount)
|
||||
for ((key, index) in scopeSlotMap) {
|
||||
@@ -7857,6 +7959,8 @@ class BytecodeCompiler(
|
||||
scopeSlotIndices[index] = key.slot
|
||||
scopeSlotNames[index] = name
|
||||
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 }
|
||||
scopeKeyByIndex[index] = key
|
||||
}
|
||||
@@ -8073,7 +8177,7 @@ class BytecodeCompiler(
|
||||
slotInitClassByKey[ScopeSlotKey(scopeId, slotIndex)] = cls
|
||||
}
|
||||
}
|
||||
if (allowLocalSlots && slotIndex != null && !shouldUseScopeSlotFor(scopeId)) {
|
||||
if (allowLocalSlots && slotIndex != null && (stmt.actualExtern || !shouldUseScopeSlotFor(scopeId, stmt.name, isDelegated = false))) {
|
||||
val key = ScopeSlotKey(scopeId, slotIndex)
|
||||
declaredLocalKeys.add(key)
|
||||
if (!localSlotInfoMap.containsKey(key)) {
|
||||
@@ -8100,7 +8204,7 @@ class BytecodeCompiler(
|
||||
val scopeId = stmt.spec.scopeId ?: 0
|
||||
if (slotIndex != null) {
|
||||
val key = ScopeSlotKey(scopeId, slotIndex)
|
||||
if (allowLocalSlots && !shouldUseScopeSlotFor(scopeId)) {
|
||||
if (allowLocalSlots && !shouldUseScopeSlotFor(scopeId, stmt.spec.name, isDelegated = false)) {
|
||||
if (!localSlotInfoMap.containsKey(key)) {
|
||||
localSlotInfoMap[key] = LocalSlotInfo(stmt.spec.name, isMutable = false, isDelegated = false)
|
||||
}
|
||||
@@ -8117,7 +8221,7 @@ class BytecodeCompiler(
|
||||
is DelegatedVarDeclStatement -> {
|
||||
val slotIndex = stmt.slotIndex
|
||||
val scopeId = stmt.scopeId ?: 0
|
||||
if (allowLocalSlots && slotIndex != null && !shouldUseScopeSlotFor(scopeId)) {
|
||||
if (allowLocalSlots && slotIndex != null && !shouldUseScopeSlotFor(scopeId, stmt.name, isDelegated = true)) {
|
||||
val key = ScopeSlotKey(scopeId, slotIndex)
|
||||
declaredLocalKeys.add(key)
|
||||
if (!localSlotInfoMap.containsKey(key)) {
|
||||
@@ -8283,15 +8387,26 @@ class BytecodeCompiler(
|
||||
|
||||
private fun isModuleSlot(scopeId: Int, name: String?): Boolean {
|
||||
if (moduleScopeId != null && scopeId != moduleScopeId) return false
|
||||
val scopeNames = allowedScopeNames ?: scopeSlotNameSet
|
||||
if (scopeNames == null || name == null) return false
|
||||
return scopeNames.contains(name)
|
||||
return isPreparedScopeName(name)
|
||||
}
|
||||
|
||||
private fun shouldUseScopeSlotFor(scopeId: Int): Boolean {
|
||||
return useScopeSlots && moduleScopeId != null && scopeId == moduleScopeId
|
||||
}
|
||||
|
||||
private fun shouldUseScopeSlotFor(scopeId: Int, name: String, isDelegated: Boolean): Boolean {
|
||||
if (moduleScopeId == null || scopeId != moduleScopeId) return false
|
||||
if (isDelegated) return false
|
||||
if (externBindingNames.contains(name)) return true
|
||||
return useScopeSlots && isPreparedScopeName(name)
|
||||
}
|
||||
|
||||
private fun isPreparedScopeName(name: String?): Boolean {
|
||||
if (name == null) return false
|
||||
if (scopeSlotNameSet?.contains(name) == true) return true
|
||||
return allowedScopeNames?.contains(name) == true
|
||||
}
|
||||
|
||||
private fun collectLoopVarNames(stmt: Statement) {
|
||||
if (stmt is BytecodeStatement) {
|
||||
collectLoopVarNames(stmt.original)
|
||||
@@ -8400,8 +8515,9 @@ class BytecodeCompiler(
|
||||
captureSlotKeys.add(key)
|
||||
return
|
||||
}
|
||||
val forceScopeSlot = shouldUseScopeSlotFor(scopeId, ref.name, ref.isDelegated)
|
||||
val isModuleSlot = if (ref.isDelegated) false else isModuleSlot(scopeId, ref.name)
|
||||
if (allowLocalSlots && !isModuleSlot) {
|
||||
if (allowLocalSlots && !isModuleSlot && !forceScopeSlot) {
|
||||
if (!localSlotInfoMap.containsKey(key)) {
|
||||
localSlotInfoMap[key] = LocalSlotInfo(ref.name, ref.isMutable, ref.isDelegated)
|
||||
}
|
||||
@@ -8448,8 +8564,9 @@ class BytecodeCompiler(
|
||||
}
|
||||
captureSlotKeys.add(key)
|
||||
} else {
|
||||
val forceScopeSlot = shouldUseScopeSlotFor(scopeId, target.name, target.isDelegated)
|
||||
val isModuleSlot = if (target.isDelegated) false else isModuleSlot(scopeId, target.name)
|
||||
if (allowLocalSlots && !isModuleSlot) {
|
||||
if (allowLocalSlots && !isModuleSlot && !forceScopeSlot) {
|
||||
if (!localSlotInfoMap.containsKey(key)) {
|
||||
localSlotInfoMap[key] = LocalSlotInfo(target.name, target.isMutable, target.isDelegated)
|
||||
}
|
||||
|
||||
@@ -50,7 +50,7 @@ class BytecodeStatement private constructor(
|
||||
?: scope.parent?.get(name)
|
||||
?: scope.get(name)
|
||||
?: 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)
|
||||
} else {
|
||||
record.value
|
||||
@@ -87,6 +87,9 @@ class BytecodeStatement private constructor(
|
||||
callableReturnTypeByScopeId: Map<Int, Map<Int, ObjClass>> = emptyMap(),
|
||||
callableReturnTypeByName: Map<String, ObjClass> = emptyMap(),
|
||||
externCallableNames: Set<String> = emptySet(),
|
||||
externBindingNames: Set<String> = emptySet(),
|
||||
preparedModuleBindingNames: Set<String> = emptySet(),
|
||||
scopeRefPosByName: Map<String, Pos> = emptyMap(),
|
||||
lambdaCaptureEntriesByRef: Map<ValueFnRef, List<LambdaCaptureEntry>> = emptyMap(),
|
||||
slotTypeDeclByScopeId: Map<Int, Map<Int, TypeDecl>> = emptyMap(),
|
||||
): Statement {
|
||||
@@ -122,6 +125,9 @@ class BytecodeStatement private constructor(
|
||||
callableReturnTypeByScopeId = callableReturnTypeByScopeId,
|
||||
callableReturnTypeByName = callableReturnTypeByName,
|
||||
externCallableNames = externCallableNames,
|
||||
externBindingNames = externBindingNames,
|
||||
preparedModuleBindingNames = preparedModuleBindingNames,
|
||||
scopeRefPosByName = scopeRefPosByName,
|
||||
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
|
||||
)
|
||||
val compiled = compiler.compileStatement(nameHint, statement)
|
||||
@@ -236,6 +242,7 @@ class BytecodeStatement private constructor(
|
||||
stmt.name,
|
||||
stmt.isMutable,
|
||||
stmt.visibility,
|
||||
stmt.actualExtern,
|
||||
stmt.initializer?.let { unwrapDeep(it) },
|
||||
stmt.isTransient,
|
||||
stmt.typeDecl,
|
||||
|
||||
@@ -67,6 +67,8 @@ class CmdBuilder {
|
||||
scopeSlotIndices: IntArray = IntArray(0),
|
||||
scopeSlotNames: Array<String?> = emptyArray(),
|
||||
scopeSlotIsModule: BooleanArray = BooleanArray(0),
|
||||
scopeSlotRequiresPreparedBinding: BooleanArray = BooleanArray(0),
|
||||
scopeSlotRefPos: Array<net.sergeych.lyng.Pos?> = emptyArray(),
|
||||
localSlotNames: Array<String?> = emptyArray(),
|
||||
localSlotMutables: BooleanArray = BooleanArray(0),
|
||||
localSlotDelegated: BooleanArray = BooleanArray(0),
|
||||
@@ -79,6 +81,12 @@ class CmdBuilder {
|
||||
require(scopeSlotIsModule.isEmpty() || scopeSlotIsModule.size == scopeSlotCount) {
|
||||
"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 == localSlotDelegated.size) { "local slot delegation size mismatch" }
|
||||
require(localSlotNames.size == localSlotCaptures.size) { "local slot capture size mismatch" }
|
||||
@@ -113,6 +121,8 @@ class CmdBuilder {
|
||||
scopeSlotIndices = scopeSlotIndices,
|
||||
scopeSlotNames = if (scopeSlotNames.isEmpty()) Array(scopeSlotCount) { null } else scopeSlotNames,
|
||||
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,
|
||||
localSlotMutables = localSlotMutables,
|
||||
localSlotDelegated = localSlotDelegated,
|
||||
|
||||
@@ -26,6 +26,8 @@ data class CmdFunction(
|
||||
val scopeSlotIndices: IntArray,
|
||||
val scopeSlotNames: Array<String?>,
|
||||
val scopeSlotIsModule: BooleanArray,
|
||||
val scopeSlotRequiresPreparedBinding: BooleanArray,
|
||||
val scopeSlotRefPos: Array<net.sergeych.lyng.Pos?>,
|
||||
val localSlotNames: Array<String?>,
|
||||
val localSlotMutables: BooleanArray,
|
||||
val localSlotDelegated: BooleanArray,
|
||||
@@ -38,6 +40,8 @@ data class CmdFunction(
|
||||
require(scopeSlotIndices.size == scopeSlotCount) { "scopeSlotIndices size mismatch" }
|
||||
require(scopeSlotNames.size == scopeSlotCount) { "scopeSlotNames 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 == localSlotDelegated.size) { "localSlot delegation 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() {
|
||||
override suspend fun perform(frame: CmdFrame) {
|
||||
val value = frame.slotToObj(src)
|
||||
if (frame.writeThroughPropertyLikeSlot(dst, value)) {
|
||||
return
|
||||
}
|
||||
if (frame.shouldBypassImmutableWrite(dst)) {
|
||||
frame.setObjUnchecked(dst, value)
|
||||
} 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() {
|
||||
override suspend fun perform(frame: CmdFrame) {
|
||||
val value = frame.getInt(src)
|
||||
if (frame.writeThroughPropertyLikeSlot(dst, ObjInt.of(value))) {
|
||||
return
|
||||
}
|
||||
if (frame.shouldBypassImmutableWrite(dst)) {
|
||||
frame.setIntUnchecked(dst, value)
|
||||
} 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() {
|
||||
override suspend fun perform(frame: CmdFrame) {
|
||||
val value = frame.getReal(src)
|
||||
if (frame.writeThroughPropertyLikeSlot(dst, ObjReal.of(value))) {
|
||||
return
|
||||
}
|
||||
if (frame.shouldBypassImmutableWrite(dst)) {
|
||||
frame.setRealUnchecked(dst, value)
|
||||
} 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() {
|
||||
override suspend fun perform(frame: CmdFrame) {
|
||||
val value = frame.getBool(src)
|
||||
if (frame.writeThroughPropertyLikeSlot(dst, if (value) ObjTrue else ObjFalse)) {
|
||||
return
|
||||
}
|
||||
if (frame.shouldBypassImmutableWrite(dst)) {
|
||||
frame.setBoolUnchecked(dst, value)
|
||||
} else {
|
||||
@@ -2392,8 +2404,13 @@ class CmdDeclLocal(internal val constId: Int, internal val slot: Int) : Cmd() {
|
||||
?: error("DECL_LOCAL expects LocalDecl at $constId")
|
||||
if (slot < frame.fn.scopeSlotCount) {
|
||||
val target = frame.scopeTarget(slot)
|
||||
frame.ensureScopeSlot(target, slot)
|
||||
val value = frame.slotToObj(slot).byValueCopy()
|
||||
val index = frame.ensureScopeSlot(target, slot)
|
||||
val raw = target.getSlotRecord(index).value
|
||||
val value = when (raw) {
|
||||
is FrameSlotRef -> raw.read()
|
||||
is RecordSlotRef -> raw.read()
|
||||
else -> raw
|
||||
}.byValueCopy()
|
||||
target.updateSlotFor(
|
||||
decl.name,
|
||||
ObjRecord(
|
||||
@@ -2590,7 +2607,7 @@ private fun buildFunctionCaptureRecords(frame: CmdFrame, captureNames: List<Stri
|
||||
}
|
||||
val scoped = frame.scope.chainLookupIgnoreClosure(name, followClosure = true) ?: frame.scope.get(name)
|
||||
if (scoped != null) {
|
||||
records += ObjRecord(RecordSlotRef(scoped), isMutable = scoped.isMutable)
|
||||
records += scoped
|
||||
continue
|
||||
}
|
||||
frame.ensureScope().raiseSymbolNotFound("capture $name not found")
|
||||
@@ -2853,7 +2870,7 @@ class CmdDeclInstanceProperty(internal val constId: Int, internal val slot: Int)
|
||||
val decl = frame.fn.constants[constId] as? BytecodeConst.InstancePropertyDecl
|
||||
?: error("DECL_INSTANCE_PROPERTY expects InstancePropertyDecl at $constId")
|
||||
val scope = frame.ensureScope()
|
||||
val prop = frame.slotToObj(slot)
|
||||
val prop = frame.storedSlotObj(slot)
|
||||
scope.addItem(
|
||||
decl.name,
|
||||
decl.isMutable,
|
||||
@@ -3719,7 +3736,7 @@ class BytecodeLambdaCallable(
|
||||
?: context.parent?.get(name)
|
||||
?: context.get(name)
|
||||
?: 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)
|
||||
} else {
|
||||
record.value
|
||||
@@ -3812,7 +3829,29 @@ class CmdFrame(
|
||||
}
|
||||
|
||||
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 {
|
||||
if (slot < fn.scopeSlotCount) return false
|
||||
val localIndex = slot - fn.scopeSlotCount
|
||||
@@ -3930,7 +3969,7 @@ class CmdFrame(
|
||||
} else {
|
||||
val raw = frame.getRawObj(localIndex)
|
||||
if (raw == null && name != null) {
|
||||
val record = scope.get(name)
|
||||
val record = findNamedExistingRecord(scope, name)
|
||||
if (record != null) {
|
||||
val value = record.value
|
||||
return@mapIndexed when (value) {
|
||||
@@ -3939,6 +3978,12 @@ class CmdFrame(
|
||||
else -> ObjRecord(value, isMutable)
|
||||
}
|
||||
}
|
||||
if (hasNamedScopeBinding(scope, name)) {
|
||||
throw ScriptError(
|
||||
ensureScope().pos,
|
||||
"captured binding '$name' is not available in the execution scope; prepare the script imports/module bindings explicitly"
|
||||
)
|
||||
}
|
||||
}
|
||||
when (raw) {
|
||||
is FrameSlotRef -> ObjRecord(raw, isMutable)
|
||||
@@ -3952,22 +3997,27 @@ class CmdFrame(
|
||||
val target = moduleScope
|
||||
val name = captureNames?.getOrNull(index)
|
||||
if (name != null) {
|
||||
target.tryGetLocalRecord(target, name, target.currentClassCtx)?.let { return@mapIndexed it }
|
||||
target.getSlotIndexOf(name)?.let { return@mapIndexed target.getSlotRecord(it) }
|
||||
target.get(name)?.let { return@mapIndexed it }
|
||||
findNamedExistingRecord(target, name)?.let { return@mapIndexed it }
|
||||
// Fallback to current scope in case the module scope isn't in the parent chain
|
||||
// or doesn't carry the imported symbol yet.
|
||||
scope.tryGetLocalRecord(scope, name, scope.currentClassCtx)?.let { return@mapIndexed it }
|
||||
scope.get(name)?.let { return@mapIndexed it }
|
||||
findNamedExistingRecord(scope, name)?.let { return@mapIndexed it }
|
||||
}
|
||||
if (slotId < target.slotCount) {
|
||||
return@mapIndexed target.getSlotRecord(slotId)
|
||||
val existing = target.getSlotRecord(slotId)
|
||||
if (name == null || existing.value !== ObjUnset || hasResolvedNamedScopeBinding(target, name)) {
|
||||
return@mapIndexed existing
|
||||
}
|
||||
}
|
||||
if (name != null) {
|
||||
target.applySlotPlan(mapOf(name to slotId))
|
||||
return@mapIndexed target.getSlotRecord(slotId)
|
||||
throw ScriptError(
|
||||
ensureScope().pos,
|
||||
"module capture '$name' is not available in the execution scope; prepare the script imports/module bindings explicitly"
|
||||
)
|
||||
}
|
||||
error("Missing module capture slot $slotId")
|
||||
throw ScriptError(
|
||||
ensureScope().pos,
|
||||
"missing module capture slot $slotId"
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -4062,7 +4112,7 @@ class CmdFrame(
|
||||
}
|
||||
|
||||
fun ensureScope(): Scope {
|
||||
val pos = posForIp(ip - 1)
|
||||
val pos = currentErrorPos()
|
||||
if (pos != null && lastScopePosIp != ip) {
|
||||
scope.pos = pos
|
||||
lastScopePosIp = ip
|
||||
@@ -4139,6 +4189,33 @@ class CmdFrame(
|
||||
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>) {
|
||||
if (scope.skipScopeCreation) {
|
||||
val snapshot = emptyMap<String, Int?>()
|
||||
@@ -4246,7 +4323,7 @@ class CmdFrame(
|
||||
return if (slot < fn.scopeSlotCount) {
|
||||
getScopeSlotValue(slot)
|
||||
} else {
|
||||
localSlotToObj(slot - fn.scopeSlotCount)
|
||||
readLocalSlotValue(slot - fn.scopeSlotCount)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4289,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 {
|
||||
return if (slot < fn.scopeSlotCount) {
|
||||
getScopeSlotValue(slot).toLong()
|
||||
@@ -4298,14 +4404,7 @@ class CmdFrame(
|
||||
SlotType.INT.code -> frame.getInt(local)
|
||||
SlotType.REAL.code -> frame.getReal(local).toLong()
|
||||
SlotType.BOOL.code -> if (frame.getBool(local)) 1L else 0L
|
||||
SlotType.OBJ.code -> {
|
||||
val obj = frame.getObj(local)
|
||||
when (obj) {
|
||||
is FrameSlotRef -> obj.read().toLong()
|
||||
is RecordSlotRef -> obj.read().toLong()
|
||||
else -> obj.toLong()
|
||||
}
|
||||
}
|
||||
SlotType.OBJ.code -> readLocalSlotValue(local).toLong()
|
||||
else -> 0L
|
||||
}
|
||||
}
|
||||
@@ -4385,14 +4484,7 @@ class CmdFrame(
|
||||
SlotType.REAL.code -> frame.getReal(local)
|
||||
SlotType.INT.code -> frame.getInt(local).toDouble()
|
||||
SlotType.BOOL.code -> if (frame.getBool(local)) 1.0 else 0.0
|
||||
SlotType.OBJ.code -> {
|
||||
val obj = frame.getObj(local)
|
||||
when (obj) {
|
||||
is FrameSlotRef -> obj.read().toDouble()
|
||||
is RecordSlotRef -> obj.read().toDouble()
|
||||
else -> obj.toDouble()
|
||||
}
|
||||
}
|
||||
SlotType.OBJ.code -> readLocalSlotValue(local).toDouble()
|
||||
else -> 0.0
|
||||
}
|
||||
}
|
||||
@@ -4461,14 +4553,7 @@ class CmdFrame(
|
||||
SlotType.BOOL.code -> frame.getBool(local)
|
||||
SlotType.INT.code -> frame.getInt(local) != 0L
|
||||
SlotType.REAL.code -> frame.getReal(local) != 0.0
|
||||
SlotType.OBJ.code -> {
|
||||
val obj = frame.getObj(local)
|
||||
when (obj) {
|
||||
is FrameSlotRef -> obj.read().toBool()
|
||||
is RecordSlotRef -> obj.read().toBool()
|
||||
else -> obj.toBool()
|
||||
}
|
||||
}
|
||||
SlotType.OBJ.code -> readLocalSlotValue(local).toBool()
|
||||
else -> false
|
||||
}
|
||||
}
|
||||
@@ -4546,7 +4631,7 @@ class CmdFrame(
|
||||
return getScopeSlotValueAtAddr(addrSlot)
|
||||
}
|
||||
|
||||
fun setAddrObj(addrSlot: Int, value: Obj) {
|
||||
suspend fun setAddrObj(addrSlot: Int, value: Obj) {
|
||||
setScopeSlotValueAtAddr(addrSlot, value)
|
||||
}
|
||||
|
||||
@@ -4554,7 +4639,7 @@ class CmdFrame(
|
||||
return getScopeSlotValueAtAddr(addrSlot).toLong()
|
||||
}
|
||||
|
||||
fun setAddrInt(addrSlot: Int, value: Long) {
|
||||
suspend fun setAddrInt(addrSlot: Int, value: Long) {
|
||||
setScopeSlotValueAtAddr(addrSlot, ObjInt.of(value))
|
||||
}
|
||||
|
||||
@@ -4562,7 +4647,7 @@ class CmdFrame(
|
||||
return getScopeSlotValueAtAddr(addrSlot).toDouble()
|
||||
}
|
||||
|
||||
fun setAddrReal(addrSlot: Int, value: Double) {
|
||||
suspend fun setAddrReal(addrSlot: Int, value: Double) {
|
||||
setScopeSlotValueAtAddr(addrSlot, ObjReal.of(value))
|
||||
}
|
||||
|
||||
@@ -4570,7 +4655,7 @@ class CmdFrame(
|
||||
return getScopeSlotValueAtAddr(addrSlot).toBool()
|
||||
}
|
||||
|
||||
fun setAddrBool(addrSlot: Int, value: Boolean) {
|
||||
suspend fun setAddrBool(addrSlot: Int, value: Boolean) {
|
||||
setScopeSlotValueAtAddr(addrSlot, if (value) ObjTrue else ObjFalse)
|
||||
}
|
||||
|
||||
@@ -4580,21 +4665,42 @@ class CmdFrame(
|
||||
}
|
||||
val local = slot - fn.scopeSlotCount
|
||||
if (fn.localSlotCaptures.getOrNull(local) == true) {
|
||||
return localSlotToObj(local)
|
||||
return readLocalSlotValue(local)
|
||||
}
|
||||
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 -> {
|
||||
val obj = frame.getObj(local)
|
||||
when (obj) {
|
||||
is FrameSlotRef -> obj.read()
|
||||
is RecordSlotRef -> obj.read()
|
||||
else -> obj
|
||||
}
|
||||
SlotType.OBJ.code -> readLocalSlotValue(local)
|
||||
else -> readLocalSlotValue(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
|
||||
}
|
||||
else -> localSlotToObj(local)
|
||||
}
|
||||
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
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4750,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)) {
|
||||
SlotType.INT.code -> ObjInt.of(frame.getInt(localIndex))
|
||||
SlotType.REAL.code -> ObjReal.of(frame.getReal(localIndex))
|
||||
@@ -4759,7 +4866,9 @@ class CmdFrame(
|
||||
val obj = frame.getObj(localIndex)
|
||||
when (obj) {
|
||||
is FrameSlotRef -> obj.read()
|
||||
is RecordSlotRef -> obj.read()
|
||||
is RecordSlotRef -> obj.read(scope, localName)
|
||||
is ObjProperty -> resolvePropertyLikeLocal(localName, obj)
|
||||
ObjUnset -> resolveUnsetLocal(localName)
|
||||
else -> obj
|
||||
}
|
||||
}
|
||||
@@ -4767,21 +4876,43 @@ class CmdFrame(
|
||||
val obj = frame.getObj(localIndex)
|
||||
when (obj) {
|
||||
is FrameSlotRef -> obj.read()
|
||||
is RecordSlotRef -> obj.read()
|
||||
is RecordSlotRef -> obj.read(scope, localName)
|
||||
is ObjProperty -> resolvePropertyLikeLocal(localName, obj)
|
||||
ObjUnset -> resolveUnsetLocal(localName)
|
||||
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 {
|
||||
val target = scopeTarget(slot)
|
||||
val name = fn.scopeSlotNames[slot]
|
||||
val hadNamedBinding = name != null && hasResolvedNamedScopeBinding(target, name)
|
||||
val index = ensureScopeSlot(target, slot)
|
||||
val record = target.getSlotRecord(index)
|
||||
val direct = record.value
|
||||
if (direct is FrameSlotRef) return direct.read()
|
||||
if (direct is RecordSlotRef) return direct.read()
|
||||
val name = fn.scopeSlotNames[slot]
|
||||
if (name != null && record.memberName != null && record.memberName != name) {
|
||||
val resolved = target.get(name)
|
||||
if (resolved != null) {
|
||||
@@ -4802,9 +4933,15 @@ class CmdFrame(
|
||||
return direct
|
||||
}
|
||||
if (name == null) return record.value
|
||||
val resolved = target.get(name) ?: return record.value
|
||||
val resolved = target.get(name)
|
||||
if (resolved == null) {
|
||||
failMissingPreparedModuleBinding(slot, name, hadNamedBinding, record)
|
||||
return record.value
|
||||
}
|
||||
if (resolved.value !== ObjUnset) {
|
||||
target.updateSlotFor(name, resolved)
|
||||
} else {
|
||||
failMissingPreparedModuleBinding(slot, name, hadNamedBinding, resolved)
|
||||
}
|
||||
return resolved.value
|
||||
}
|
||||
@@ -4812,12 +4949,13 @@ class CmdFrame(
|
||||
private suspend fun getScopeSlotValueAtAddr(addrSlot: Int): Obj {
|
||||
val target = addrScopes[addrSlot] ?: error("Address slot $addrSlot is not resolved")
|
||||
val index = addrIndices[addrSlot]
|
||||
val slotId = addrScopeSlots[addrSlot]
|
||||
val name = fn.scopeSlotNames.getOrNull(slotId)
|
||||
val hadNamedBinding = name != null && hasResolvedNamedScopeBinding(target, name)
|
||||
val record = target.getSlotRecord(index)
|
||||
val direct = record.value
|
||||
if (direct is FrameSlotRef) return direct.read()
|
||||
if (direct is RecordSlotRef) return direct.read()
|
||||
val slotId = addrScopeSlots[addrSlot]
|
||||
val name = fn.scopeSlotNames.getOrNull(slotId)
|
||||
if (name != null && record.memberName != null && record.memberName != name) {
|
||||
val resolved = target.get(name)
|
||||
if (resolved != null) {
|
||||
@@ -4838,19 +4976,49 @@ class CmdFrame(
|
||||
return direct
|
||||
}
|
||||
if (name == null) return record.value
|
||||
val resolved = target.get(name) ?: return record.value
|
||||
val resolved = target.get(name)
|
||||
if (resolved == null) {
|
||||
failMissingPreparedModuleBinding(slotId, name, hadNamedBinding, record)
|
||||
return record.value
|
||||
}
|
||||
if (resolved.value !== ObjUnset) {
|
||||
target.updateSlotFor(name, resolved)
|
||||
} else {
|
||||
failMissingPreparedModuleBinding(slotId, name, hadNamedBinding, resolved)
|
||||
}
|
||||
return resolved.value
|
||||
}
|
||||
|
||||
private 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 index = addrIndices[addrSlot]
|
||||
val slotId = addrScopeSlots[addrSlot]
|
||||
val name = fn.scopeSlotNames.getOrNull(slotId)
|
||||
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
|
||||
}
|
||||
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 {
|
||||
val name = fn.scopeSlotNames[slot]
|
||||
if (name != null) {
|
||||
@@ -4875,6 +5043,45 @@ class CmdFrame(
|
||||
return index
|
||||
}
|
||||
|
||||
private fun hasNamedScopeBinding(target: Scope, name: String): Boolean {
|
||||
if (target.tryGetLocalRecord(target, name, target.currentClassCtx) != null) return true
|
||||
if (target.getSlotIndexOf(name) != null) return true
|
||||
if (target.get(name) != null) return true
|
||||
return false
|
||||
}
|
||||
|
||||
private fun hasResolvedNamedScopeBinding(target: Scope, name: String): Boolean =
|
||||
findNamedExistingRecord(target, name) != null
|
||||
|
||||
private fun findNamedExistingRecord(target: Scope, name: String): ObjRecord? {
|
||||
target.tryGetLocalRecord(target, name, target.currentClassCtx)?.let { return it }
|
||||
target.get(name)?.let { record ->
|
||||
if (record.value !== ObjUnset || record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property) {
|
||||
return record
|
||||
}
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
private fun failMissingPreparedModuleBinding(
|
||||
slot: Int,
|
||||
name: String,
|
||||
hadNamedBinding: Boolean,
|
||||
record: ObjRecord
|
||||
) {
|
||||
if (hadNamedBinding) return
|
||||
if (record.value !== ObjUnset) 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(
|
||||
pos,
|
||||
"module binding '$name' is not available in the execution scope; prepare the script imports/module bindings explicitly"
|
||||
)
|
||||
}
|
||||
|
||||
private fun ensureLocalMutable(localIndex: Int) {
|
||||
val name = fn.localSlotNames.getOrNull(localIndex) ?: return
|
||||
val isMutable = fn.localSlotMutables.getOrNull(localIndex) ?: true
|
||||
|
||||
@@ -31,12 +31,12 @@ internal suspend fun seedFrameLocalsFromScope(frame: CmdFrame, scope: Scope) {
|
||||
val record = scope.getLocalRecordDirect(name)
|
||||
?: scope.chainLookupIgnoreClosure(name, followClosure = true)
|
||||
?: 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)
|
||||
} else {
|
||||
record.value
|
||||
}
|
||||
if (value is net.sergeych.lyng.FrameSlotRef && value.refersTo(frame.frame, base + i)) {
|
||||
if (value is net.sergeych.lyng.FrameSlotRef && value.refersTo(frame.frame, i)) {
|
||||
continue
|
||||
}
|
||||
frame.setObjUnchecked(base + i, 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)
|
||||
fun math1(name: String) = mod.funDoc(
|
||||
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")))
|
||||
)
|
||||
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 = "ceil", doc = StdlibInlineDocIndex.topFunDoc("ceil") ?: "Round up 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.", 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. 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. Decimal is handled directly and stays Decimal.", params = listOf(ParamDoc("x", type("lyng.Number"))))
|
||||
|
||||
// Hyperbolic and inverse hyperbolic
|
||||
math1("sinh"); math1("cosh"); math1("tanh"); math1("asinh"); math1("acosh"); math1("atanh")
|
||||
|
||||
// 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 = "ln", doc = StdlibInlineDocIndex.topFunDoc("ln") ?: "Natural logarithm (base e).", 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 = "log2", doc = StdlibInlineDocIndex.topFunDoc("log2") ?: "Logarithm base 2.", 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). 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. 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. 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
|
||||
mod.funDoc(
|
||||
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")))
|
||||
)
|
||||
mod.funDoc(
|
||||
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")))
|
||||
)
|
||||
mod.funDoc(
|
||||
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")))
|
||||
)
|
||||
|
||||
@@ -540,7 +540,8 @@ private fun buildStdlibDocs(): List<MiniDecl> {
|
||||
|
||||
// Concurrency helpers
|
||||
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(
|
||||
name = "launch",
|
||||
|
||||
@@ -25,6 +25,8 @@ import kotlinx.serialization.json.JsonElement
|
||||
import kotlinx.serialization.json.JsonNull
|
||||
import kotlinx.serialization.serializer
|
||||
import net.sergeych.lyng.*
|
||||
import net.sergeych.lyng.InteropOperator
|
||||
import net.sergeych.lyng.OperatorInteropRegistry
|
||||
import net.sergeych.lyng.miniast.ParamDoc
|
||||
import net.sergeych.lyng.miniast.addFnDoc
|
||||
import net.sergeych.lyng.miniast.type
|
||||
@@ -175,7 +177,8 @@ open class Obj {
|
||||
if (other === this) return 0
|
||||
if (other === ObjNull || other === ObjUnset || other === ObjVoid) return 2
|
||||
return invokeInstanceMethod(scope, "compareTo", Arguments(other)) {
|
||||
scope.raiseNotImplemented("compareTo for ${objClass.className}")
|
||||
OperatorInteropRegistry.invokeCompare(scope, this, other)?.let { ObjInt.of(it.toLong()) }
|
||||
?: scope.raiseNotImplemented("compareTo for ${objClass.className}")
|
||||
}.cast<ObjInt>(scope).toInt()
|
||||
}
|
||||
|
||||
@@ -284,7 +287,8 @@ open class Obj {
|
||||
}
|
||||
if (self !== this) return self.plus(scope, otherValue)
|
||||
return invokeInstanceMethod(scope, "plus", Arguments(otherValue)) {
|
||||
scope.raiseNotImplemented("plus for ${objClass.className}")
|
||||
OperatorInteropRegistry.invokeBinary(scope, self, otherValue, InteropOperator.Plus)
|
||||
?: scope.raiseNotImplemented("plus for ${objClass.className}")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -301,7 +305,8 @@ open class Obj {
|
||||
}
|
||||
if (self !== this) return self.minus(scope, otherValue)
|
||||
return invokeInstanceMethod(scope, "minus", Arguments(otherValue)) {
|
||||
scope.raiseNotImplemented("minus for ${objClass.className}")
|
||||
OperatorInteropRegistry.invokeBinary(scope, self, otherValue, InteropOperator.Minus)
|
||||
?: scope.raiseNotImplemented("minus for ${objClass.className}")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -324,7 +329,8 @@ open class Obj {
|
||||
}
|
||||
if (self !== this) return self.mul(scope, otherValue)
|
||||
return invokeInstanceMethod(scope, "mul", Arguments(otherValue)) {
|
||||
scope.raiseNotImplemented("mul for ${objClass.className}")
|
||||
OperatorInteropRegistry.invokeBinary(scope, self, otherValue, InteropOperator.Mul)
|
||||
?: scope.raiseNotImplemented("mul for ${objClass.className}")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -341,7 +347,8 @@ open class Obj {
|
||||
}
|
||||
if (self !== this) return self.div(scope, otherValue)
|
||||
return invokeInstanceMethod(scope, "div", Arguments(otherValue)) {
|
||||
scope.raiseNotImplemented("div for ${objClass.className}")
|
||||
OperatorInteropRegistry.invokeBinary(scope, self, otherValue, InteropOperator.Div)
|
||||
?: scope.raiseNotImplemented("div for ${objClass.className}")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -358,7 +365,8 @@ open class Obj {
|
||||
}
|
||||
if (self !== this) return self.mod(scope, otherValue)
|
||||
return invokeInstanceMethod(scope, "mod", Arguments(otherValue)) {
|
||||
scope.raiseNotImplemented("mod for ${objClass.className}")
|
||||
OperatorInteropRegistry.invokeBinary(scope, self, otherValue, InteropOperator.Mod)
|
||||
?: scope.raiseNotImplemented("mod for ${objClass.className}")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -583,11 +591,14 @@ open class Obj {
|
||||
return obj.copy(value = res, type = ObjRecord.Type.Other)
|
||||
}
|
||||
val value = obj.value
|
||||
if (value is ObjProperty || obj.type == ObjRecord.Type.Property) {
|
||||
val prop = (value as? ObjProperty)
|
||||
?: scope.raiseError("Expected ObjProperty for property member $name, got ${value::class}")
|
||||
val res = prop.callGetter(scope, this, decl)
|
||||
return ObjRecord(res, obj.isMutable)
|
||||
if (value is ObjProperty) {
|
||||
val res = value.callGetter(scope, this, decl)
|
||||
return obj.copy(value = res, type = ObjRecord.Type.Other)
|
||||
}
|
||||
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
|
||||
// Check visibility for non-property members here if they weren't checked before
|
||||
@@ -1068,6 +1079,7 @@ interface Numeric {
|
||||
|
||||
fun Obj.toDouble(): Double =
|
||||
(this as? Numeric)?.doubleValue
|
||||
?: ObjDecimalSupport.toDoubleOrNull(this)
|
||||
?: (this as? ObjString)?.value?.toDouble()
|
||||
?: throw IllegalArgumentException("cannot convert to double $this")
|
||||
|
||||
|
||||
@@ -106,10 +106,20 @@ open class ObjClass(
|
||||
vararg parents: ObjClass,
|
||||
) : Obj() {
|
||||
|
||||
private fun declaringModulePackageName(scope: Scope?): String? {
|
||||
var current = scope
|
||||
while (current != null) {
|
||||
if (current is ModuleScope) return current.packageName
|
||||
current = current.parent
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
var isAnonymous: Boolean = false
|
||||
|
||||
var isAbstract: Boolean = false
|
||||
var isClosed: Boolean = false
|
||||
var logicalPackageNameOverride: String? = null
|
||||
|
||||
// Stable identity and simple structural version for PICs
|
||||
val classId: Long = ClassIdGen.nextId()
|
||||
@@ -169,6 +179,16 @@ open class ObjClass(
|
||||
*/
|
||||
var classScope: Scope? = null
|
||||
|
||||
/**
|
||||
* Stable logical identity for class matching across separately instantiated modules.
|
||||
* Uses declaring module package plus class name when available.
|
||||
*/
|
||||
val logicalPackageName: String?
|
||||
get() = logicalPackageNameOverride ?: declaringModulePackageName(classScope)
|
||||
|
||||
val logicalName: String
|
||||
get() = logicalPackageName?.let { "$it::$className" } ?: className
|
||||
|
||||
/** Direct parents in declaration order (kept deterministic). */
|
||||
val directParents: List<ObjClass> = parents.toList()
|
||||
|
||||
@@ -1160,8 +1180,11 @@ open class ObjClass(
|
||||
scope: Scope, name: String, args: Arguments,
|
||||
onNotFoundResult: (suspend () -> Obj?)?
|
||||
): Obj {
|
||||
getInstanceMemberOrNull(name)?.let { rec ->
|
||||
val decl = rec.declaringClass ?: findDeclaringClassOf(name) ?: this
|
||||
classScope?.objects?.get(name)?.let { rec ->
|
||||
val decl = rec.declaringClass ?: this
|
||||
if (!rec.visibility.isPublic) {
|
||||
return super.invokeInstanceMethod(scope, name, args, onNotFoundResult)
|
||||
}
|
||||
if (rec.type == ObjRecord.Type.Delegated) {
|
||||
val del = rec.delegate ?: scope.raiseError("Internal error: delegated member $name has no delegate")
|
||||
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}")
|
||||
}
|
||||
@@ -0,0 +1,434 @@
|
||||
/*
|
||||
* 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 com.ionspin.kotlin.bignum.decimal.DecimalMode
|
||||
import com.ionspin.kotlin.bignum.decimal.RoundingMode
|
||||
import com.ionspin.kotlin.bignum.integer.BigInteger
|
||||
import net.sergeych.lyng.*
|
||||
import net.sergeych.lyng.miniast.addPropertyDoc
|
||||
import net.sergeych.lyng.miniast.type
|
||||
import net.sergeych.lyng.requiredArg
|
||||
import com.ionspin.kotlin.bignum.decimal.BigDecimal as IonBigDecimal
|
||||
|
||||
object ObjDecimalSupport {
|
||||
private const val decimalContextVar = "__lyng_decimal_context__"
|
||||
// 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.
|
||||
private val realConversionMode = DecimalMode(17L, RoundingMode.ROUND_HALF_TO_EVEN)
|
||||
// Division needs an explicit stopping rule for non-terminating results. Use a
|
||||
// decimal128-like default context until Lyng exposes per-operation contexts.
|
||||
private val defaultDivisionMode = DecimalMode(34L, RoundingMode.ROUND_HALF_TO_EVEN)
|
||||
private val zero: IonBigDecimal = IonBigDecimal.ZERO
|
||||
private val decimalTypeDecl = TypeDecl.Simple("lyng.decimal.Decimal", false)
|
||||
private object BoundMarker
|
||||
private data class DecimalRuntimeContext(
|
||||
val precision: Long,
|
||||
val rounding: RoundingMode
|
||||
) : Obj()
|
||||
|
||||
suspend fun bindTo(module: ModuleScope) {
|
||||
val decimalClass = module.requireClass("Decimal")
|
||||
if (decimalClass.kotlinClassData === BoundMarker) return
|
||||
decimalClass.kotlinClassData = BoundMarker
|
||||
decimalClass.isAbstract = false
|
||||
val hooks = decimalClass.bridgeInitHooks ?: mutableListOf<suspend (ScopeFacade, ObjInstance) -> Unit>().also {
|
||||
decimalClass.bridgeInitHooks = it
|
||||
}
|
||||
hooks += { _, instance ->
|
||||
instance.kotlinInstanceData = zero
|
||||
}
|
||||
decimalClass.addFn("plus") {
|
||||
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") {
|
||||
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") {
|
||||
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") {
|
||||
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") {
|
||||
mixedRealDecimalArithmeticFallback(thisObj, args.firstAndOnly(), InteropOperator.Mod)
|
||||
?: newInstance(decimalClass, valueOf(thisObj).rem(coerceArg(requireScope(), args.firstAndOnly())))
|
||||
}
|
||||
decimalClass.addFn("compareTo") {
|
||||
mixedRealDecimalCompareFallback(thisObj, args.firstAndOnly())?.toObj()
|
||||
?: ObjInt.of(valueOf(thisObj).compareTo(coerceArg(requireScope(), args.firstAndOnly())).toLong())
|
||||
}
|
||||
decimalClass.addFn("negate") {
|
||||
newInstance(decimalClass, valueOf(thisObj).unaryMinus())
|
||||
}
|
||||
decimalClass.addFn("toInt") {
|
||||
ObjInt.of(valueOf(thisObj).longValue(false))
|
||||
}
|
||||
decimalClass.addFn("toReal") {
|
||||
ObjReal.of(valueOf(thisObj).doubleValue(false))
|
||||
}
|
||||
decimalClass.addFn("isInfinite") {
|
||||
ObjFalse
|
||||
}
|
||||
decimalClass.addFn("isNaN") {
|
||||
ObjFalse
|
||||
}
|
||||
decimalClass.addFn("toString") {
|
||||
ObjString(valueOf(thisObj).toStringExpanded())
|
||||
}
|
||||
decimalClass.addFn("toStringExpanded") {
|
||||
ObjString(valueOf(thisObj).toStringExpanded())
|
||||
}
|
||||
decimalClass.addClassFn("fromInt") {
|
||||
val value = requiredArg<ObjInt>(0).value
|
||||
newInstance(decimalClass, IonBigDecimal.fromLong(value))
|
||||
}
|
||||
decimalClass.addClassFn("fromReal") {
|
||||
val value = requiredArg<ObjReal>(0).value
|
||||
newInstanceFromFiniteReal(decimalClass, value)
|
||||
}
|
||||
decimalClass.addClassFn("fromString") {
|
||||
val value = requiredArg<ObjString>(0).value
|
||||
try {
|
||||
newInstance(decimalClass, IonBigDecimal.parseStringWithMode(value))
|
||||
} catch (e: Throwable) {
|
||||
requireScope().raiseIllegalArgument("invalid Decimal string: $value")
|
||||
}
|
||||
}
|
||||
module.addFn("withDecimalContext") {
|
||||
val (context, block) = when (args.list.size) {
|
||||
2 -> {
|
||||
val first = args[0]
|
||||
val block = args[1]
|
||||
if (first is ObjInt) {
|
||||
DecimalRuntimeContext(first.value, RoundingMode.ROUND_HALF_TO_EVEN) to block
|
||||
} else {
|
||||
normalizeContext(requireScope(), first) to block
|
||||
}
|
||||
}
|
||||
3 -> {
|
||||
val precision = requiredArg<ObjInt>(0).value
|
||||
val rounding = roundingModeFromObj(requireScope(), args[1])
|
||||
DecimalRuntimeContext(precision, rounding) to args[2]
|
||||
}
|
||||
else -> requireScope().raiseIllegalArgument("withDecimalContext expects (context, block), (precision, block), or (precision, rounding, block)")
|
||||
}
|
||||
val child = requireScope().createChildScope()
|
||||
child.addConst(decimalContextVar, context)
|
||||
block.callOn(child)
|
||||
}
|
||||
registerBuiltinConversions(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 {
|
||||
val instance = obj as? ObjInstance ?: error("Decimal receiver must be an object instance")
|
||||
return instance.kotlinInstanceData as? IonBigDecimal ?: zero
|
||||
}
|
||||
|
||||
private suspend fun currentDivisionMode(scope: Scope): DecimalMode {
|
||||
val context = findContextObject(scope) ?: return defaultDivisionMode
|
||||
return DecimalMode(context.precision, context.rounding)
|
||||
}
|
||||
|
||||
private fun divideWithContext(left: IonBigDecimal, right: IonBigDecimal, mode: DecimalMode): IonBigDecimal {
|
||||
if (mode.decimalPrecision <= 0L) {
|
||||
return stripMode(left.divide(right, mode))
|
||||
}
|
||||
val exactLeft = stripMode(left)
|
||||
val exactRight = stripMode(right)
|
||||
val guardMode = DecimalMode(mode.decimalPrecision + 2, RoundingMode.TOWARDS_ZERO)
|
||||
var guarded = stripMode(exactLeft.divide(exactRight, guardMode))
|
||||
val hasMoreTail = !stripMode(exactLeft - stripMode(guarded * exactRight)).isZero()
|
||||
if (hasMoreTail && isHalfRounding(mode.roundingMode) && looksLikeExactHalf(guarded, mode.decimalPrecision)) {
|
||||
guarded = nudgeLastDigitAwayFromZero(guarded)
|
||||
}
|
||||
return stripMode(guarded.roundSignificand(mode))
|
||||
}
|
||||
|
||||
private suspend fun ScopeFacade.newInstance(decimalClass: ObjClass, value: IonBigDecimal): ObjInstance {
|
||||
val instance = call(decimalClass) as? ObjInstance
|
||||
?: raiseIllegalState("Decimal() did not return an object instance")
|
||||
instance.kotlinInstanceData = value
|
||||
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) {
|
||||
is ObjInt -> IonBigDecimal.fromLong(value.value)
|
||||
is ObjReal -> {
|
||||
if (!value.value.isFinite()) {
|
||||
scope.raiseIllegalArgument("cannot convert non-finite Real to Decimal: ${value.value}")
|
||||
}
|
||||
IonBigDecimal.fromDouble(value.value, realConversionMode)
|
||||
}
|
||||
is ObjInstance -> {
|
||||
if (value.objClass.className != "Decimal") {
|
||||
scope.raiseIllegalArgument("expected Decimal-compatible value, got ${value.objClass.className}")
|
||||
}
|
||||
value.kotlinInstanceData as? IonBigDecimal ?: zero
|
||||
}
|
||||
else -> scope.raiseIllegalArgument("expected Decimal-compatible value, got ${value.objClass.className}")
|
||||
}
|
||||
|
||||
private suspend fun normalizeContext(scope: Scope, value: Obj): DecimalRuntimeContext {
|
||||
val instance = value as? ObjInstance
|
||||
?: scope.raiseClassCastError("withDecimalContext expects DecimalContext as the first argument")
|
||||
if (instance.objClass.className != "DecimalContext") {
|
||||
scope.raiseClassCastError("withDecimalContext expects DecimalContext as the first argument")
|
||||
}
|
||||
return decimalRuntimeContextFromInstance(scope, instance)
|
||||
}
|
||||
|
||||
private fun findContextObject(scope: Scope): DecimalRuntimeContext? {
|
||||
var current: Scope? = scope
|
||||
while (current != null) {
|
||||
val record = current.objects[decimalContextVar] ?: current.localBindings[decimalContextVar]
|
||||
val value = when (val raw = record?.value) {
|
||||
is FrameSlotRef -> raw.peekValue()
|
||||
is RecordSlotRef -> raw.peekValue()
|
||||
else -> raw
|
||||
}
|
||||
when (value) {
|
||||
is DecimalRuntimeContext -> return value
|
||||
}
|
||||
current = current.parent
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
private suspend fun decimalRuntimeContextFromInstance(scope: Scope, context: ObjInstance): DecimalRuntimeContext {
|
||||
val precision = context.readField(scope, "precision").value as? ObjInt
|
||||
?: scope.raiseClassCastError("DecimalContext.precision must be Int")
|
||||
if (precision.value <= 0L) {
|
||||
scope.raiseIllegalArgument("DecimalContext precision must be positive")
|
||||
}
|
||||
val rounding = roundingModeFromObj(scope, context.readField(scope, "rounding").value)
|
||||
return DecimalRuntimeContext(precision.value, rounding)
|
||||
}
|
||||
|
||||
private fun stripMode(value: IonBigDecimal): IonBigDecimal =
|
||||
IonBigDecimal.fromBigIntegerWithExponent(value.significand, value.exponent)
|
||||
|
||||
private fun isHalfRounding(mode: RoundingMode): Boolean = when (mode) {
|
||||
RoundingMode.ROUND_HALF_TO_EVEN,
|
||||
RoundingMode.ROUND_HALF_AWAY_FROM_ZERO,
|
||||
RoundingMode.ROUND_HALF_TOWARDS_ZERO,
|
||||
RoundingMode.ROUND_HALF_CEILING,
|
||||
RoundingMode.ROUND_HALF_FLOOR,
|
||||
RoundingMode.ROUND_HALF_TO_ODD -> true
|
||||
else -> false
|
||||
}
|
||||
|
||||
private fun looksLikeExactHalf(value: IonBigDecimal, targetPrecision: Long): Boolean {
|
||||
val digits = value.significand.abs().toString(10)
|
||||
if (digits.length <= targetPrecision) return false
|
||||
val discarded = digits.substring(targetPrecision.toInt())
|
||||
return discarded[0] == '5' && discarded.drop(1).all { it == '0' }
|
||||
}
|
||||
|
||||
private fun nudgeLastDigitAwayFromZero(value: IonBigDecimal): IonBigDecimal {
|
||||
val ulpExponent = value.exponent - value.precision + 1
|
||||
val ulp = IonBigDecimal.fromBigIntegerWithExponent(BigInteger.ONE, ulpExponent)
|
||||
return if (value.significand.signum() < 0) value - ulp else value + ulp
|
||||
}
|
||||
|
||||
private fun roundingModeFromObj(scope: Scope, value: Obj): RoundingMode {
|
||||
val entry = value as? ObjEnumEntry ?: scope.raiseClassCastError("DecimalContext.rounding must be DecimalRounding")
|
||||
return when (entry.name.value) {
|
||||
"HalfEven" -> RoundingMode.ROUND_HALF_TO_EVEN
|
||||
"HalfAwayFromZero" -> RoundingMode.ROUND_HALF_AWAY_FROM_ZERO
|
||||
"HalfTowardsZero" -> RoundingMode.ROUND_HALF_TOWARDS_ZERO
|
||||
"Ceiling" -> RoundingMode.CEILING
|
||||
"Floor" -> RoundingMode.FLOOR
|
||||
"AwayFromZero" -> RoundingMode.AWAY_FROM_ZERO
|
||||
"TowardsZero" -> RoundingMode.TOWARDS_ZERO
|
||||
else -> scope.raiseIllegalArgument("unsupported DecimalRounding: ${entry.name.value}")
|
||||
}
|
||||
}
|
||||
|
||||
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) {
|
||||
ObjInt.type.addPropertyDoc(
|
||||
name = "d",
|
||||
doc = "Convert this integer to a Decimal.",
|
||||
type = type("lyng.decimal.Decimal"),
|
||||
moduleName = "lyng.decimal",
|
||||
getter = { newInstance(decimalClass, IonBigDecimal.fromLong(thisAs<ObjInt>().value)) }
|
||||
)
|
||||
ObjInt.type.members["d"] = ObjInt.type.members.getValue("d").copy(typeDecl = decimalTypeDecl)
|
||||
ObjReal.type.addPropertyDoc(
|
||||
name = "d",
|
||||
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.Decimal"),
|
||||
moduleName = "lyng.decimal",
|
||||
getter = { newInstanceFromFiniteReal(decimalClass, thisAs<ObjReal>().value) }
|
||||
)
|
||||
ObjReal.type.members["d"] = ObjReal.type.members.getValue("d").copy(typeDecl = decimalTypeDecl)
|
||||
ObjString.type.addPropertyDoc(
|
||||
name = "d",
|
||||
doc = "Parse this string as a Decimal.",
|
||||
type = type("lyng.decimal.Decimal"),
|
||||
moduleName = "lyng.decimal",
|
||||
getter = {
|
||||
val value = thisAs<ObjString>().value
|
||||
try {
|
||||
newInstance(decimalClass, IonBigDecimal.parseStringWithMode(value))
|
||||
} catch (e: Throwable) {
|
||||
requireScope().raiseIllegalArgument("invalid Decimal string: $value")
|
||||
}
|
||||
}
|
||||
)
|
||||
ObjString.type.members["d"] = ObjString.type.members.getValue("d").copy(typeDecl = decimalTypeDecl)
|
||||
}
|
||||
|
||||
private fun registerInterop(decimalClass: ObjClass) {
|
||||
val decimalIdentity = ObjExternCallable.fromBridge {
|
||||
requiredArg<Obj>(0)
|
||||
}
|
||||
val numericOperators = listOf(
|
||||
InteropOperator.Plus.name,
|
||||
InteropOperator.Minus.name,
|
||||
InteropOperator.Mul.name,
|
||||
InteropOperator.Div.name,
|
||||
InteropOperator.Mod.name,
|
||||
InteropOperator.Compare.name,
|
||||
InteropOperator.Equals.name
|
||||
)
|
||||
OperatorInteropRegistry.register(
|
||||
leftClass = ObjInt.type,
|
||||
rightClass = decimalClass,
|
||||
commonClass = decimalClass,
|
||||
operatorNames = numericOperators,
|
||||
leftToCommon = ObjExternCallable.fromBridge {
|
||||
val value = requiredArg<ObjInt>(0).value
|
||||
newInstance(decimalClass, IonBigDecimal.fromLong(value))
|
||||
},
|
||||
rightToCommon = decimalIdentity
|
||||
)
|
||||
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
|
||||
|
||||
import kotlinx.coroutines.Deferred
|
||||
import kotlin.coroutines.cancellation.CancellationException as KotlinCancellationException
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.miniast.addFnDoc
|
||||
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")
|
||||
}
|
||||
}.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(
|
||||
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"),
|
||||
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(
|
||||
name = "isCompleted",
|
||||
doc = "Whether this deferred has completed (successfully or with an error).",
|
||||
@@ -66,4 +82,3 @@ open class ObjDeferred(val deferred: Deferred<Obj>): Obj() {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -129,6 +129,7 @@ open class ObjDynamic(var readCallback: Obj? = null, var writeCallback: Obj? = n
|
||||
}
|
||||
|
||||
val type = object : ObjClass("Delegate") {}.apply {
|
||||
logicalPackageNameOverride = "lyng.stdlib"
|
||||
addFn("getValue") { raiseError("Delegate.getValue is not implemented") }
|
||||
addFn("setValue") { raiseError("Delegate.setValue is not implemented") }
|
||||
addFn("invoke") { raiseError("Delegate.invoke is not implemented") }
|
||||
|
||||
@@ -278,6 +278,7 @@ open class ObjException(
|
||||
"AssertionFailedException",
|
||||
"ClassCastException",
|
||||
"IndexOutOfBoundsException",
|
||||
"CancellationException",
|
||||
"IllegalArgumentException",
|
||||
"IllegalStateException",
|
||||
"NoSuchElementException",
|
||||
@@ -311,6 +312,9 @@ class ObjClassCastException(scope: Scope, message: String) : ObjException("Class
|
||||
class ObjIndexOutOfBoundsException(scope: Scope, message: String = "index out of bounds") :
|
||||
ObjException("IndexOutOfBoundsException", scope, message)
|
||||
|
||||
class ObjCancellationException(scope: Scope, message: String = "cancelled") :
|
||||
ObjException("CancellationException", scope, message)
|
||||
|
||||
class ObjIllegalArgumentException(scope: Scope, message: String = "illegal argument") :
|
||||
ObjException("IllegalArgumentException", scope, message)
|
||||
|
||||
|
||||
@@ -364,6 +364,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
onNotFoundResult: (suspend () -> Obj?)?
|
||||
): Obj {
|
||||
val caller = scope.currentClassCtx
|
||||
val methodScope = scope.applyClosure(instanceScope)
|
||||
|
||||
// Fast path for public members when outside any class context
|
||||
if (caller == null) {
|
||||
@@ -373,7 +374,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
if (rec.type == ObjRecord.Type.Property) {
|
||||
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, decl)
|
||||
} else if (rec.type == ObjRecord.Type.Fun) {
|
||||
return rec.value.invoke(instanceScope, this, args, decl)
|
||||
return rec.value.invoke(methodScope, this, args, decl)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -384,7 +385,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
if (rec.type == ObjRecord.Type.Property) {
|
||||
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, decl)
|
||||
} else if (rec.type == ObjRecord.Type.Fun) {
|
||||
return rec.value.invoke(instanceScope, this, args, decl)
|
||||
return rec.value.invoke(methodScope, this, args, decl)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -394,7 +395,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
if (rec.type == ObjRecord.Type.Property) {
|
||||
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, decl)
|
||||
} else if (rec.type == ObjRecord.Type.Fun) {
|
||||
return rec.value.invoke(instanceScope, this, args, decl)
|
||||
return rec.value.invoke(methodScope, this, args, decl)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -409,7 +410,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
if (rec.type == ObjRecord.Type.Property) {
|
||||
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, c)
|
||||
} else if (rec.type == ObjRecord.Type.Fun) {
|
||||
return rec.value.invoke(instanceScope, this, args, c)
|
||||
return rec.value.invoke(methodScope, this, args, c)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -418,7 +419,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
if (rec.type == ObjRecord.Type.Property) {
|
||||
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, c)
|
||||
} else if (rec.type == ObjRecord.Type.Fun) {
|
||||
return rec.value.invoke(instanceScope, this, args, c)
|
||||
return rec.value.invoke(methodScope, this, args, c)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -427,7 +428,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
if (rec.type == ObjRecord.Type.Property) {
|
||||
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, c)
|
||||
} else if (rec.type == ObjRecord.Type.Fun) {
|
||||
return rec.value.invoke(instanceScope, this, args, c)
|
||||
return rec.value.invoke(methodScope, this, args, c)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -439,7 +440,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
val decl = rec.declaringClass ?: objClass.findDeclaringClassOf(name) ?: objClass
|
||||
val effectiveCaller = caller ?: if (scope.thisObj === this) objClass else null
|
||||
if (canAccessMember(rec.visibility, decl, effectiveCaller, name)) {
|
||||
return rec.value.invoke(instanceScope, this, args, decl)
|
||||
return rec.value.invoke(methodScope, this, args, decl)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -474,7 +475,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, decl)
|
||||
} else if (rec.type == ObjRecord.Type.Fun) {
|
||||
return rec.value.invoke(
|
||||
instanceScope,
|
||||
methodScope,
|
||||
this,
|
||||
args,
|
||||
decl
|
||||
@@ -586,8 +587,14 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
}
|
||||
|
||||
override suspend fun compareTo(scope: Scope, other: Obj): Int {
|
||||
if (other !is ObjInstance) return -1
|
||||
if (other.objClass != objClass) return -1
|
||||
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) {
|
||||
OperatorInteropRegistry.invokeCompare(scope, this, other)?.let { return it }
|
||||
return -1
|
||||
}
|
||||
for (f in comparableVars) {
|
||||
val a = f.value.value
|
||||
val b = other.instanceScope.objects[f.key]?.value ?: scope.raiseError("Internal error: field ${f.key} not found in other instance")
|
||||
|
||||
@@ -19,6 +19,8 @@ package net.sergeych.lyng.obj
|
||||
|
||||
import kotlinx.serialization.json.JsonElement
|
||||
import kotlinx.serialization.json.JsonPrimitive
|
||||
import net.sergeych.lyng.InteropOperator
|
||||
import net.sergeych.lyng.OperatorInteropRegistry
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.miniast.addFnDoc
|
||||
import net.sergeych.lynon.LynonDecoder
|
||||
@@ -54,10 +56,11 @@ class ObjInt(val value: Long, override val isConst: Boolean = false) : Obj(), Nu
|
||||
}
|
||||
|
||||
override suspend fun compareTo(scope: Scope, other: Obj): Int {
|
||||
if (other !is Numeric) return -2
|
||||
return if (other is ObjInt) {
|
||||
value.compareTo(other.value)
|
||||
} else {
|
||||
OperatorInteropRegistry.invokeCompare(scope, this, other)?.let { return it }
|
||||
if (other !is Numeric) return -2
|
||||
doubleValue.compareTo(other.doubleValue)
|
||||
}
|
||||
}
|
||||
@@ -70,28 +73,39 @@ class ObjInt(val value: Long, override val isConst: Boolean = false) : Obj(), Nu
|
||||
if (other is ObjInt)
|
||||
of(this.value + other.value)
|
||||
else
|
||||
OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Plus)
|
||||
?:
|
||||
ObjReal.of(this.doubleValue + other.toDouble())
|
||||
|
||||
override suspend fun minus(scope: Scope, other: Obj): Obj =
|
||||
if (other is ObjInt)
|
||||
of(this.value - other.value)
|
||||
else
|
||||
OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Minus)
|
||||
?:
|
||||
ObjReal.of(this.doubleValue - other.toDouble())
|
||||
|
||||
override suspend fun mul(scope: Scope, other: Obj): Obj =
|
||||
if (other is ObjInt) {
|
||||
of(this.value * other.value)
|
||||
} else ObjReal.of(this.value * other.toDouble())
|
||||
} else {
|
||||
OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Mul)
|
||||
?: ObjReal.of(this.value * other.toDouble())
|
||||
}
|
||||
|
||||
override suspend fun div(scope: Scope, other: Obj): Obj =
|
||||
if (other is ObjInt)
|
||||
of(this.value / other.value)
|
||||
else ObjReal.of(this.value / other.toDouble())
|
||||
else
|
||||
OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Div)
|
||||
?: ObjReal.of(this.value / other.toDouble())
|
||||
|
||||
override suspend fun mod(scope: Scope, other: Obj): Obj =
|
||||
if (other is ObjInt)
|
||||
of(this.value % other.value)
|
||||
else ObjReal.of(this.value.toDouble() % other.toDouble())
|
||||
else
|
||||
OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Mod)
|
||||
?: ObjReal.of(this.value.toDouble() % other.toDouble())
|
||||
|
||||
/**
|
||||
* Numbers are now immutable, so we can't do in-place assignment.
|
||||
|
||||
@@ -1,86 +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.obj
|
||||
|
||||
import net.sergeych.lyng.Arguments
|
||||
import net.sergeych.lyng.Pos
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.Statement
|
||||
import net.sergeych.lyng.Visibility
|
||||
import net.sergeych.lyng.executeBytecodeWithSeed
|
||||
|
||||
/**
|
||||
* Lazy delegate used by `val x by lazy { ... }`.
|
||||
*/
|
||||
class ObjLazyDelegate(
|
||||
private val builder: Obj,
|
||||
private val capturedScope: Scope,
|
||||
) : Obj() {
|
||||
override val objClass: ObjClass = type
|
||||
|
||||
private var calculated = false
|
||||
private var cachedValue: Obj = ObjVoid
|
||||
|
||||
override suspend fun invokeInstanceMethod(
|
||||
scope: Scope,
|
||||
name: String,
|
||||
args: Arguments,
|
||||
onNotFoundResult: (suspend () -> Obj?)?,
|
||||
): Obj {
|
||||
return when (name) {
|
||||
"getValue" -> {
|
||||
if (!calculated) {
|
||||
val callScope = capturedScope.createChildScope(capturedScope.pos, args = Arguments.EMPTY)
|
||||
cachedValue = if (builder is Statement) {
|
||||
executeBytecodeWithSeed(callScope, builder, "lazy delegate")
|
||||
} else {
|
||||
builder.callOn(callScope)
|
||||
}
|
||||
calculated = true
|
||||
}
|
||||
cachedValue
|
||||
}
|
||||
"setValue" -> scope.raiseIllegalAssignment("lazy delegate is read-only")
|
||||
else -> super.invokeInstanceMethod(scope, name, args, onNotFoundResult)
|
||||
}
|
||||
}
|
||||
|
||||
companion object {
|
||||
val type = ObjClass("LazyDelegate").apply {
|
||||
implementingNames.add("Delegate")
|
||||
createField(
|
||||
"getValue",
|
||||
ObjNull,
|
||||
isMutable = false,
|
||||
visibility = Visibility.Public,
|
||||
pos = Pos.builtIn,
|
||||
declaringClass = this,
|
||||
type = ObjRecord.Type.Fun
|
||||
)
|
||||
createField(
|
||||
"setValue",
|
||||
ObjNull,
|
||||
isMutable = false,
|
||||
visibility = Visibility.Public,
|
||||
pos = Pos.builtIn,
|
||||
declaringClass = this,
|
||||
type = ObjRecord.Type.Fun
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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())
|
||||
}
|
||||
@@ -19,6 +19,8 @@ package net.sergeych.lyng.obj
|
||||
|
||||
import kotlinx.serialization.json.JsonElement
|
||||
import kotlinx.serialization.json.JsonPrimitive
|
||||
import net.sergeych.lyng.InteropOperator
|
||||
import net.sergeych.lyng.OperatorInteropRegistry
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.miniast.addConstDoc
|
||||
import net.sergeych.lyng.miniast.addFnDoc
|
||||
@@ -40,6 +42,9 @@ data class ObjReal(val value: Double) : Obj(), Numeric {
|
||||
override fun byValueCopy(): Obj = this
|
||||
|
||||
override suspend fun compareTo(scope: Scope, other: Obj): Int {
|
||||
if (other is ObjReal) return value.compareTo(other.value)
|
||||
ObjDecimalSupport.mixedRealDecimalCompareFallback(this, other)?.let { return it }
|
||||
OperatorInteropRegistry.invokeCompare(scope, this, other)?.let { return it }
|
||||
if (other !is Numeric) return -2
|
||||
return value.compareTo(other.doubleValue)
|
||||
}
|
||||
@@ -63,19 +68,29 @@ data class ObjReal(val value: Double) : Obj(), Numeric {
|
||||
}
|
||||
|
||||
override suspend fun plus(scope: Scope, other: Obj): Obj =
|
||||
of(this.value + other.toDouble())
|
||||
ObjDecimalSupport.mixedRealDecimalArithmeticFallback(this, other, InteropOperator.Plus)
|
||||
?: OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Plus)
|
||||
?: of(this.value + other.toDouble())
|
||||
|
||||
override suspend fun minus(scope: Scope, other: Obj): Obj =
|
||||
of(this.value - other.toDouble())
|
||||
ObjDecimalSupport.mixedRealDecimalArithmeticFallback(this, other, InteropOperator.Minus)
|
||||
?: OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Minus)
|
||||
?: of(this.value - other.toDouble())
|
||||
|
||||
override suspend fun mul(scope: Scope, other: Obj): Obj =
|
||||
of(this.value * other.toDouble())
|
||||
ObjDecimalSupport.mixedRealDecimalArithmeticFallback(this, other, InteropOperator.Mul)
|
||||
?: OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Mul)
|
||||
?: of(this.value * other.toDouble())
|
||||
|
||||
override suspend fun div(scope: Scope, other: Obj): Obj =
|
||||
of(this.value / other.toDouble())
|
||||
ObjDecimalSupport.mixedRealDecimalArithmeticFallback(this, other, InteropOperator.Div)
|
||||
?: OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Div)
|
||||
?: of(this.value / other.toDouble())
|
||||
|
||||
override suspend fun mod(scope: Scope, other: Obj): Obj =
|
||||
of(this.value % other.toDouble())
|
||||
ObjDecimalSupport.mixedRealDecimalArithmeticFallback(this, other, InteropOperator.Mod)
|
||||
?: OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Mod)
|
||||
?: of(this.value % other.toDouble())
|
||||
|
||||
/**
|
||||
* Returns unboxed Double value
|
||||
@@ -140,6 +155,22 @@ data class ObjReal(val value: Double) : Obj(), Numeric {
|
||||
) {
|
||||
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())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,226 @@
|
||||
/*
|
||||
* 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.stdlib_included
|
||||
|
||||
@Suppress("Unused", "MemberVisibilityCanBePrivate")
|
||||
internal val decimalLyng = """
|
||||
package lyng.decimal
|
||||
|
||||
/**
|
||||
* Rounding policies used by [DecimalContext] and `withDecimalContext(...)`.
|
||||
*
|
||||
* These modes currently affect decimal division. They are designed to be explicit and readable in Lyng code.
|
||||
*
|
||||
* Common examples at precision `2`:
|
||||
* - `HalfEven`: `1.d / 8.d -> 0.12`
|
||||
* - `HalfAwayFromZero`: `1.d / 8.d -> 0.13`, `-1.d / 8.d -> -0.13`
|
||||
* - `HalfTowardsZero`: `1.d / 8.d -> 0.12`, `-1.d / 8.d -> -0.12`
|
||||
* - `Ceiling`: rounds toward positive infinity
|
||||
* - `Floor`: rounds toward negative infinity
|
||||
* - `AwayFromZero`: always increases magnitude when rounding is needed
|
||||
* - `TowardsZero`: always truncates toward zero
|
||||
*/
|
||||
enum DecimalRounding {
|
||||
HalfEven,
|
||||
HalfAwayFromZero,
|
||||
HalfTowardsZero,
|
||||
Ceiling,
|
||||
Floor,
|
||||
AwayFromZero,
|
||||
TowardsZero
|
||||
}
|
||||
|
||||
/**
|
||||
* Dynamic decimal arithmetic settings.
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* Default context:
|
||||
* - precision: `34` significant digits
|
||||
* - rounding: `DecimalRounding.HalfEven`
|
||||
*
|
||||
* Example:
|
||||
*
|
||||
* import lyng.decimal
|
||||
*
|
||||
* (1.d / 3.d).toStringExpanded()
|
||||
* >>> "0.3333333333333333333333333333333333"
|
||||
*
|
||||
* withDecimalContext(10) { (1.d / 3.d).toStringExpanded() }
|
||||
* >>> "0.3333333333"
|
||||
*
|
||||
* withDecimalContext(2, DecimalRounding.HalfAwayFromZero) { (1.d / 8.d).toStringExpanded() }
|
||||
* >>> "0.13"
|
||||
*/
|
||||
class DecimalContext(
|
||||
val precision: Int = 34,
|
||||
val rounding: DecimalRounding = DecimalRounding.HalfEven
|
||||
)
|
||||
|
||||
/**
|
||||
* Arbitrary-precision decimal value.
|
||||
*
|
||||
* `Decimal` is intended for decimal arithmetic where binary floating-point (`Real`) is the wrong tool:
|
||||
* - money
|
||||
* - human-entered decimal values
|
||||
* - ratios that should round in decimal, not in binary
|
||||
* - reproducible decimal formatting
|
||||
*
|
||||
* Creating values:
|
||||
*
|
||||
* - `1.d` converts `Int -> Decimal`
|
||||
* - `2.2.d` converts `Real -> Decimal` by preserving the current IEEE-754 value
|
||||
* - `"2.2".d` parses exact decimal text
|
||||
* - `Decimal.fromInt(...)`, `fromReal(...)`, `fromString(...)` are explicit factory forms
|
||||
*
|
||||
* Important distinction:
|
||||
*
|
||||
* - `2.2.d` means "take the current `Real` value and convert it"
|
||||
* - `"2.2".d` means "parse this exact decimal literal text"
|
||||
*
|
||||
* Therefore:
|
||||
*
|
||||
* import lyng.decimal
|
||||
*
|
||||
* 2.2.d.toStringExpanded()
|
||||
* >>> "2.2"
|
||||
*
|
||||
* (0.1 + 0.2).d.toStringExpanded()
|
||||
* >>> "0.30000000000000004"
|
||||
*
|
||||
* "0.3".d.toStringExpanded()
|
||||
* >>> "0.3"
|
||||
*
|
||||
* Mixed arithmetic:
|
||||
*
|
||||
* `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:
|
||||
*
|
||||
* import lyng.decimal
|
||||
*
|
||||
* 1.d + 2
|
||||
* >>> 3.d
|
||||
*
|
||||
* 1 + 2.d
|
||||
* >>> 3.d
|
||||
*
|
||||
* 0.5 + 1.d
|
||||
* >>> 1.5.d
|
||||
*
|
||||
* Precision and rounding:
|
||||
*
|
||||
* - division uses the default decimal context unless overridden
|
||||
* - use `withDecimalContext(...)` to apply a local precision/rounding policy
|
||||
*
|
||||
* Exact decimal literal style:
|
||||
*
|
||||
* If you want the source text itself to be the decimal value, use a string:
|
||||
*
|
||||
* "2.2".d
|
||||
*
|
||||
* That is the precise form. `2.2.d` remains a `Real -> Decimal` conversion by design.
|
||||
*/
|
||||
extern class Decimal() {
|
||||
/** Add another decimal-compatible value. */
|
||||
extern fun plus(other: Object): Decimal
|
||||
/** Subtract another decimal-compatible value. */
|
||||
extern fun minus(other: Object): Decimal
|
||||
/** Multiply by another decimal-compatible value. */
|
||||
extern fun mul(other: Object): Decimal
|
||||
/**
|
||||
* Divide by another decimal-compatible value.
|
||||
*
|
||||
* Division uses the current decimal context:
|
||||
* - by default: `34` significant digits, `HalfEven`
|
||||
* - inside `withDecimalContext(...)`: the context active for the current block
|
||||
*/
|
||||
extern fun div(other: Object): Decimal
|
||||
/** Remainder with another decimal-compatible value. */
|
||||
extern fun mod(other: Object): Decimal
|
||||
/** Compare with another decimal-compatible value. */
|
||||
extern fun compareTo(other: Object): Int
|
||||
/** Unary minus. */
|
||||
extern fun negate(): Decimal
|
||||
/** Convert to `Int` by dropping the fractional part according to backend conversion rules. */
|
||||
extern fun toInt(): Int
|
||||
/** Convert to `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.
|
||||
*
|
||||
* This is the preferred representation for user-facing decimal tests and diagnostics.
|
||||
*/
|
||||
extern fun toStringExpanded(): String
|
||||
|
||||
/** Create a decimal from an `Int`. */
|
||||
static extern fun fromInt(value: Int): Decimal
|
||||
/**
|
||||
* Create a decimal from a `Real`.
|
||||
*
|
||||
* This preserves the current IEEE-754 value using a round-trip-safe decimal conversion.
|
||||
* It does not try to recover the original source text.
|
||||
*/
|
||||
static extern fun fromReal(value: Real): Decimal
|
||||
/** Parse exact decimal text. */
|
||||
static extern fun fromString(value: String): Decimal
|
||||
}
|
||||
|
||||
/**
|
||||
* Run [block] with the provided decimal context.
|
||||
*
|
||||
* This is the main way to control decimal division precision and rounding locally without changing global behavior.
|
||||
*
|
||||
* Example:
|
||||
*
|
||||
* import lyng.decimal
|
||||
*
|
||||
* withDecimalContext(10) {
|
||||
* (1.d / 3.d).toStringExpanded()
|
||||
* }
|
||||
* >>> "0.3333333333"
|
||||
*
|
||||
* Contexts are dynamic and block-local. After the block finishes, the previous context is restored.
|
||||
*/
|
||||
extern fun withDecimalContext<T>(context: DecimalContext, block: ()->T): T
|
||||
|
||||
/**
|
||||
* Convenience overload for changing only precision.
|
||||
*
|
||||
* Equivalent to `withDecimalContext(DecimalContext(precision, DecimalRounding.HalfEven), block)`.
|
||||
*/
|
||||
extern fun withDecimalContext<T>(precision: Int, block: ()->T): T
|
||||
|
||||
/**
|
||||
* Convenience overload for changing precision and rounding explicitly.
|
||||
*
|
||||
* Example:
|
||||
*
|
||||
* import lyng.decimal
|
||||
*
|
||||
* withDecimalContext(2, DecimalRounding.HalfAwayFromZero) {
|
||||
* (1.d / 8.d).toStringExpanded()
|
||||
* }
|
||||
* >>> "0.13"
|
||||
*/
|
||||
extern fun withDecimalContext<T>(precision: Int, rounding: DecimalRounding, block: ()->T): T
|
||||
""".trimIndent()
|
||||
@@ -0,0 +1,191 @@
|
||||
/*
|
||||
* 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.stdlib_included
|
||||
|
||||
@Suppress("Unused", "MemberVisibilityCanBePrivate")
|
||||
internal val operatorsLyng = """
|
||||
package lyng.operators
|
||||
|
||||
/**
|
||||
* Binary operators that can be bridged between two different operand classes.
|
||||
*
|
||||
* Registering a pair means:
|
||||
* - the runtime can evaluate `left op right` when `left` has class `L` and `right` has class `R`
|
||||
* - both operands are first converted to a shared "common" class `C`
|
||||
* - the actual operator implementation is then looked up on `C`
|
||||
*
|
||||
* This is primarily useful when:
|
||||
* - you add a new numeric-like type in a library or in pure Lyng code
|
||||
* - your type already implements operators against itself
|
||||
* - you also want existing left-hand types such as `Int` or `Real` to work when your type is on the right
|
||||
*
|
||||
* Example:
|
||||
*
|
||||
* import lyng.operators
|
||||
*
|
||||
* class DecimalBox(val value: Int) {
|
||||
* fun plus(other: DecimalBox) = DecimalBox(value + other.value)
|
||||
* fun compareTo(other: DecimalBox) = value <=> other.value
|
||||
* }
|
||||
*
|
||||
* OperatorInterop.register(
|
||||
* Int,
|
||||
* DecimalBox,
|
||||
* DecimalBox,
|
||||
* [BinaryOperator.Plus, BinaryOperator.Compare, BinaryOperator.Equals],
|
||||
* { x: Int -> DecimalBox(x) },
|
||||
* { x: DecimalBox -> x }
|
||||
* )
|
||||
*
|
||||
* After registration:
|
||||
* - `1 + DecimalBox(2)` works
|
||||
* - `1 < DecimalBox(2)` works
|
||||
* - `2 == DecimalBox(2)` works
|
||||
*
|
||||
* But this registration does not replace methods on the original classes. It only teaches
|
||||
* Lyng how to bridge a mixed pair into a common class for the listed operators.
|
||||
*/
|
||||
enum BinaryOperator {
|
||||
/** `a + b` */
|
||||
Plus,
|
||||
/** `a - b` */
|
||||
Minus,
|
||||
/** `a * b` */
|
||||
Mul,
|
||||
/** `a / b` */
|
||||
Div,
|
||||
/** `a % b` */
|
||||
Mod,
|
||||
/**
|
||||
* Ordering comparisons.
|
||||
*
|
||||
* Registering `Compare` enables `<`, `<=`, `>`, `>=`, and the shuttle operator `<=>`
|
||||
* for the mixed operand pair.
|
||||
*/
|
||||
Compare,
|
||||
/**
|
||||
* Equality comparisons.
|
||||
*
|
||||
* Registering `Equals` enables `==` and `!=` for the mixed operand pair.
|
||||
*/
|
||||
Equals
|
||||
}
|
||||
|
||||
/**
|
||||
* Runtime registry for mixed-class binary operators.
|
||||
*
|
||||
* `register(L, R, C, ...)` defines how Lyng should evaluate expressions where:
|
||||
* - the left operand has class `L`
|
||||
* - the right operand has class `R`
|
||||
* - the actual operation should be executed as if both were values of class `C`
|
||||
*
|
||||
* 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:
|
||||
*
|
||||
* - `myDecimal + 1` usually already works if `Decimal.plus(Int)` exists
|
||||
* - `1 + myDecimal` needs registration because `Int` itself is not rewritten
|
||||
*
|
||||
* Typical pattern for a custom type:
|
||||
*
|
||||
* import lyng.operators
|
||||
*
|
||||
* class Rational(val num: Int, val den: Int) {
|
||||
* fun plus(other: Rational) = Rational(num * other.den + other.num * den, den * other.den)
|
||||
* fun minus(other: Rational) = Rational(num * other.den - other.num * den, den * other.den)
|
||||
* fun mul(other: Rational) = Rational(num * other.num, den * other.den)
|
||||
* fun div(other: Rational) = Rational(num * other.den, den * other.num)
|
||||
* fun compareTo(other: Rational) = (num * other.den) <=> (other.num * den)
|
||||
*
|
||||
* static fun fromInt(value: Int) = Rational(value, 1)
|
||||
* }
|
||||
*
|
||||
* OperatorInterop.register(
|
||||
* Int,
|
||||
* Rational,
|
||||
* Rational,
|
||||
* [
|
||||
* BinaryOperator.Plus,
|
||||
* BinaryOperator.Minus,
|
||||
* BinaryOperator.Mul,
|
||||
* BinaryOperator.Div,
|
||||
* BinaryOperator.Compare,
|
||||
* BinaryOperator.Equals
|
||||
* ],
|
||||
* { x: Int -> Rational.fromInt(x) },
|
||||
* { x: Rational -> x }
|
||||
* )
|
||||
*
|
||||
* Then:
|
||||
* - `1 + Rational(1, 2)` works
|
||||
* - `3 > Rational(5, 2)` works
|
||||
* - `2 == Rational(2, 1)` works
|
||||
*
|
||||
* Decimal uses the same mechanism internally to make `Int + Decimal` and `Real + Decimal`
|
||||
* work without changing the built-in `Int` or `Real` classes.
|
||||
*/
|
||||
extern object OperatorInterop {
|
||||
/**
|
||||
* Register a mixed-operand operator bridge.
|
||||
*
|
||||
* @param leftClass class of the original left operand
|
||||
* @param rightClass class of the original right operand
|
||||
* @param commonClass class that will actually execute the operator methods
|
||||
* @param operators operators supported for this mixed pair
|
||||
* @param leftToCommon conversion from `L` to `C`
|
||||
* @param rightToCommon conversion from `R` to `C`
|
||||
*
|
||||
* Requirements for `commonClass`:
|
||||
* - if you register `Plus`, `C` should implement `fun plus(other: C): C` or equivalent accepted result type
|
||||
* - if you register `Minus`, `C` should implement `fun minus(other: C): ...`
|
||||
* - if you register `Mul`, `C` should implement `fun mul(other: C): ...`
|
||||
* - if you register `Div`, `C` should implement `fun div(other: C): ...`
|
||||
* - if you register `Mod`, `C` should implement `fun mod(other: C): ...`
|
||||
* - if you register `Compare`, `C` should implement `fun compareTo(other: C): Int`
|
||||
*
|
||||
* `Equals` reuses comparison/equality semantics of the promoted values.
|
||||
*
|
||||
* Registration is usually done once at module initialization time:
|
||||
*
|
||||
* package my.rational
|
||||
* import lyng.operators
|
||||
*
|
||||
* class Rational(val num: Int, val den: Int) {
|
||||
* fun plus(other: Rational) = Rational(num * other.den + other.num * den, den * other.den)
|
||||
* fun compareTo(other: Rational) = (num * other.den) <=> (other.num * den)
|
||||
* static fun fromInt(value: Int) = Rational(value, 1)
|
||||
* }
|
||||
*
|
||||
* OperatorInterop.register(
|
||||
* Int,
|
||||
* Rational,
|
||||
* Rational,
|
||||
* [BinaryOperator.Plus, BinaryOperator.Compare, BinaryOperator.Equals],
|
||||
* { x: Int -> Rational.fromInt(x) },
|
||||
* { x: Rational -> x }
|
||||
* )
|
||||
*/
|
||||
extern fun register<L, R, C>(
|
||||
leftClass: Class<L>,
|
||||
rightClass: Class<R>,
|
||||
commonClass: Class<C>,
|
||||
operators: List<BinaryOperator>,
|
||||
leftToCommon: (L)->C,
|
||||
rightToCommon: (R)->C
|
||||
): Void
|
||||
}
|
||||
""".trimIndent()
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,88 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov
|
||||
*
|
||||
* 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.Compiler
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.Script
|
||||
import net.sergeych.lyng.ScriptError
|
||||
import net.sergeych.lyng.Source
|
||||
import net.sergeych.lyng.asFacade
|
||||
import net.sergeych.lyng.obj.ObjString
|
||||
import net.sergeych.lyng.obj.toInt
|
||||
import net.sergeych.lyng.pacman.ImportManager
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertContains
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertFailsWith
|
||||
|
||||
class CompilerVmReviewRegressionTest {
|
||||
|
||||
@Test
|
||||
fun missingModuleCaptureFailsFastInsteadOfBecomingUnset() = runTest {
|
||||
val manager = ImportManager()
|
||||
manager.addTextPackages(
|
||||
"""
|
||||
package foo
|
||||
|
||||
val answer = 42
|
||||
""".trimIndent()
|
||||
)
|
||||
val script = Compiler.compile(
|
||||
Source(
|
||||
"<missing-module-capture>",
|
||||
"""
|
||||
import foo
|
||||
fun make() = { answer }
|
||||
make()
|
||||
""".trimIndent()
|
||||
),
|
||||
manager
|
||||
)
|
||||
|
||||
val prepared = manager.newModule()
|
||||
script.importInto(prepared)
|
||||
val preparedLambda = script.execute(prepared)
|
||||
assertEquals(42, prepared.asFacade().call(preparedLambda).toInt())
|
||||
|
||||
val rawModule = manager.newModule()
|
||||
val hostScope = Scope(parent = rawModule, thisObj = ObjString("receiver"))
|
||||
|
||||
val lambda = script.execute(hostScope)
|
||||
val ex = assertFailsWith<ScriptError> {
|
||||
hostScope.asFacade().call(lambda)
|
||||
}
|
||||
assertContains(ex.errorMessage, "module binding 'answer'")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun subjectlessWhenReportsScriptError() = runTest {
|
||||
val ex = assertFailsWith<ScriptError> {
|
||||
Compiler.compile(
|
||||
Source(
|
||||
"<when-without-subject>",
|
||||
"""
|
||||
when {
|
||||
true -> 1
|
||||
}
|
||||
""".trimIndent()
|
||||
),
|
||||
Script.defaultImportManager
|
||||
)
|
||||
}
|
||||
assertContains(ex.errorMessage, "when without subject")
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
fun testMutex() = runTest {
|
||||
eval(
|
||||
|
||||
@@ -17,14 +17,15 @@
|
||||
|
||||
package net.sergeych.lyng
|
||||
|
||||
import com.ionspin.kotlin.bignum.decimal.BigDecimal
|
||||
import kotlinx.coroutines.test.runTest
|
||||
import net.sergeych.lyng.bridge.bindGlobalFun1
|
||||
import net.sergeych.lyng.bridge.bindGlobalFun3
|
||||
import net.sergeych.lyng.bridge.bindGlobalVar
|
||||
import net.sergeych.lyng.bridge.globalBinder
|
||||
import net.sergeych.lyng.bridge.*
|
||||
import net.sergeych.lyng.obj.ObjInstance
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import net.sergeych.lyng.obj.ObjReal
|
||||
import net.sergeych.lyng.obj.ObjString
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class GlobalBindingTest {
|
||||
@@ -136,4 +137,87 @@ class GlobalBindingTest {
|
||||
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())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,151 @@
|
||||
/*
|
||||
* 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 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.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.assertEquals
|
||||
|
||||
class GlobalPropertyCaptureRegressionTest {
|
||||
@Test
|
||||
fun externGlobalVarAssignmentInsideFunctionShouldCallBoundSetter() = runTest {
|
||||
val scope = Script.newScope()
|
||||
var x = 1.0
|
||||
|
||||
scope.eval(
|
||||
"""
|
||||
extern var X: Real
|
||||
|
||||
fun main() {
|
||||
X = X + 1.0
|
||||
}
|
||||
""".trimIndent()
|
||||
)
|
||||
|
||||
scope.globalBinder().bindGlobalVar(
|
||||
name = "X",
|
||||
get = { x },
|
||||
set = { x = it }
|
||||
)
|
||||
|
||||
scope.eval("main()")
|
||||
|
||||
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)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,87 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov
|
||||
*
|
||||
* 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.Compiler
|
||||
import net.sergeych.lyng.Script
|
||||
import net.sergeych.lyng.Source
|
||||
import net.sergeych.lyng.obj.toInt
|
||||
import net.sergeych.lyng.pacman.ImportManager
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertNotNull
|
||||
import kotlin.test.assertNull
|
||||
|
||||
class ScriptImportPreparationTest {
|
||||
|
||||
@Test
|
||||
fun scriptImportIntoExplicitlyPreparesExistingScope() = runTest {
|
||||
val manager = ImportManager()
|
||||
manager.addTextPackages(
|
||||
"""
|
||||
package foo
|
||||
|
||||
val answer = 42
|
||||
""".trimIndent()
|
||||
)
|
||||
val script = Compiler.compile(
|
||||
Source(
|
||||
"<prepare-scope>",
|
||||
"""
|
||||
import foo
|
||||
answer
|
||||
""".trimIndent()
|
||||
),
|
||||
manager
|
||||
)
|
||||
val scope = manager.newModule()
|
||||
|
||||
assertNull(scope["answer"])
|
||||
|
||||
script.importInto(scope)
|
||||
|
||||
val record = assertNotNull(scope["answer"])
|
||||
assertEquals(42, scope.resolve(record, "answer").toInt())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun scriptInstantiateModuleUsesSeedScopeImportProvider() = runTest {
|
||||
val manager = ImportManager()
|
||||
manager.addTextPackages(
|
||||
"""
|
||||
package foo
|
||||
|
||||
val answer = 42
|
||||
""".trimIndent()
|
||||
)
|
||||
val script = Compiler.compile(
|
||||
Source(
|
||||
"<instantiate-module>",
|
||||
"""
|
||||
import foo
|
||||
answer
|
||||
""".trimIndent()
|
||||
),
|
||||
manager
|
||||
)
|
||||
val seedScope = manager.newModule()
|
||||
|
||||
val module = script.instantiateModule(seedScope)
|
||||
|
||||
val record = assertNotNull(module["answer"])
|
||||
assertEquals(42, module.resolve(record, "answer").toInt())
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
fun testEmptySpreadList() = runTest {
|
||||
eval(
|
||||
@@ -5460,4 +5473,113 @@ class ScriptTest {
|
||||
""".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())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
/*
|
||||
* 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.FrameSlotRef
|
||||
import net.sergeych.lyng.Pos
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.bytecode.*
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertNull
|
||||
|
||||
class SeedLocalsRegressionTest {
|
||||
|
||||
@Test
|
||||
fun seedFrameLocalsSkipsSelfReferentialFrameSlotRef() = runTest {
|
||||
val fn = CmdFunction(
|
||||
name = "seed-self-ref",
|
||||
localCount = 1,
|
||||
addrCount = 0,
|
||||
returnLabels = emptySet(),
|
||||
scopeSlotCount = 1,
|
||||
scopeSlotIndices = intArrayOf(0),
|
||||
scopeSlotNames = arrayOf(null),
|
||||
scopeSlotIsModule = booleanArrayOf(false),
|
||||
scopeSlotRequiresPreparedBinding = booleanArrayOf(false),
|
||||
scopeSlotRefPos = arrayOfNulls(1),
|
||||
localSlotNames = arrayOf("x"),
|
||||
localSlotMutables = booleanArrayOf(true),
|
||||
localSlotDelegated = booleanArrayOf(false),
|
||||
localSlotCaptures = booleanArrayOf(false),
|
||||
constants = listOf(BytecodeConst.IntVal(0)),
|
||||
cmds = emptyArray(),
|
||||
posByIp = emptyArray()
|
||||
)
|
||||
val scope = Scope(null, pos = Pos.builtIn)
|
||||
val record = scope.addConst("x", net.sergeych.lyng.obj.ObjInt.of(1))
|
||||
val frame = CmdFrame(CmdVm(), fn, scope, emptyList())
|
||||
record.value = FrameSlotRef(frame.frame, 0)
|
||||
scope.updateSlotFor("x", record)
|
||||
|
||||
seedFrameLocalsFromScope(frame, scope)
|
||||
|
||||
assertNull(frame.frame.getRawObj(0))
|
||||
}
|
||||
}
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
@@ -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())
|
||||
}
|
||||
|
||||
}
|
||||
@@ -212,6 +212,96 @@ class DelegationTest {
|
||||
assertTrue(badThrown)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testPureLyngLazyPreservesReceiverAndClosure() = runTest {
|
||||
val scope = Script.newScope()
|
||||
scope.eval(
|
||||
"""
|
||||
val GLOBAL_NUMBERS = [1,2,3]
|
||||
|
||||
class PureLazy<T,ThisRefType=Object>(creatorParam: ThisRefType.()->T) : Delegate<T,ThisRefType> {
|
||||
private val creator: ThisRefType.()->T = creatorParam
|
||||
private var value = Unset
|
||||
|
||||
override fun bind(name: String, access, thisRef: ThisRefType): Object = this
|
||||
|
||||
override fun getValue(thisRef: ThisRefType, name: String): T {
|
||||
if (value == Unset)
|
||||
value = creator(thisRef)
|
||||
value as T
|
||||
}
|
||||
}
|
||||
|
||||
fun pureLazy<T,ThisRefType=Object>(creator: ThisRefType.()->T): Delegate<T,ThisRefType> = PureLazy(creator)
|
||||
|
||||
class A {
|
||||
val numbers = [1,2,3]
|
||||
val fromThis: List by pureLazy { this.numbers }
|
||||
val fromScope: List by pureLazy { GLOBAL_NUMBERS }
|
||||
}
|
||||
|
||||
class B {
|
||||
val a: A by pureLazy { A() }
|
||||
val test: List by pureLazy { (a as A).fromThis + [4] }
|
||||
}
|
||||
|
||||
assertEquals([1,2,3], A().fromThis)
|
||||
assertEquals([1,2,3], A().fromScope)
|
||||
assertEquals([1,2,3,4], B().test)
|
||||
""".trimIndent()
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testImportedPureLyngLazyPreservesReceiverAndClosure() = runTest {
|
||||
val scope = Script.newScope()
|
||||
scope.importManager.addTextPackages(
|
||||
"""
|
||||
package repro.lazy
|
||||
|
||||
import lyng.stdlib
|
||||
|
||||
class PureLazy<T,ThisRefType=Object>(creatorParam: ThisRefType.()->T) : Delegate<T,ThisRefType> {
|
||||
private val creator: ThisRefType.()->T = creatorParam
|
||||
private var value = Unset
|
||||
|
||||
override fun bind(name: String, access: DelegateAccess, thisRef: ThisRefType): Object {
|
||||
if (access != DelegateAccess.Val) throw "lazy delegate can only be used with 'val'"
|
||||
this
|
||||
}
|
||||
|
||||
override fun getValue(thisRef: ThisRefType, name: String): T {
|
||||
if (value == Unset)
|
||||
value = with(thisRef, creator)
|
||||
value as T
|
||||
}
|
||||
}
|
||||
""".trimIndent()
|
||||
)
|
||||
scope.eval(
|
||||
"""
|
||||
import repro.lazy
|
||||
|
||||
val GLOBAL_NUMBERS = [1,2,3]
|
||||
|
||||
class A {
|
||||
val numbers = [1,2,3]
|
||||
val fromThis: List by PureLazy { this.numbers }
|
||||
val fromScope: List by PureLazy { GLOBAL_NUMBERS }
|
||||
}
|
||||
|
||||
class B {
|
||||
val a: A by PureLazy { A() }
|
||||
val test: List by PureLazy { (a as A).fromThis + [4] }
|
||||
}
|
||||
|
||||
assertEquals([1,2,3], A().fromThis)
|
||||
assertEquals([1,2,3], A().fromScope)
|
||||
assertEquals([1,2,3,4], B().test)
|
||||
""".trimIndent()
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testLazyIsDelegate() = runTest {
|
||||
eval("""
|
||||
|
||||
@@ -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,111 @@
|
||||
/*
|
||||
* 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 OperatorInteropTest {
|
||||
@Test
|
||||
fun testPureLyngOperatorInteropRegistration() = runTest {
|
||||
val im = Script.defaultImportManager.copy()
|
||||
im.addPackage("test.decimalbox") { scope ->
|
||||
scope.eval(
|
||||
"""
|
||||
package test.decimalbox
|
||||
import lyng.operators
|
||||
|
||||
class DecimalBox(val value: Int) {
|
||||
fun plus(other: DecimalBox) = DecimalBox(value + other.value)
|
||||
fun minus(other: DecimalBox) = DecimalBox(value - other.value)
|
||||
fun mul(other: DecimalBox) = DecimalBox(value * other.value)
|
||||
fun div(other: DecimalBox) = DecimalBox(value / other.value)
|
||||
fun mod(other: DecimalBox) = DecimalBox(value % other.value)
|
||||
fun compareTo(other: DecimalBox) = value <=> other.value
|
||||
}
|
||||
|
||||
OperatorInterop.register(
|
||||
Int,
|
||||
DecimalBox,
|
||||
DecimalBox,
|
||||
[BinaryOperator.Plus, BinaryOperator.Minus, BinaryOperator.Mul, BinaryOperator.Div, BinaryOperator.Mod, BinaryOperator.Compare, BinaryOperator.Equals],
|
||||
{ x: Int -> DecimalBox(x) },
|
||||
{ x: DecimalBox -> x }
|
||||
)
|
||||
""".trimIndent()
|
||||
)
|
||||
}
|
||||
|
||||
val scope = im.newStdScope()
|
||||
scope.eval(
|
||||
"""
|
||||
import test.decimalbox
|
||||
|
||||
assertEquals(DecimalBox(3), 1 + DecimalBox(2))
|
||||
assertEquals(DecimalBox(1), 3 - DecimalBox(2))
|
||||
assertEquals(DecimalBox(8), 4 * DecimalBox(2))
|
||||
assertEquals(DecimalBox(4), 8 / DecimalBox(2))
|
||||
assertEquals(DecimalBox(1), 7 % DecimalBox(2))
|
||||
assert(1 < DecimalBox(2))
|
||||
assert(2 <= DecimalBox(2))
|
||||
assert(3 > DecimalBox(2))
|
||||
assert(2 >= DecimalBox(2))
|
||||
assert(2 == DecimalBox(2))
|
||||
assert(2 != DecimalBox(3))
|
||||
""".trimIndent()
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testRealInteropRegistrationUsesTopLevelModuleCode() = runTest {
|
||||
val im = Script.defaultImportManager.copy()
|
||||
im.addPackage("test.realbox") { scope ->
|
||||
scope.eval(
|
||||
"""
|
||||
package test.realbox
|
||||
import lyng.operators
|
||||
|
||||
class RealBox(val value: Real) {
|
||||
fun plus(other: RealBox) = RealBox(value + other.value)
|
||||
fun compareTo(other: RealBox) = value <=> other.value
|
||||
}
|
||||
|
||||
OperatorInterop.register(
|
||||
Real,
|
||||
RealBox,
|
||||
RealBox,
|
||||
[BinaryOperator.Plus, BinaryOperator.Compare, BinaryOperator.Equals],
|
||||
{ x: Real -> RealBox(x) },
|
||||
{ x: RealBox -> x }
|
||||
)
|
||||
""".trimIndent()
|
||||
)
|
||||
}
|
||||
|
||||
val scope = im.newStdScope()
|
||||
scope.eval(
|
||||
"""
|
||||
import test.realbox
|
||||
|
||||
assertEquals(RealBox(1.75), 0.5 + RealBox(1.25))
|
||||
assert(1.5 < RealBox(2.0))
|
||||
assert(2.0 == RealBox(2.0))
|
||||
""".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())
|
||||
}
|
||||
}
|
||||
+53
@@ -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
|
||||
}
|
||||
}
|
||||
+26
@@ -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)
|
||||
}
|
||||
@@ -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 }
|
||||
)
|
||||
@@ -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)
|
||||
@@ -1,11 +1,48 @@
|
||||
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
|
||||
|
||||
/* Built-in exception type. */
|
||||
extern class Exception
|
||||
extern class IllegalArgumentException
|
||||
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 Iterable<T> {
|
||||
fun iterator(): Iterator<T>
|
||||
@@ -77,9 +114,16 @@ extern class MapEntry<K,V> : Array<Object> {
|
||||
}
|
||||
|
||||
// Built-in math helpers (implemented in host runtime).
|
||||
extern fun abs(x: Object): Real
|
||||
extern fun ln(x: Object): Real
|
||||
extern fun pow(x: Object, y: Object): Real
|
||||
//
|
||||
// Decimal note:
|
||||
// - 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 clamp<T>(value: T, range: Range<T>): T
|
||||
|
||||
@@ -421,7 +465,6 @@ fun with<T,R>(self: T, block: T.()->R): R {
|
||||
Can only be used with 'val' properties.
|
||||
*/
|
||||
class lazy<T,ThisRefType=Object>(creatorParam: ThisRefType.()->T) : Delegate<T,ThisRefType> {
|
||||
private val creator: ThisRefType.()->T = creatorParam
|
||||
private var value = Unset
|
||||
|
||||
override fun bind(name: String, access: DelegateAccess, thisRef: ThisRefType): Object {
|
||||
@@ -431,7 +474,7 @@ class lazy<T,ThisRefType=Object>(creatorParam: ThisRefType.()->T) : Delegate<T,T
|
||||
|
||||
override fun getValue(thisRef: ThisRefType, name: String): T {
|
||||
if (value == Unset)
|
||||
value = with(thisRef,creator)
|
||||
value = with(thisRef, creatorParam)
|
||||
value as T
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -21,7 +21,7 @@
|
||||
|
||||
plugins {
|
||||
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"
|
||||
`maven-publish`
|
||||
}
|
||||
|
||||
@@ -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`
|
||||
@@ -0,0 +1,69 @@
|
||||
# :lynglib Compiler and VM Review (2026-03-26)
|
||||
|
||||
## Scope
|
||||
- Reviewed `:lynglib` compiler and bytecode VM paths, focusing on compile/execution correctness.
|
||||
- Read core files around `Compiler`, `Script`, `BytecodeCompiler`, `CmdRuntime`, `Scope`, `ModuleScope`, and capture/slot plumbing.
|
||||
- Ran `./gradlew :lynglib:jvmTest` on 2026-03-26: PASS.
|
||||
|
||||
## Findings
|
||||
|
||||
### 1. High: local seeding uses the wrong slot index when checking for self-referential `FrameSlotRef`
|
||||
- Status: fixed in worktree on 2026-03-26; covered by `SeedLocalsRegressionTest`.
|
||||
- File: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/bytecode/SeedLocals.kt:39`
|
||||
- The self-reference guard compares `FrameSlotRef` against `base + i`, but `FrameSlotRef` stores the underlying `BytecodeFrame` local slot index, not the VM absolute slot id.
|
||||
- The same slot is then written using `setObjUnchecked(base + i, value)` at `SeedLocals.kt:42`, which means a self-reference is not filtered out before being reinserted.
|
||||
- Impact: this can seed a local with a reference to itself, creating recursive `FrameSlotRef` chains. Reads then recurse through `BytecodeFrame.getObj()` / `FrameSlotRef.read()` instead of resolving to a value, which is a realistic path to stack overflow or non-terminating execution in bytecode-only helper execution (`executeBytecodeWithSeed`).
|
||||
- Why this looks real: the equivalent check in `CmdFrame.applyCaptureRecords()` uses the local index directly (`CmdRuntime.kt:3867`), and `Script.seedModuleLocals()` also compares with the local index, not `scopeSlotCount + i` (`Script.kt:109`).
|
||||
- Suggested fix: compare with `i`, not `base + i`, and add a regression test around `executeBytecodeWithSeed` seeding a scope that already contains a `FrameSlotRef` to the same local.
|
||||
|
||||
### 2. Design note: script-specific import/module preparation should stay explicit, not hidden in `execute(scope)`
|
||||
- Status: resolved by API addition, without changing `Script.execute(scope)` semantics.
|
||||
- File: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt:51-57`
|
||||
- `shouldSeedModule` is only true when `execScope` is a `ModuleScope` or `thisObj === ObjVoid`.
|
||||
- If a compiled script is executed against a non-module scope with a real receiver object, `seedModuleSlots()` is skipped entirely, so script imports and explicit module bindings are never installed into `moduleTarget`.
|
||||
- Original concern: top-level bytecode that expects imported names or module globals can see different behavior depending on whether the host prepared the target scope explicitly.
|
||||
- Resolution taken: do **not** change `Script.execute(scope)`, because in this codebase it is expected to run on exactly the provided scope and many embedding flows already rely on explicit scope setup via `Script.newScope()`, `Scope.eval(...)`, `addFn(...)`, `addConst(...)`, and direct import-manager configuration.
|
||||
- New explicit APIs added instead:
|
||||
- `Script.importInto(scope, seedScope = scope)`
|
||||
- `Script.instantiateModule(seedScope = null, pos = script.pos)`
|
||||
- This keeps existing execution behavior stable while giving hosts an opt-in way to apply a script's import/module bindings when they actually want that preparation step.
|
||||
- Coverage added: `ScriptImportPreparationTest`.
|
||||
|
||||
### 3. Medium: missing module captures are silently converted into fresh `Unset` slots
|
||||
- Status: fixed in worktree on 2026-03-27; covered by `CompilerVmReviewRegressionTest`.
|
||||
- File: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/bytecode/CmdRuntime.kt:3950-3970`
|
||||
- In `CmdFrame.buildCaptureRecords()`, the module-capture path first tries several lookups. If the requested `slotId` is missing but the capture has a `name`, it calls `target.applySlotPlan(mapOf(name to slotId))` and immediately returns `target.getSlotRecord(slotId)`.
|
||||
- That record is a newly created placeholder from `Scope.applySlotPlan()` (`Scope.kt:460-471`) and defaults to `ObjUnset`.
|
||||
- Impact: a compiler/runtime disagreement in capture resolution is masked as a normal capture of `Unset`, so the failure moves far away from closure creation and becomes data corruption or an unrelated later exception. This will be difficult to debug when it happens.
|
||||
- Resolution taken: the VM now refuses to treat synthetic placeholder slots as real module/captured bindings. Reads and capture construction fail with a source-positioned `ScriptError` when the execution scope was not prepared with the script's required module/import bindings.
|
||||
|
||||
### 4. Medium: subject-less `when { ... }` still crashes through a raw Kotlin `TODO`
|
||||
- Status: fixed in worktree on 2026-03-27; covered by `CompilerVmReviewRegressionTest`.
|
||||
- File: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Compiler.kt:6447-6449`
|
||||
- The unsupported branch uses `TODO("when without object is not yet implemented")`.
|
||||
- Current docs explicitly say subject-less `when` is not implemented, so the language limitation itself is documented. The problem is the failure mode: the compiler throws a raw Kotlin `NotImplementedError` instead of a normal `ScriptError` or a feature diagnostic.
|
||||
- Impact: IDE/embedding callers get an implementation exception rather than a source-positioned language error, which is especially bad across non-JVM targets and for editor tooling.
|
||||
- Resolution taken: the parser now throws a normal `ScriptError` at the `when` position with an explicit "when without subject is not implemented" message.
|
||||
|
||||
## Risks Worth Checking Next
|
||||
|
||||
### 5. Medium risk: module frame growth only retargets records stored in `objects`/`localBindings`
|
||||
- File: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/ModuleScope.kt:39-67`
|
||||
- When `ensureModuleFrame()` replaces the old `BytecodeFrame` with a larger one, it retargets `FrameSlotRef`s only in `objects` and `localBindings`.
|
||||
- Existing closures/capture records that already hold `FrameSlotRef(oldFrame, slot)` are not retargeted here.
|
||||
- Impact: if a module scope survives across recompilation/re-execution with a larger local frame, previously exported closures can keep reading stale values from the old frame instance.
|
||||
- Confidence is lower because this depends on module reuse across differing compiled shapes, but the reference-retargeting logic is clearly incomplete for that scenario.
|
||||
- Suggested check: add a regression covering module re-execution with increased local count and an exported closure captured before the resize.
|
||||
|
||||
## Test Status
|
||||
- `./gradlew :lynglib:jvmTest` passed during this review.
|
||||
- `./gradlew :lynglib:jvmTest --tests ScriptImportPreparationTest --tests SeedLocalsRegressionTest` passed after the fixes/API additions.
|
||||
- `./gradlew :lynglib:jvmTest --tests CompilerVmReviewRegressionTest --tests ScriptImportPreparationTest --tests SeedLocalsRegressionTest` passed after fixing findings 3 and 4.
|
||||
- Finding 1 is covered directly; finding 2 is covered by explicit preparation API tests.
|
||||
|
||||
## Suggested Fix Order
|
||||
1. Fix finding 1 first: it is a concrete slot-index bug with likely recursive failure modes. Done.
|
||||
2. Keep `Script.execute(scope)` semantics stable and use explicit preparation APIs where script-owned import/module setup is needed. Done.
|
||||
3. Tighten finding 3 next: fail fast on capture mismatches. Done.
|
||||
4. Replace the raw `TODO` in finding 4 so unsupported syntax produces normal diagnostics. Done.
|
||||
5. Decide whether finding 5 matters for current module-reload workflows; add a regression before changing behavior.
|
||||
@@ -0,0 +1,46 @@
|
||||
WASM использует стековую модель памяти. Lyng стеки не использует. В чем разница?
|
||||
|
||||
Стек это очень древняя структура, была придумана в 1955 (магазинная память Бауэра и Самельсона), и приняла современную форму в 1960, благодаря Барбаре Лисокв, вполседствии лауреата премии Тьюринга, которого, в свою очередь, за выдающийся вклад в развитие IT кастрировали, формально, за гомосексуализм, но в британии, где на трех джентльменов приходилось тогда, и приходится и теперь, четыре гомосексуала, все понимают, что это был просто предлог.
|
||||
|
||||
Стек был прекрасен в 60е годы, когда IBM планировала продавать по компьютеру в год в лучшем случае, а за идеи о микропроцессорах или ядрах можно было устроиться только пациентом психушки. Стек это заранее жестко выделенная область памяти, которая обычно вообще не используется, и по ней в одну сторону растет используемая область, которая хранит локальные переменные, адреса возврата и иногда состояние процессора.
|
||||
|
||||
Она крайне плохо подходит для многозадачности. Представь себе что у тебя есть wasm процесс, со своим стеком, и ему надо переключиться, остановив текущий поток исполнения (например, он ждет ответа от сети). Тогда тебе придется создать _новый стек_ — пока еще пустой, переключиться на него и исполнять там другую задачу. Сколько потоков - столько и стеков. И все они по большей части не используются — там просто запас памяти "на вырост", если исполнение потребует. А оценить заранее адекватно почти невозможно, дают с запасом.
|
||||
|
||||
Далее, васм использует фиксированную память выделенную на процесс. Ее тоже приходится брать "с запасом", так как если по ходу не хватит, процесс вылетит. И она тоже в изрядной части пустая. Ну и назасладочку, васм был задуман однозадачным, и все попытки туда хотя бы треды засунуть, получаются очень кривыми.
|
||||
|
||||
Линг использует фреймы и сопрограммы. Линг вообще треды не использует. Основная команда исполнения программы на линге - сопрограмма (coroutine), ей не нужен стейк, она им не пользуется. Вместо этого каждый вызов в линге, грубо говоря, это вызов сопрограммы. Для него формируется фрейм (не на стеке, а в динамической памяти!), которого гарантировано достаточно для исполнения собственно кода. Он заменяет собой "стековый фрейм", но его размер известен заранее, и его можно распределять и освобождать проще, как обычную динамическую память.
|
||||
|
||||
Далее, линг использует ту же динамическую память, что и его родительская платформа. Если он работает на Java, то использует память со сборкой мусора JVM, на Javascript - память машины JS, в нативных машинах - специальнй менеджер памяти со сборкой мусора, от Kotlin Native (довольно хороший и очень быстро развивающийся). В результате, запустить одновременно десять, или сто тысяч программ на лигне, которые будут исполняться конкурентно, вполне реально. Просто попытка запустить 10к васм-машин на v8 или другом движке скорее всего убьет систему, да и 10 тысяч тредов редко какой сервер приложению даст. Огромный перерасход ресурсов и тормоза.
|
||||
|
||||
Далее. Васм СТЕКОВАЯ машина со стековыми командами, он без стека вообще не может. Посмотрим как он считает примитивное выражение:
|
||||
|
||||
```wasm
|
||||
(module
|
||||
;; Экспортируем функцию, чтобы её можно было вызвать из JS
|
||||
(func (export "calc") (param $a i32) (param $b i32) (param $c i32) (param $d i32) (result i32)
|
||||
;; --- вычисление (a + b) / c * d ---
|
||||
local.get $a ;; помещаем a на стек
|
||||
local.get $b ;; помещаем b на стек
|
||||
i32.add ;; складываем: стек содержит (a+b)
|
||||
|
||||
local.get $c ;; помещаем c
|
||||
i32.div_s ;; знаковое деление: стек содержит ((a+b) / c)
|
||||
|
||||
local.get $d ;; помещаем d
|
||||
i32.mul ;; умножение: стек содержит (((a+b)/c) * d)
|
||||
|
||||
;; результат остаётся на стеке — это возвращаемое значение функции
|
||||
)
|
||||
)
|
||||
```
|
||||
|
||||
На ВМ Линга нет стека, он трехадресный универсальный ассемблер, если можно так сказать:
|
||||
|
||||
```
|
||||
add_int s1, s2 -> s5 // a + b -> s5
|
||||
div_int s5, s3 -> s5 // s5 -> s5 / c
|
||||
mul_int s5, s4 -> s5 // s5 -> s5 * d
|
||||
return s5
|
||||
```
|
||||
|
||||
Этот код крайне эффективно реализуется на любом реальном процессоре, и хорошо оптимизируется. Исполняется он без всякого стека.
|
||||
@@ -0,0 +1,21 @@
|
||||
Почему не WASM?
|
||||
|
||||
- wasm очень громоздкий и неудобный для разработки, он проектировался очень давно и с другими целями, так что сейчас его безуспешно пытаются "перезаточить" в современные области, но он поддается с трудом. Компилировать в wasm была бы задача по сложности превосходящая весь проект, а результат был бы уныл: мы и так имеем все достоинсва wasm, полезные для Lyng, но не имеем многих его недостатков.
|
||||
|
||||
Виртуалка lyng легкая, и доступна на всех платформах уже сейчас, а вот прикрутить скажем wasm машину к котлину на сервере, чтобы она работала как сопрограммы первого класса вместе с котлинскими, задача сейчас неразрешимая.
|
||||
|
||||
То есть, преимущества wasm что он доступен на многих платформах, для нас неважно - мы и так на тех же платформах имеем полную поддержку.
|
||||
|
||||
- Lyng VM изначально заточена на исполнение именно сопрограмм со сборкой мусора. Эти два ключевых механизма линга практически отсутствуют в wasm, их мучительно прикручивают как расширения, и они довольно слабо поддерживаются.
|
||||
|
||||
- LyngVM заточен на исполнение программ с гибридной ООП-ФП моделью, она хорошо поддерживает множественное наследование, делегацию, работу со сложными списками аргументов (ФП фичи, подстановки, деструктурирование), на васме это очень непросто написать, будет медленно и громоздко.
|
||||
|
||||
- одна из целей Lyng была получить быстрое безопасное и очень мощное скриптовое решение для вклучения в проекты на Java/Kotlin multiplatform. На wasm это в принципе невозможно - его включение это кошмар, он громоздкий. К тому же требует компиляции, а Lyng работает с JIT (исполняет прямо исходник, компилируя его на лету, как JS), и может использоваться как скрипт (wasm не может)
|
||||
|
||||
- типы данных которые мы используем в Lyng в WASM отсутстсвтуют, их бы пришлось добавлять
|
||||
|
||||
В результате если бы мы компилировали Lyng->WASM мы бы получили огромный и медленный код. Для которого потребовалась бы огромная wasm VM. Практического смысла в этом нет.
|
||||
|
||||
Если же ты рассматриваешь идею в единой платформе использовать разные языки, а wasm как промежуточный язых совместимости, то это собственно противоречит идее использовать общую кодовую базу и интерфейсы. Разные языки имеют несовпадающие, несовместимые интерфейсы вызовов, так что приходится писать руками биндинги, которые не добавляют скорости и добавляют ошибки, к тому же, разные языки предоставляют часто вообще несовместимые модели программирования (например прототипы в JS, множественное наследование С++ или Линга и кошмар на улице вязов от руста, в владением ссылками).
|
||||
|
||||
Платформ на васме полно, и там и ловить нечего, и неинтересно. Я же предлагаю вылезти в другой класс. Навеяно реальным опоытом переносов контрактов из старого золота в мольтпей, которое получается на удивление хорошо
|
||||
+22
-5
@@ -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");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -21,8 +21,8 @@
|
||||
|
||||
plugins {
|
||||
alias(libs.plugins.kotlinMultiplatform)
|
||||
// Compose compiler plugin for Kotlin 2.2.21 (matches version catalog)
|
||||
id("org.jetbrains.kotlin.plugin.compose") version "2.2.21"
|
||||
// Compose compiler plugin aligned with the project Kotlin version.
|
||||
id("org.jetbrains.kotlin.plugin.compose") version "2.3.20"
|
||||
// Compose Multiplatform plugin for convenient dependencies (compose.html.core, etc.)
|
||||
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
|
||||
tasks.configureEach {
|
||||
if (name.endsWith("ProcessResources")) {
|
||||
dependsOn(generateDocsIndex)
|
||||
dependsOn(generateDocsIndex, generateSiteVersion)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -143,4 +160,4 @@ tasks.named<Copy>("jsProcessResources").configure {
|
||||
}
|
||||
}
|
||||
|
||||
// Optional: configure toolchain if needed by the project; uses root Kotlin version from version catalog
|
||||
// Optional: configure toolchain if needed by the project; uses root Kotlin version from version catalog
|
||||
@@ -70,6 +70,7 @@ fun App() {
|
||||
|
||||
PageTemplate(title = when {
|
||||
isDocsRoute -> null
|
||||
route.startsWith("authors") -> "Authors"
|
||||
route.startsWith("reference") -> "Reference"
|
||||
route.isBlank() -> null
|
||||
else -> null
|
||||
@@ -118,6 +119,7 @@ fun App() {
|
||||
Div({ classes("col-12", if (isDocsRoute) "col-lg-9" else "col-lg-12") }) {
|
||||
when {
|
||||
route.isBlank() -> HomePage()
|
||||
route.startsWith("authors") -> AuthorsPage()
|
||||
route.startsWith("tryling") -> TryLyngPage(route)
|
||||
route.startsWith("search") -> SearchPage(route)
|
||||
!isDocsRoute -> ReferencePage()
|
||||
|
||||
@@ -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) }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -27,74 +27,85 @@ import org.jetbrains.compose.web.dom.*
|
||||
fun HomePage() {
|
||||
val samples = remember {
|
||||
listOf(
|
||||
"""
|
||||
// Decimal arithmetic with explicit local precision
|
||||
import lyng.decimal
|
||||
|
||||
val exact = "0.3".d
|
||||
val fromReal = (0.1 + 0.2).d
|
||||
|
||||
println(exact.toStringExpanded())
|
||||
println(fromReal.toStringExpanded())
|
||||
println(withDecimalContext(10) { (1.d / 3.d).toStringExpanded() })
|
||||
""".trimIndent(),
|
||||
"""
|
||||
// Mixed operators for your own type
|
||||
import lyng.operators
|
||||
|
||||
class Coins(val amount: Int) {
|
||||
fun plus(other: Coins) = Coins(amount + other.amount)
|
||||
fun compareTo(other: Coins) = amount <=> other.amount
|
||||
}
|
||||
|
||||
OperatorInterop.register(
|
||||
Int,
|
||||
Coins,
|
||||
Coins,
|
||||
[BinaryOperator.Plus, BinaryOperator.Compare, BinaryOperator.Equals],
|
||||
{ x: Int -> Coins(x) },
|
||||
{ x: Coins -> x }
|
||||
)
|
||||
|
||||
println(1 + Coins(2))
|
||||
println(3 > Coins(2))
|
||||
""".trimIndent(),
|
||||
"""
|
||||
// Non-local returns from closures
|
||||
fun findFirst<T>(list: Iterable<T>, predicate: (T)->Bool): T? {
|
||||
list.forEach {
|
||||
if (predicate(it)) return@findFirst it
|
||||
}
|
||||
null
|
||||
}
|
||||
|
||||
val found: Int? = findFirst([1, 5, 8, 12]) { it > 10 }
|
||||
println("Found: " + found)
|
||||
""".trimIndent(),
|
||||
"""
|
||||
// Implicit coroutines: parallelism without ceremony
|
||||
import lyng.time
|
||||
|
||||
val d1 = launch {
|
||||
delay(100.milliseconds)
|
||||
"Task A finished"
|
||||
}
|
||||
val d2 = launch {
|
||||
delay(50.milliseconds)
|
||||
"Task B finished"
|
||||
}
|
||||
|
||||
println(d1.await())
|
||||
println(d2.await())
|
||||
""".trimIndent(),
|
||||
"""
|
||||
// Everything is an expression
|
||||
val x: Int = 10
|
||||
val status: String = if (x > 0) "Positive" else "Zero or Negative"
|
||||
|
||||
// Even loops return values!
|
||||
val result = for (i in 1..5) {
|
||||
if (i == 3) break "Found 3!"
|
||||
} else "Not found"
|
||||
|
||||
println("Result: " + result)
|
||||
println(status)
|
||||
println(result)
|
||||
""".trimIndent(),
|
||||
"""
|
||||
// Functional power with generics and collections
|
||||
// Functional collections with strict static types
|
||||
val squares: List<Int> = (1..10)
|
||||
.filter { it % 2 == 0 }
|
||||
.map { it * it }
|
||||
|
||||
println("Even squares: " + squares)
|
||||
// Output: [4, 16, 36, 64, 100]
|
||||
""".trimIndent(),
|
||||
"""
|
||||
// Generics and type aliases
|
||||
type Num = Int | Real
|
||||
|
||||
class Box<out T: Num>(val value: T) {
|
||||
fun get(): T = value
|
||||
}
|
||||
|
||||
val intBox = Box(42)
|
||||
val realBox = Box(3.14)
|
||||
println("Boxes: " + intBox.get() + ", " + realBox.get())
|
||||
""".trimIndent(),
|
||||
"""
|
||||
// Strict compile-time types and symbol resolution
|
||||
fun greet(name: String, count: Int) {
|
||||
for (i in 1..count) {
|
||||
println("Hello, " + name + "!")
|
||||
}
|
||||
}
|
||||
|
||||
greet("Lyng", 3)
|
||||
// greet(10, "error") // This would be a compile-time error!
|
||||
""".trimIndent(),
|
||||
"""
|
||||
// Flexible map literals and shorthands
|
||||
val id = 101
|
||||
val name = "Lyng"
|
||||
val base = { id:, name: } // Shorthand for id: id, name: name
|
||||
|
||||
val full = { ...base, version: "1.5.0-SNAPSHOT", status: "active" }
|
||||
println(full)
|
||||
""".trimIndent(),
|
||||
"""
|
||||
// Modern null safety
|
||||
var config: Map<String, Int>? = null
|
||||
config ?= { timeout: 30 } // Assign only if null
|
||||
|
||||
val timeout = config?["timeout"] ?: 60
|
||||
println("Timeout is: " + timeout)
|
||||
""".trimIndent(),
|
||||
"""
|
||||
// Destructuring with splat operator
|
||||
val [first, middle..., last] = [1, 2, 3, 4, 5, 6]
|
||||
|
||||
println("First: " + first)
|
||||
println("Middle: " + middle)
|
||||
println("Last: " + last)
|
||||
""".trimIndent(),
|
||||
"""
|
||||
// Diamond-safe Multiple Inheritance (C3 MRO)
|
||||
@@ -123,18 +134,6 @@ fun HomePage() {
|
||||
println([10, 20, 30].second)
|
||||
""".trimIndent(),
|
||||
"""
|
||||
// Non-local returns from closures
|
||||
fun findFirst<T>(list: Iterable<T>, predicate: (T)->Bool): T? {
|
||||
list.forEach {
|
||||
if (predicate(it)) return@findFirst it
|
||||
}
|
||||
null
|
||||
}
|
||||
|
||||
val found: Int? = findFirst([1, 5, 8, 12]) { it > 10 }
|
||||
println("Found: " + found)
|
||||
""".trimIndent(),
|
||||
"""
|
||||
// Easy operator overloading
|
||||
class Vector(val x: Real, val y: Real) {
|
||||
fun plus(other: Vector): Vector = Vector(x + other.x, y + other.y)
|
||||
@@ -156,20 +155,13 @@ fun HomePage() {
|
||||
println("User name: " + u.name)
|
||||
""".trimIndent(),
|
||||
"""
|
||||
// Implicit coroutines: parallelism without ceremony
|
||||
import lyng.time
|
||||
// Flexible map literals and shorthands
|
||||
val id = 101
|
||||
val name = "Lyng"
|
||||
val base = { id:, name: }
|
||||
val full = { ...base, status: "active", tags: ["typed", "portable"] }
|
||||
|
||||
val d1 = launch {
|
||||
delay(100.milliseconds)
|
||||
"Task A finished"
|
||||
}
|
||||
val d2 = launch {
|
||||
delay(50.milliseconds)
|
||||
"Task B finished"
|
||||
}
|
||||
|
||||
println(d1.await())
|
||||
println(d2.await())
|
||||
println(full)
|
||||
""".trimIndent()
|
||||
)
|
||||
}
|
||||
@@ -195,6 +187,8 @@ fun HomePage() {
|
||||
Div({ classes("d-flex", "justify-content-center", "gap-2", "flex-wrap", "mb-4") }) {
|
||||
// Benefits pills
|
||||
listOf(
|
||||
"Decimal arithmetic",
|
||||
"Operator interop",
|
||||
"Strict static typing",
|
||||
"Generics & Type Aliases",
|
||||
"Implicit coroutines",
|
||||
@@ -233,6 +227,26 @@ fun HomePage() {
|
||||
}
|
||||
}
|
||||
|
||||
Div({ classes("row", "g-3", "mb-4") }) {
|
||||
listOf(
|
||||
Triple("New: Decimal", "Exact decimal values, local precision control, and mixed operators with Int and Real.", "#/docs/Decimal.md"),
|
||||
Triple("New: Operator Interop", "Teach Lyng how your custom types interact with built-ins on the left-hand side.", "#/docs/OperatorInterop.md"),
|
||||
Triple("What Changed", "Recent language, stdlib, and tooling improvements in one place.", "#/docs/whats_new.md")
|
||||
).forEach { (title, text, href) ->
|
||||
Div({ classes("col-12", "col-lg-4") }) {
|
||||
A(attrs = {
|
||||
classes("text-decoration-none")
|
||||
attr("href", href)
|
||||
}) {
|
||||
Div({ classes("h-100", "p-3", "border", "rounded-3", "bg-body-tertiary") }) {
|
||||
H3({ classes("h5", "mb-2", "text-body") }) { Text(title) }
|
||||
P({ classes("mb-0", "text-muted") }) { Text(text) }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Code sample slideshow
|
||||
Div({
|
||||
classes("markdown-body", "mt-0", "slide-container", "position-relative")
|
||||
@@ -273,8 +287,8 @@ fun HomePage() {
|
||||
}
|
||||
}
|
||||
|
||||
// Bottom section with a small Telegram button
|
||||
Div({ classes("text-center", "mt-5", "pb-4") }) {
|
||||
// Bottom section with Telegram and authors links
|
||||
Div({ classes("text-center", "mt-5", "d-flex", "justify-content-center", "gap-2", "flex-wrap") }) {
|
||||
A(attrs = {
|
||||
classes("btn", "btn-outline-primary", "btn-sm")
|
||||
attr("href", "https://t.me/lynglang")
|
||||
@@ -284,6 +298,13 @@ fun HomePage() {
|
||||
I({ classes("bi", "bi-telegram", "me-1") })
|
||||
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")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -332,16 +332,22 @@
|
||||
<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 -->
|
||||
<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>
|
||||
<body>
|
||||
<!-- Top-left version ribbon -->
|
||||
<div class="corner-ribbon bg-danger text-white">
|
||||
<span style="margin-left: -5em">
|
||||
v1.5.1
|
||||
<span id="lyng-version-ribbon" style="margin-left: -5em">
|
||||
</span>
|
||||
</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 -->
|
||||
<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>
|
||||
@@ -384,6 +390,7 @@
|
||||
<!-- 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="#/reference" data-route="reference">Reference</a></li>
|
||||
<li><a class="dropdown-item" href="#/authors" data-route="authors">Authors</a></li>
|
||||
<li>
|
||||
<hr class="dropdown-divider">
|
||||
</li>
|
||||
@@ -485,7 +492,7 @@
|
||||
var activeLink = null;
|
||||
if (!hash || hash === '#' || hash === '#/') {
|
||||
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
|
||||
activeLink = document.querySelector('#topbarNav .nav-link.dropdown-toggle');
|
||||
} else if (hash.startsWith('#/reference')) {
|
||||
|
||||
@@ -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)}")
|
||||
Reference in new issue
Block a user