Compare commits

...
43 Commits
Author SHA1 Message Date
sergeych 446c8d9a6e minor additions 2026-04-01 02:51:00 +03:00
sergeych c140567e0c made last changes KMP compliant 2026-04-01 02:51:00 +03:00
sergeych 311cf6ee44 Add Lyng deferred cancellation support 2026-03-31 22:50:46 +03:00
sergeych 3e338f3d53 Fix sqrt type inference and add regression coverage 2026-03-31 22:26:58 +03:00
sergeych c097464750 - fixed CLI -x mode
- fixed a wrong error message when global symbol is not found
2026-03-31 20:52:31 +03:00
sergeych 6e9333844e support for Decimal.isInfitite and isNan 2026-03-31 19:13:45 +03:00
sergeych a976702caf support for Real.isInfitite and isNan 2026-03-31 19:08:11 +03:00
sergeych 850efedb72 Handle non-finite real/decimal arithmetic 2026-03-31 16:57:18 +03:00
sergeych f845213332 fixed Decima/Complex interop bug 2026-03-30 09:25:29 +03:00
sergeych cdd48ec871 Improved instance method resolution logic and added test for Decimal overloading. 2026-03-30 08:53:07 +03:00
sergeych 286ec30422 Added Decimal support for complex number 2026-03-30 08:20:55 +03:00
sergeych 8a560f5417 fixed interpolation bug 2026-03-29 12:35:10 +03:00
sergeych 966b6a31ae extended inference of fun return type 2026-03-29 03:57:02 +03:00
sergeych c3c0a3292b fixed Decimal conversion bug 2026-03-29 03:35:53 +03:00
sergeych aa9565b40b fixed Decimal (and other such classes ) comparison 2026-03-29 01:29:48 +03:00
sergeych 05d7432b37 fixes on Decimals and bound kotlin classes 2026-03-29 01:20:20 +03:00
sergeych c7c333b71a fixed some issues with Decimals 2026-03-29 00:39:48 +03:00
sergeych e55d9c835a another snapshot release, configs for matrix operations 2026-03-28 23:28:28 +03:00
sergeych 83d8c8b71f Added Vectors and Matrics operations, slicing, docs. 2026-03-28 22:25:40 +03:00
sergeych a72991d1b7 debug stuff cleanup and simplify 2026-03-28 17:50:53 +03:00
sergeych cd007050a8 added complext number support 2026-03-28 17:44:43 +03:00
sergeych 418b1ae2b6 Fix captured bound global writes in nested bytecode blocks 2026-03-28 00:47:08 +03:00
sergeych b0fb65a036 Fix bound property captures and property slot resolution 2026-03-28 00:00:59 +03:00
sergeych 86e8b2e2bc site upgrades 2026-03-27 22:36:23 +03:00
sergeych a98fe51983 version bump 2026-03-27 21:49:53 +03:00
sergeych f8d36beae1 Merge branch 'bigdecimals' 2026-03-27 21:32:25 +03:00
sergeych 580256d520 Add decimal module and operator interop registry 2026-03-27 21:31:37 +03:00
sergeych 5ab074ba9e readme updated 2026-03-27 21:30:21 +03:00
sergeych 4269310beb Use canonical class identity for delegate checks 2026-03-27 19:19:38 +03:00
sergeych 7c059b4741 Fix lazy delegate type resolution across modules 2026-03-27 18:57:27 +03:00
sergeych 217787e17a Temporary lazy builtin baseline 2026-03-27 18:46:53 +03:00
sergeych 9ddc7dbee6 Fix remaining compiler and VM review findings 2026-03-27 16:10:49 +03:00
sergeych 24937c7cf5 some commercial proposals and clarifications 2026-03-27 15:53:12 +03:00
sergeych ecc4d8b9ed Add explicit script import prep APIs and VM regression tests 2026-03-27 15:51:17 +03:00
sergeych 3d8bfe8863 Add Lyng string interpolation with docs/tests and refresh changelog 2026-03-25 18:43:23 +03:00
sergeych 3b83439788 Rewrite Lyng common-platform proposal with validated samples 2026-03-25 17:53:57 +03:00
sergeych 0af0f31e48 site version fix 2026-03-22 03:11:34 +03:00
sergeych d17ad9ef0d 1.5.0 release; console stability fix; tetris sample rewritten to be RC-free 2026-03-22 03:11:08 +03:00
sergeych 222a653040 pause for tetris ;) 2026-03-21 01:44:28 +03:00
sergeych f24c7d2715 some docs tweaks 2026-03-20 23:44:18 +03:00
sergeych 2546a5327f better tetris ;) 2026-03-20 23:04:01 +03:00
sergeych 4df6612eca 1.5.0-RC2: build fixes 2026-03-19 22:45:08 +03:00
sergeych 2a79c718ba 1.5.0-RC2: improved lyngio.console, some polishing 2026-03-19 22:41:06 +03:00
106 changed files with 8862 additions and 1352 deletions

No files matched your search

+1
View File
@@ -27,3 +27,4 @@ debug.log
/compile_jvm_output.txt /compile_jvm_output.txt
/compile_metadata_output.txt /compile_metadata_output.txt
test_output*.txt test_output*.txt
/site/src/version-template/lyng-version.js
+8
View File
@@ -5,6 +5,14 @@
- For generics-heavy code generation, follow `docs/ai_language_reference.md` section `7.1 Generics Runtime Model and Bounds` and `7.2 Differences vs Java / Kotlin / Scala`. - For generics-heavy code generation, follow `docs/ai_language_reference.md` section `7.1 Generics Runtime Model and Bounds` and `7.2 Differences vs Java / Kotlin / Scala`.
- Use `docs/ai_stdlib_reference.md` for default runtime/module APIs and stdlib surface. - Use `docs/ai_stdlib_reference.md` for default runtime/module APIs and stdlib surface.
- Treat `LYNG_AI_SPEC.md` and older docs as secondary if they conflict with the two files above. - Treat `LYNG_AI_SPEC.md` and older docs as secondary if they conflict with the two files above.
- Prefer the shortest clear loop: use `for` for straightforward iteration/ranges; use `while` only when loop state/condition is irregular or changes in ways `for` cannot express cleanly.
- In Lyng code, slice strings with range indexing (`text[a..<b]`, `text[..<n]`, `text[n..]`) and avoid Java/Kotlin-style `substring(...)`.
## Lyng-First API Declarations
- Use `.lyng` declarations as the single source of truth for Lyng-facing API docs and types (especially module extern declarations).
- Prefer defining Lyng entities (enums/classes/type shapes) in `.lyng` files; only define them in Kotlin when there is Kotlin/platform-specific implementation detail that cannot be expressed in Lyng.
- Avoid hardcoding Lyng API documentation in Kotlin registrars when it can be declared in `.lyng`; Kotlin-side docs should be fallback/bridge only.
- For mixed pluggable modules (Lyng + Kotlin), embed module `.lyng` sources as generated Kotlin string literals, evaluate them into module scope during registration, then attach Kotlin implementations/bindings.
## Kotlin/Wasm generation guardrails ## Kotlin/Wasm generation guardrails
- Avoid creating suspend lambdas for compiler runtime statements. Prefer explicit `object : Statement()` with `override suspend fun execute(...)`. - Avoid creating suspend lambdas for compiler runtime statements. Prefer explicit `object : Statement()` with `override suspend fun execute(...)`.
+73 -141
View File
@@ -1,156 +1,88 @@
## 1.5.0-SNAPSHOT # Changelog
### Language Features This file tracks user-visible Lyng language/runtime/tooling changes.
- Added `return` statement with local and non-local exit support (`return@label`).
- Support for `abstract` classes, methods, and variables.
- Introduced `interface` as a synonym for `abstract class`.
- Multiple Inheritance (MI) completed and enabled by default (C3 MRO).
- Class properties with custom accessors (`get`, `set`).
- Restricted setter visibility (`private set`, `protected set`).
- Late-initialized `val` fields in classes with `Unset` protection.
- Named arguments (`name: value`) and named splats (`...Map`).
- Assign-if-null operator `?=`.
- Refined `protected` visibility rules and `closed` modifier.
- Transient attribute `@Transient` for serialization and equality.
- Unified Delegation model for `val`, `var`, and `fun`.
- Singleton objects (`object`) and object expressions.
### Standard Library History note:
- Added `with(self, block)` for scoped execution. - The project had periods where changelog maintenance lagged behind commits.
- Added `clamp()` function and extension. - Entries below are synchronized and curated for `1.5.x`.
- Improved `Exception` and `StackTraceEntry` reporting. - Earlier history may be incomplete and should be cross-checked with git tags/commits when needed.
### Tooling and IDE ## 1.5.1 (2026-03-25)
- **CLI**: Added `fmt` as a first-class subcommand for code formatting.
- **IDEA Plugin**: Lightweight autocompletion (experimental), improved docs, and Grazie integration.
- **Highlighters**: Updated TextMate bundle and website highlighters for new syntax.
### Detailed Changes: ### Language
- Added string interpolation:
- `"$name"` identifier interpolation.
- `"${expr}"` expression interpolation.
- Added literal-dollar forms in strings:
- `"\$"` -> `$`
- `"$$"` -> `$`
- `\\$x` is parsed as backslash + interpolation of `x`.
- Added per-file interpolation opt-out via leading directive comment:
- `// feature: interpolation: off`
- Language: Refined `protected` visibility rules ### Docs and AI references
- Ancestor classes can now access `protected` members of their descendants, provided the ancestor also defines or inherits a member with the same name (indicating an override of a member known to the ancestor). - Updated compiler-accurate AI language docs:
- This allows patterns where a base class calls a `protected` method that is implemented in a subclass. - interpolation syntax and escaping
- Fixed a regression where self-calls to unmangled members sometimes bypassed visibility checks incorrectly; these are now handled by the refined logic. - per-file feature switch behavior
- Refreshed tutorial examples and doctests to reflect new interpolation semantics.
- Added/reworked current proposal/reference materials for Lyng common-platform guidance.
- Language: Added `return` statement ### Compatibility notes
- `return [expression]` exits the innermost enclosing callable (function or lambda). - Interpolation is enabled by default for normal string literals.
- Supports non-local returns using `@label` syntax (e.g., `return@outer 42`). - Existing code that intentionally used `$name` as literal text should use `\$name`, `$$name`, or the file directive `// feature: interpolation: off`.
- Named functions automatically provide their name as a label for non-local returns.
- Labeled lambdas: lambdas can be explicitly labeled using `@label { ... }`.
- Restriction: `return` is forbidden in shorthand function definitions (e.g., `fun f(x) = return x` is a syntax error).
- Control Flow: `return` and `break` are now protected from being caught by user-defined `try-catch` blocks in Lyng.
- Documentation: New `docs/return_statement.md` and updated `tutorial.md`.
- Language: stdlib improvements ## 1.5.0 (2026-03-22)
- Added `with(self, block)` function to `root.lyng` which executes a block with `this` set to the provided object.
- Language: Abstract Classes and Interfaces
- Support for `abstract` modifier on classes, methods, and variables.
- Introduced `interface` as a synonym for `abstract class`, supporting full state (constructors, fields, `init` blocks) and implementation by parts via MI.
- New `closed` modifier (antonym to `open`) to prevent overriding class members.
- Refined `override` logic: mandatory keyword when re-declaring members that exist in the ancestor chain (MRO).
- MI Satisfaction: Abstract requirements are automatically satisfied by matching concrete members found later in the C3 MRO chain without requiring explicit proxy methods.
- Integration: Updated highlighters (lynglib, lyngweb, IDEA plugin), IDEA completion, and Grazie grammar checking.
- Documentation: Updated `docs/OOP.md` with sections on "Abstract Classes and Members", "Interfaces", and "Overriding and Virtual Dispatch".
- IDEA plugin: Improved natural language support and spellchecking
- Disabled the limited built-in English and Technical dictionaries.
- Enforced usage of the platform's standard Natural Languages (Grazie) and Spellchecker components.
- Integrated `SpellCheckerManager` for word suggestions and validation, respecting users' personal and project dictionaries.
- Added project-specific "learned words" support via `Lyng Formatter` settings and quick-fixes.
- Enhanced fallback spellchecker for technical terms and Lyng-specific vocabulary.
- Language: Class properties with accessors ### Major runtime/compiler direction
- Support for `val` (read-only) and `var` (read-write) properties in classes. - Completed migration to bytecode-first/bytecode-only execution paths.
- Syntax: `val name [ : Type ] get() { body }` or `var name [ : Type ] get() { body } set(value) { body }`. - Removed interpreter fallback behavior in core execution hot paths.
- Laconic Expression Shorthand: `val prop get() = expression` and `var prop get() = read set(v) = write`. - Continued frame-slot-first local/capture model improvements and related diagnostics.
- Properties are pure accessors and do **not** have automatic backing fields.
- Validation: `var` properties must have both accessors; `val` must have only a getter.
- Integration: Updated TextMate grammar and IntelliJ plugin (highlighting + keywords).
- Documentation: New "Properties" section in `docs/OOP.md`.
- Language: Restricted Setter Visibility ### Language features and semantics
- Support for `private set` and `protected set` modifiers on `var` fields and properties. - Added/finished `return` semantics including labeled non-local forms (`return@label`).
- Allows members to be publicly readable but only writable from within the declaring class or its subclasses. - Added abstract classes/members and `interface` support (as abstract-class-style construct).
- Enforcement at runtime: throws `AccessException` on unauthorized writes. - Completed and enabled multiple inheritance with C3 MRO by default.
- Supported only for declarations in class bodies (fields and properties). - Added class properties with accessors (`get`/`set`) and restricted setter visibility (`private set`, `protected set`).
- Documentation: New "Restricted Setter Visibility" section in `docs/OOP.md`. - Added late-initialized class `val` support with `Unset` protection rules.
- Added named arguments (`name: value`) and named splats (`...map`) with stricter validation.
- Added assign-if-null operator `?=`.
- Improved nullable/type-checking behavior (including `T is nullable` and related type checks).
- Added variadic function types (`...` in function type declarations) and tighter lambda type checks.
- Language: Late-initialized `val` fields in classes ### Type system and collections
- Support for declaring `val` without an immediate initializer in class bodies. - Added immutable collections hierarchy (`ImmutableList`, `ImmutableSet`, `ImmutableMap`).
- Compulsory initialization: every late-init `val` must be assigned at least once within the class body or an `init` block. - Improved generic runtime binding/checking for explicit type arguments and bounds.
- Write-once enforcement: assigning to a `val` is allowed only if its current value is `Unset`. - Added smarter type-aware collection ops (`+=`, `-=`) and stronger declared-member type checks.
- Access protection: reading a late-init `val` before it is assigned returns the `Unset` singleton; using `Unset` for most operations throws an `UnsetException`.
- Extension properties do not support late-init.
- Documentation: New "Late-initialized `val` fields" and "The `Unset` singleton" sections in `docs/OOP.md`.
- Docs: OOP improvements ### Extern/Kotlin bridge
- New page: `docs/scopes_and_closures.md` detailing `ClosureScope` resolution order, recursion‑safe helpers (`chainLookupIgnoreClosure`, `chainLookupWithMembers`, `baseGetIgnoreClosure`), cycle prevention, and capturing lexical environments for callbacks (`snapshotForClosure`). - Tightened extern declaration rules:
- Updated: `docs/advanced_topics.md` (link to the new page), `docs/parallelism.md` (closures in `launch`/`flow`), `docs/OOP.md` (visibility from closures with preserved `currentClassCtx`), `docs/exceptions_handling.md` (compatibility alias `SymbolNotFound`). - explicit extern members are required for extern class/object declarations.
- Tutorial: added quick link to Scopes and Closures. - Improved extern generic class behavior and diagnostics.
- Extended bridge APIs for binding global functions/variables and object/member interop scenarios.
- IDEA plugin: Lightweight autocompletion (experimental) ### Standard library and modules
- Global completion: local declarations, in‑scope parameters, imported modules, and stdlib symbols. - Added `lyng.observable` improvements (`ObservableList` hooks/events).
- Member completion: after a dot, suggests only members of the inferred receiver type (incl. chained calls like `Path(".." ).lines().` → `Iterator` methods). No global identifiers appear after a dot. - Added `Random` stdlib API used by updated samples.
- Inheritance-aware: direct class members first, then inherited (e.g., `List` includes `Collection`/`Iterable` methods). - Added/extended `lyngio.console` support and CLI integration for console interaction.
- Heuristics: handles literals (`"…"` → `String`, numbers → `Int/Real`, `[...]` → `List`, `{...}` → `Dict`) and static `Namespace.` members. - Migrated time APIs to `kotlin.time` (`Instant` migration and related docs/tests).
- Performance: capped results, early prefix filtering, per‑document MiniAst cache, cancellation checks.
- Toggle: Settings | Lyng Formatter → "Enable Lyng autocompletion (experimental)" (default ON).
- Stabilization: DEBUG completion/Quick Doc logs are OFF by default; behavior aligned between IDE and isolated engine tests.
- Language: Named arguments and named splats ### CLI, IDE, and docs/tooling
- New call-site syntax for named arguments using colon: `name: value`. - CLI:
- Positional arguments must come before named; positionals after a named argument inside parentheses are rejected. - added first-class `fmt` command
- Trailing-lambda interaction: if the last parameter is already assigned by name (or via a named splat), a trailing `{ ... }` block is illegal. - preserved direct script fast-path invocation
- Named splats: `...` can now expand a Map into named arguments. - improved command help/dispatch behavior
- Only string keys are allowed; non-string keys raise a clear error. - IntelliJ plugin:
- Duplicate assignment across named args and named splats is an error. - improved lightweight completion and documentation/inspection behavior
- Ellipsis (variadic) parameters remain positional-only and cannot be named. - continued highlighter and Grazie/spellchecking integration work
- Rationale: `=` is assignment and an expression in Lyng; `:` at call sites avoids ambiguity. Declarations keep `name: Type`; call-site casts continue to use `as` / `as?`. - Docs:
- Documentation updated: proposals and declaring-arguments sections now cover named args/splats and error cases. - substantial updates across tutorial/OOP/type/runtime references
- Tests added covering success cases and errors for named args/splats and trailing-lambda interactions. - expanded bytecode and advanced topics coverage
- Tooling: Highlighters and TextMate bundle updated for named args ## Migration checklist for 1.5.x
- Website/editor highlighter (lyngweb + site) works with `name: value` and `...Map("k" => v)`; added JS tests covering punctuation/operator spans for `:` and `...`.
- TextMate grammar updated to recognize named call arguments: `name: value` after `(` or `,` with `name` highlighted as `variable.parameter.named.lyng` and `:` as punctuation; excludes `::`.
- TextMate bundle version bumped to 0.0.3; README updated with details and guidance.
- Multiple Inheritance (MI) completed and enabled by default: - If you rely on literal `$...` strings:
- Active C3 Method Resolution Order (MRO) for deterministic, monotonic lookup across complex hierarchies and diamonds. - replace with `\$...` or `$$...`, or
- Qualified dispatch: - add `// feature: interpolation: off` at file top.
- `this@Type.member(...)` inside class bodies starts lookup at the specified ancestor. - Review any code relying on interpreter-era fallback behavior; 1.5.x assumes bytecode-first execution.
- Cast-based disambiguation: `(expr as Type).member(...)`, `(expr as? Type)?.member(...)` (works with existing safe-call `?.`). - For extern declarations, ensure members are explicitly declared where required.
- Field inheritance (`val`/`var`) under MI: - For named arguments/splats, verify call sites follow stricter ordering/duplication rules.
- Instance storage is disambiguated per declaring class; unqualified read/write resolves to the first match in MRO.
- Qualified read/write targets the chosen ancestor’s storage.
- Constructors and initialization:
- Direct bases are initialized left-to-right; each ancestor is initialized at most once (diamond-safe de-duplication).
- Header-specified constructor arguments are passed to direct bases.
- Visibility enforcement under MI:
- `private` visible only inside the declaring class body.
- `protected` visible inside the declaring class and its transitive subclasses. Additionally, ancestor classes can access protected members of their descendants if it's an override of a member known to the ancestor. Unrelated contexts cannot access it (qualification/casts do not bypass).
- Diagnostics improvements:
- Missing member/field messages include receiver class and linearization order; hints for `this@Type` or casts when helpful.
- Invalid `this@Type` reports that the qualifier is not an ancestor and shows the receiver lineage.
- `as`/`as?` cast errors include actual and target type names.
- Documentation updated (docs/OOP.md and tutorial quick-start) to reflect MI with active C3 MRO.
- CLI: Added `fmt` as a first-class Clikt subcommand.
- Default behavior: formats files to stdout (no in-place edits by default).
- Options:
- `--check`: check only; print files that would change; exit with code 2 if any changes are needed.
- `-i, --in-place`: write formatted result back to files.
- `--spacing`: apply spacing normalization.
- `--wrap`, `--wrapping`: enable line wrapping.
- Mutually exclusive: `--check` and `--in-place` together now produce an error and exit with code 1.
- Multi-file stdout prints headers `--- <path> ---` per file.
- `lyng --help` shows `fmt`; `lyng fmt --help` displays dedicated help.
- Fix: Property accessors (`get`, `set`, `private set`, `protected set`) are now correctly indented relative to the property declaration.
- Fix: Indentation now correctly carries over into blocks that start on extra‑indented lines (e.g., nested `if` statements or property accessor bodies).
- Fix: Formatting Markdown files no longer deletes content in `.lyng` code fences and works correctly with injected files (resolves clobbering, `StringIndexOutOfBoundsException`, and `nonempty text is not covered by block` errors).
- CLI: Preserved legacy script invocation fast-paths:
- `lyng script.lyng [args...]` executes the script directly.
- `lyng -- -file.lyng [args...]` executes a script whose name begins with `-`.
- CLI: Fixed a regression where the root help banner could print before subcommands.
- Root command no longer prints help when a subcommand (e.g., `fmt`) is invoked.
+9 -7
View File
@@ -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] site with integrated interpreter to give a try
- [x] kotlin part public API good docs, integration focused - [x] kotlin part public API good docs, integration focused
- [ ] type specifications - [x] type specifications
- [x] Textmate Bundle - [x] Textmate Bundle
- [x] IDEA plugin - [x] IDEA plugin
- [ ] source docs and maybe lyng.md to a standard - [x] source docs and maybe lyng.md to a standard
- [ ] metadata first class access from lyng
- [x] aggressive optimizations - [x] aggressive optimizations
- [ ] compile to JVM bytecode optimization
## After 1.5 "Ideal scripting" ## After 1.5 "Ideal scripting"
Estimated summer 2026 * __we are here now ;)__
- propose your feature! - propose your feature!
@@ -239,8 +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. @-links are for contacting authors on [project home](https://gitea.sergeych.net/SergeychWorks/lyng): this simplest s to open issue for the person you need to convey any information about this project.
__Sergey Chernov__ @sergeych: Initial idea and architecture, language concept, design, implementation. <img src="https://www.gravatar.com/avatar/7e3a56ff8a090fc9ffbd1909dea94904?s=32&d=identicon" alt="Sergey Chernov" width="32" height="32" style="vertical-align: middle; margin-right: 0.5em;" /> <b>Sergey Chernov</b> @sergeych, real.sergeych@gmail.com: Initial idea and architecture, language concept, design, implementation.
<br/>
<img src="https://www.gravatar.com/avatar/53a90bca30c85a81db8f0c0d8dea43a1?s=32&d=identicon" alt="Yulia Nezhinskaya" width="32" height="32" style="vertical-align: middle; margin-right: 0.5em;" /> <b>Yulia Nezhinskaya</b> @AlterEgoJuliaN, neleka88@gmail.com: System analysis, math and feature design.
__Yulia Nezhinskaya__ @AlterEgoJuliaN: System analysis, math and features design.
[parallelism]: docs/parallelism.md [parallelism]: docs/parallelism.md
-7
View File
@@ -1,7 +0,0 @@
# Bytecode Migration Plan (Archived)
Status: completed.
Historical reference:
- `notes/archive/bytecode_migration_plan.md` (full plan)
- `notes/archive/bytecode_migration_plan_completed.md` (summary)
+7
View File
@@ -4,6 +4,13 @@ It's an interface if the [Collection] that provides indexing access, like `array
Array therefore implements [Iterable] too. Well known implementations of `Array` are Array therefore implements [Iterable] too. Well known implementations of `Array` are
[List] and [ImmutableList]. [List] and [ImmutableList].
The language-level bracket syntax supports one or more selectors:
- `value[i]`
- `value[i, j]`
Concrete array-like types decide what selectors they accept. Built-in list-like arrays use one selector at a time; custom types such as matrices may interpret multiple selectors.
Array adds the following methods: Array adds the following methods:
## Binary search ## Binary search
+82
View File
@@ -0,0 +1,82 @@
# Complex Numbers (`lyng.complex`)
`lyng.complex` adds a pure-Lyng `Complex` type backed by `Real` components.
Import it when you want ordinary complex arithmetic:
```lyng
import lyng.complex
```
## Construction
Use any of these:
```lyng
import lyng.complex
val a = Complex(1.0, 2.0)
val b = complex(1.0, 2.0)
val c = 2.i
val d = 3.re
assertEquals(Complex(1.0, 2.0), 1 + 2.i)
```
Convenience extensions:
- `Int.re`, `Real.re`: embed a real value into the complex plane
- `Int.i`, `Real.i`: create a pure imaginary value
- `cis(angle)`: shorthand for `cos(angle) + i sin(angle)`
## Core Operations
`Complex` supports:
- `+`
- `-`
- `*`
- `/`
- unary `-`
- `conjugate`
- `magnitude`
- `phase`
Mixed arithmetic with `Int` and `Real` is enabled through `lyng.operators`, so both sides work naturally:
```lyng
import lyng.complex
assertEquals(Complex(1.0, 2.0), 1 + 2.i)
assertEquals(Complex(1.5, 2.0), 1.5 + 2.i)
assertEquals(Complex(2.0, 2.0), 2.i + 2)
```
Mixed equality with built-in numeric types is intentionally not promised yet. Keep equality checks in the `Complex` domain for now.
## Transcendental Functions
For now, use member-style calls:
```lyng
import lyng.complex
val z = 1 + π.i
val w = z.exp()
val s = z.sin()
val r = z.sqrt()
```
This is deliberate. Lyng already has built-in top-level real-valued functions such as `exp(x)` and `sin(x)`, and imported modules do not currently replace those root bindings. So plain `exp(z)` is not yet the right extension mechanism for complex math.
## Design Scope
This module intentionally uses `Complex` with `Real` parts, not `Complex<T>`.
Reasons:
- the existing math runtime is `Real`-centric
- the operator interop registry works with concrete runtime classes
- transcendental functions (`exp`, `sin`, `ln`, `sqrt`) are defined over the `Real` math backend here
If Lyng later gets a more general numeric-trait or callable-overload registry, a generic algebraic `Complex<T>` can be revisited on firmer ground.
+325
View File
@@ -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).
+7
View File
@@ -30,6 +30,13 @@ There is a shortcut for the last:
__Important__ negative indexes works wherever indexes are used, e.g. in insertion and removal methods too. __Important__ negative indexes works wherever indexes are used, e.g. in insertion and removal methods too.
The language also allows multi-selector indexing syntax such as `value[i, j]`, but `List` itself uses a single selector only:
- `list[index]` for one element
- `list[range]` for a slice copy
Multi-selector indexing is intended for custom indexers such as `Matrix`.
## Concatenation ## Concatenation
You can concatenate lists or iterable objects: You can concatenate lists or iterable objects:
+192
View File
@@ -0,0 +1,192 @@
# Matrix (`lyng.matrix`)
`lyng.matrix` adds dense immutable `Matrix` and `Vector` types for linear algebra.
Import it when you need matrix or vector arithmetic:
```lyng
import lyng.matrix
```
## Construction
Create vectors from a flat list and matrices from nested row lists:
```lyng
import lyng.matrix
val v: Vector = vector([1, 2, 3])
val m: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
assertEquals([1.0, 2.0, 3.0], v.toList())
assertEquals([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], m.toList())
```
Factory methods are also available:
```lyng
import lyng.matrix
val z: Vector = Vector.zeros(3)
val i: Matrix = Matrix.identity(3)
val m: Matrix = Matrix.zeros(2, 4)
```
All elements are standard double-precision numeric values internally.
## Shapes
Matrices may have any rectangular geometry:
```lyng
import lyng.matrix
val a: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
assertEquals(2, a.rows)
assertEquals(3, a.cols)
assertEquals([2, 3], a.shape)
assertEquals(false, a.isSquare)
```
Vectors expose:
- `size`
- `length` as an alias of `size`
## Matrix Operations
Supported matrix operations:
- `+` and `-` for element-wise matrix arithmetic
- `*` for matrix-matrix product
- `*` and `/` by a scalar
- `transpose()`
- `trace()`
- `rank()`
- `determinant()`
- `inverse()`
- `solve(rhs)` for `Vector` or `Matrix` right-hand sides
Example:
```lyng
import lyng.matrix
val a: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
val b: Matrix = matrix([[7, 8], [9, 10], [11, 12]])
val product: Matrix = a * b
assertEquals([[58.0, 64.0], [139.0, 154.0]], product.toList())
assertEquals([[1.0, 4.0], [2.0, 5.0], [3.0, 6.0]], a.transpose().toList())
```
Inverse and solve:
```lyng
import lyng.matrix
val a: Matrix = matrix([[4, 7], [2, 6]])
val rhs: Vector = vector([1, 0])
val inv: Matrix = a.inverse()
val x: Vector = a.solve(rhs)
assert(abs(a.determinant() - 10.0) < 1e-9)
assert(abs(inv.get(0, 0) - 0.6) < 1e-9)
assert(abs(x.get(0) - 0.6) < 1e-9)
```
## Vector Operations
Supported vector operations:
- `+` and `-`
- scalar `*` and `/`
- `dot(other)`
- `norm()`
- `normalize()`
- `cross(other)` for 3D vectors
- `outer(other)` producing a matrix
```lyng
import lyng.matrix
val a: Vector = vector([1, 2, 3])
val b: Vector = vector([2, 0, 0])
assertEquals(2.0, a.dot(b))
assertEquals([0.2672612419124244, 0.5345224838248488, 0.8017837257372732], a.normalize().toList())
```
## Indexing and Slicing
`Matrix` supports both method-style indexing and bracket syntax.
Scalar access:
```lyng
import lyng.matrix
val m: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
assertEquals(6.0, m.get(1, 2))
assertEquals(6.0, m[1, 2])
```
Bracket indexing accepts two selectors: `[row, col]`.
Each selector may be either:
- an `Int`
- a `Range`
Examples:
```lyng
import lyng.matrix
val m: Matrix = matrix([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
assertEquals(7.0, m[1, 2])
val columnSlice: Matrix = m[0..2, 2]
val topLeft: Matrix = m[0..1, 0..1]
val tail: Matrix = m[1.., 1..]
assertEquals([[3.0], [7.0], [11.0]], columnSlice.toList())
assertEquals([[1.0, 2.0], [5.0, 6.0]], topLeft.toList())
assertEquals([[6.0, 7.0, 8.0], [10.0, 11.0, 12.0]], tail.toList())
```
Shape rules:
- `m[Int, Int]` returns a `Real`
- `m[Range, Int]` returns an `Nx1` `Matrix`
- `m[Int, Range]` returns a `1xM` `Matrix`
- `m[Range, Range]` returns a submatrix
Open-ended ranges are supported:
- `m[..1, ..1]`
- `m[1.., 1..]`
- `m[.., 2]`
Stepped ranges are not supported in matrix slicing.
Slices currently return new matrices, not views.
## Rows and Columns
If you want plain lists instead of a sliced matrix:
```lyng
import lyng.matrix
val a: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
assertEquals([4.0, 5.0, 6.0], a.row(1))
assertEquals([2.0, 5.0], a.column(1))
```
## Backend Notes
The matrix module uses a platform-specific backend where available and falls back to pure Kotlin where needed.
The public Lyng API stays the same across platforms.
+18 -2
View File
@@ -1183,8 +1183,24 @@ collection's sugar won't work with it:
assertEquals("buzz", x[0]) assertEquals("buzz", x[0])
>>> void >>> void
If you want dynamic to function like an array, create a [feature Multiple selectors are packed into one list index object:
request](https://gitea.sergeych.net/SergeychWorks/lyng/issues).
val x = dynamic {
get {
if( it == [1, 2] ) "hit"
else null
}
}
assertEquals("hit", x[1, 2])
>>> void
So:
- `x[i]` passes `i`
- `x[i, j]` passes `[i, j]`
- `x[i, j, k]` passes `[i, j, k]`
This is the same rule used by Kotlin-backed `getAt` / `putAt` indexers in embedding.
# Theory # Theory
+309
View File
@@ -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).
+2
View File
@@ -19,6 +19,8 @@ you can use it's class to ensure type:
|-----------------|-------------------------------------------------------------|------| |-----------------|-------------------------------------------------------------|------|
| `.roundToInt()` | round to nearest int like round(x) | Int | | `.roundToInt()` | round to nearest int like round(x) | Int |
| `.toInt()` | convert integer part of real to `Int` dropping decimal part | Int | | `.toInt()` | convert integer part of real to `Int` dropping decimal part | Int |
| `.isInfinite()` | true when the value is `Infinity` or `-Infinity` | Bool |
| `.isNaN()` | true when the value is `NaN` | Bool |
| `.clamp(range)` | clamp value within range boundaries | Real | | `.clamp(range)` | clamp value within range boundaries | Real |
| | | | | | | |
| | | | | | | |
+14 -1
View File
@@ -17,6 +17,14 @@ Primary sources used: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/{Parser,T
- Supported escapes: `\n`, `\r`, `\t`, `\"`, `\\`, `\uXXXX` (4 hex digits). - Supported escapes: `\n`, `\r`, `\t`, `\"`, `\\`, `\uXXXX` (4 hex digits).
- Unicode escapes use exactly 4 hex digits (for example: `"\u0416"` -> `Ж`). - Unicode escapes use exactly 4 hex digits (for example: `"\u0416"` -> `Ж`).
- Unknown `\x` escapes in strings are preserved literally as two characters (`\` and `x`). - Unknown `\x` escapes in strings are preserved literally as two characters (`\` and `x`).
- String interpolation is supported:
- identifier form: `"$name"`
- expression form: `"${expr}"`
- escaped dollar: `"\$"` and `"$$"` both produce literal `$`.
- `\\$x` means backslash + interpolated `x`.
- Per-file opt-out is supported via leading comment directive:
- `// feature: interpolation: off`
- with this directive, `$...` stays literal text.
- Numbers: `Int` (`123`, `1_000`), `Real` (`1.2`, `1e3`), hex (`0xFF`). - Numbers: `Int` (`123`, `1_000`), `Real` (`1.2`, `1e3`), hex (`0xFF`).
- Char: `'a'`, escaped chars supported. - Char: `'a'`, escaped chars supported.
- Supported escapes: `\n`, `\r`, `\t`, `\'`, `\\`, `\uXXXX` (4 hex digits). - Supported escapes: `\n`, `\r`, `\t`, `\'`, `\\`, `\uXXXX` (4 hex digits).
@@ -74,11 +82,16 @@ Primary sources used: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/{Parser,T
- Type/containment: `is`, `!is`, `in`, `!in`, `as`, `as?`. - Type/containment: `is`, `!is`, `in`, `!in`, `as`, `as?`.
- Null-safe family: - Null-safe family:
- member access: `?.` - member access: `?.`
- safe index: `?[i]` - safe index: `?[i]`, `?[i, j]`
- safe invoke: `?(...)` - safe invoke: `?(...)`
- safe block invoke: `?{ ... }` - safe block invoke: `?{ ... }`
- elvis: `?:` and `??`. - elvis: `?:` and `??`.
- Increment/decrement: prefix and postfix `++`, `--`. - Increment/decrement: prefix and postfix `++`, `--`.
- Indexing syntax:
- single selector: `a[i]`
- multiple selectors: `a[i, j, k]`
- language-level indexing with multiple selectors is passed to `getAt`/`putAt` as one list-like index object, not as multiple method arguments.
- example: `m[0..2, 2]`.
## 5. Declarations ## 5. Declarations
- Variables: - Variables:
+15 -1
View File
@@ -14,7 +14,13 @@ Sources: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt`, `lynglib/s
- Assertions/tests: `assert`, `assertEquals`/`assertEqual`, `assertNotEquals`, `assertThrows`. - Assertions/tests: `assert`, `assertEquals`/`assertEqual`, `assertNotEquals`, `assertThrows`.
- Preconditions: `require`, `check`. - Preconditions: `require`, `check`.
- Async/concurrency: `launch`, `yield`, `flow`, `delay`. - Async/concurrency: `launch`, `yield`, `flow`, `delay`.
- `Deferred.cancel()` cancels an active task.
- `Deferred.await()` throws `CancellationException` if that task was cancelled.
- Math: `floor`, `ceil`, `round`, `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `sinh`, `cosh`, `tanh`, `asinh`, `acosh`, `atanh`, `exp`, `ln`, `log10`, `log2`, `pow`, `sqrt`, `abs`, `clamp`. - Math: `floor`, `ceil`, `round`, `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `sinh`, `cosh`, `tanh`, `asinh`, `acosh`, `atanh`, `exp`, `ln`, `log10`, `log2`, `pow`, `sqrt`, `abs`, `clamp`.
- These helpers also accept `lyng.decimal.Decimal`.
- Exact Decimal path today: `abs`, `floor`, `ceil`, `round`, and `pow` with integral exponent.
- Temporary Decimal path for the rest: convert `Decimal -> Real`, compute, then convert back to `Decimal`.
- Treat that bridge as temporary; prefer native Decimal implementations when they become available.
## 3. Core Global Constants/Types ## 3. Core Global Constants/Types
- Values: `Unset`, `π`. - Values: `Unset`, `π`.
@@ -22,13 +28,14 @@ Sources: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt`, `lynglib/s
- Collections/types: `Iterable`, `Iterator`, `Collection`, `Array`, `List`, `ImmutableList`, `Set`, `ImmutableSet`, `Map`, `ImmutableMap`, `MapEntry`, `Range`, `RingBuffer`. - Collections/types: `Iterable`, `Iterator`, `Collection`, `Array`, `List`, `ImmutableList`, `Set`, `ImmutableSet`, `Map`, `ImmutableMap`, `MapEntry`, `Range`, `RingBuffer`.
- Random: singleton `Random` and class `SeededRandom`. - Random: singleton `Random` and class `SeededRandom`.
- Async types: `Deferred`, `CompletableDeferred`, `Mutex`, `Flow`, `FlowBuilder`. - Async types: `Deferred`, `CompletableDeferred`, `Mutex`, `Flow`, `FlowBuilder`.
- Async exception: `CancellationException`.
- Delegation types: `Delegate`, `DelegateContext`. - Delegation types: `Delegate`, `DelegateContext`.
- Regex types: `Regex`, `RegexMatch`. - Regex types: `Regex`, `RegexMatch`.
- Also present: `Math.PI` namespace constant. - Also present: `Math.PI` namespace constant.
## 4. `lyng.stdlib` Module Surface (from `root.lyng`) ## 4. `lyng.stdlib` Module Surface (from `root.lyng`)
### 4.1 Extern class declarations ### 4.1 Extern class declarations
- Exceptions/delegation base: `Exception`, `IllegalArgumentException`, `NotImplementedException`, `Delegate`. - Exceptions/delegation base: `Exception`, `CancellationException`, `IllegalArgumentException`, `NotImplementedException`, `Delegate`.
- Collections and iterables: `Iterable<T>`, `Iterator<T>`, `Collection<T>`, `Array<T>`, `List<T>`, `ImmutableList<T>`, `Set<T>`, `ImmutableSet<T>`, `Map<K,V>`, `ImmutableMap<K,V>`, `MapEntry<K,V>`, `RingBuffer<T>`. - Collections and iterables: `Iterable<T>`, `Iterator<T>`, `Collection<T>`, `Array<T>`, `List<T>`, `ImmutableList<T>`, `Set<T>`, `ImmutableSet<T>`, `Map<K,V>`, `ImmutableMap<K,V>`, `MapEntry<K,V>`, `RingBuffer<T>`.
- Host iterator bridge: `KotlinIterator<T>`. - Host iterator bridge: `KotlinIterator<T>`.
- Random APIs: `extern object Random`, `extern class SeededRandom`. - Random APIs: `extern object Random`, `extern class SeededRandom`.
@@ -56,6 +63,13 @@ Sources: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt`, `lynglib/s
## 5. Additional Built-in Modules (import explicitly) ## 5. Additional Built-in Modules (import explicitly)
- `import lyng.observable` - `import lyng.observable`
- `Observable`, `Subscription`, `ObservableList`, `ListChange` and change subtypes, `ChangeRejectionException`. - `Observable`, `Subscription`, `ObservableList`, `ListChange` and change subtypes, `ChangeRejectionException`.
- `import lyng.decimal`
- `Decimal`, `DecimalContext`, `DecimalRounding`, `withDecimalContext(...)`.
- Kotlin host helper: `ScopeFacade.newDecimal(BigDecimal)` wraps an ionspin host decimal as a Lyng `Decimal`.
- `import lyng.complex`
- `Complex`, `complex(re, im)`, `cis(angle)`, and numeric embedding extensions such as `2.i` / `3.re`.
- `import lyng.matrix`
- `Matrix`, `Vector`, `matrix(rows)`, `vector(values)`, dense linear algebra, inversion, solving, and matrix slicing with `m[row, col]`.
- `import lyng.buffer` - `import lyng.buffer`
- `Buffer`, `MutableBuffer`. - `Buffer`, `MutableBuffer`.
- `import lyng.serialization` - `import lyng.serialization`
+88
View File
@@ -72,6 +72,14 @@ For module-level APIs, the default workflow is:
1. declare globals in Lyng using `extern fun` / `extern val` / `extern var`; 1. declare globals in Lyng using `extern fun` / `extern val` / `extern var`;
2. bind Kotlin implementation via `ModuleScope.globalBinder()`. 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 ```kotlin
import net.sergeych.lyng.bridge.* import net.sergeych.lyng.bridge.*
import net.sergeych.lyng.obj.ObjInt import net.sergeych.lyng.obj.ObjInt
@@ -117,6 +125,12 @@ assertEquals("changed", globalProp)
assertEquals("1.0.0", globalVersion) 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: For custom argument handling and full runtime access:
```kotlin ```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. If you truly need the full `Scope` (e.g., for low-level interop), use `requireScope()` explicitly.
### 4.5) Indexers from Kotlin: `getAt` and `putAt`
Lyng bracket syntax is dispatched through `getAt` and `putAt`.
That means:
- `x[i]` calls `getAt(index)`
- `x[i] = value` calls `putAt(index, value)` or `setAt(index, value)`
- field-like `x["name"]` also uses the same index path unless you expose a real field/property
For Kotlin-backed classes, bind indexers as ordinary methods named `getAt` and `putAt`:
```kotlin
moduleScope.eval("""
extern class Grid {
override fun getAt(index: List<Int>): Int
override fun putAt(index: List<Int>, value: Int): void
}
""".trimIndent())
moduleScope.bind("Grid") {
init { _ -> data = IntArray(4) }
addFun("getAt") {
val index = args.requiredArg<ObjList>(0)
val row = (index.list[0] as ObjInt).value.toInt()
val col = (index.list[1] as ObjInt).value.toInt()
val data = (thisObj as ObjInstance).data as IntArray
ObjInt.of(data[row * 2 + col].toLong())
}
addFun("putAt") {
val index = args.requiredArg<ObjList>(0)
val value = args.requiredArg<ObjInt>(1).value.toInt()
val row = (index.list[0] as ObjInt).value.toInt()
val col = (index.list[1] as ObjInt).value.toInt()
val data = (thisObj as ObjInstance).data as IntArray
data[row * 2 + col] = value
ObjVoid
}
}
```
Usage from Lyng:
```lyng
val g = Grid()
g[0, 1] = 42
assertEquals(42, g[0, 1])
```
Important rule: multiple selectors inside brackets are packed into one index object.
So:
- `x[i]` passes `i`
- `x[i, j]` passes a `List` containing `[i, j]`
- `x[i, j, k]` passes `[i, j, k]`
This applies equally to:
- Kotlin-backed classes
- Lyng classes overriding `getAt`
- `dynamic { get { ... } set { ... } }`
If you want multi-axis slicing semantics, decode that list yourself in `getAt`.
### 5) Add Kotlin‑backed fields ### 5) Add Kotlin‑backed fields
If you need a simple field (with a value) instead of a computed property, use `createField`. This adds a field to the class that will be present in all its instances. If you need a simple field (with a value) instead of a computed property, use `createField`. This adds a field to the class that will be present in all its instances.
@@ -462,14 +542,21 @@ im.addPackage("my.tools") { module: ModuleScope ->
module.eval( module.eval(
""" """
extern val version: String extern val version: String
extern var status: String
extern fun triple(x: Int): Int extern fun triple(x: Int): Int
""".trimIndent() """.trimIndent()
) )
val binder = module.globalBinder() val binder = module.globalBinder()
var status = "ready"
binder.bindGlobalVar( binder.bindGlobalVar(
name = "version", name = "version",
get = { "1.0" } get = { "1.0" }
) )
binder.bindGlobalVar(
name = "status",
get = { status },
set = { status = it }
)
binder.bindGlobalFun1<Int>("triple") { x -> binder.bindGlobalFun1<Int>("triple") { x ->
ObjInt.of((x * 3).toLong()) ObjInt.of((x * 3).toLong())
} }
@@ -479,6 +566,7 @@ im.addPackage("my.tools") { module: ModuleScope ->
scope.eval(""" scope.eval("""
import my.tools.* import my.tools.*
val v = triple(14) val v = triple(14)
status = "busy"
""") """)
val v = scope.eval("v").toKotlin(scope) // -> 42 val v = scope.eval("v").toKotlin(scope) // -> 42
``` ```
+15 -4
View File
@@ -40,7 +40,18 @@ Console.setCursorVisible(true)
Console.flush() Console.flush()
``` ```
Interactive sample script in this repo: #### Tetris sample
The repository includes a full interactive Tetris sample that demonstrates:
- alternate screen rendering
- raw keyboard input
- resize handling
- typed console events
![Lyng Tetris sample](/tetris.png)
Run it from the project root in a real TTY:
```bash ```bash
lyng examples/tetris_console.lyng lyng examples/tetris_console.lyng
@@ -50,7 +61,7 @@ lyng examples/tetris_console.lyng
- `Console.isSupported(): Bool` — whether console control is available on this platform/runtime. - `Console.isSupported(): Bool` — whether console control is available on this platform/runtime.
- `Console.isTty(): Bool` — whether output is attached to a TTY. - `Console.isTty(): Bool` — whether output is attached to a TTY.
- `Console.ansiLevel(): String` — `NONE`, `BASIC16`, `ANSI256`, `TRUECOLOR`. - `Console.ansiLevel(): ConsoleAnsiLevel` — `NONE`, `BASIC16`, `ANSI256`, `TRUECOLOR`.
- `Console.geometry(): ConsoleGeometry?` — `{columns, rows}` as typed object or `null`. - `Console.geometry(): ConsoleGeometry?` — `{columns, rows}` as typed object or `null`.
- `Console.details(): ConsoleDetails` — consolidated capability object. - `Console.details(): ConsoleDetails` — consolidated capability object.
- `Console.write(text: String)` — writes to console output. - `Console.write(text: String)` — writes to console output.
@@ -81,9 +92,9 @@ launch {
#### Event format #### Event format
`Console.events()` emits `ConsoleEvent` with at least: `Console.events()` emits `ConsoleEvent` with:
- `type: String` — `resize`, `keydown`, `keyup` - `type: ConsoleEventType` — `UNKNOWN`, `RESIZE`, `KEY_DOWN`, `KEY_UP`
Additional fields: Additional fields:
+73 -3
View File
@@ -60,8 +60,13 @@ but:
## Round and range ## Round and range
The following functions return its argument if it is `Int`, The following functions return the argument unchanged if it is `Int`.
or transformed `Real` otherwise.
For `Decimal`:
- `floor(x)`, `ceil(x)`, and `round(x)` currently use exact decimal operations
- the result stays `Decimal`
For `Real`, the result is a transformed `Real`.
| name | description | | name | description |
|----------------|--------------------------------------------------------| |----------------|--------------------------------------------------------|
@@ -72,6 +77,14 @@ or transformed `Real` otherwise.
## Lyng math functions ## Lyng math functions
Decimal note:
- all scalar math helpers accept `Decimal`
- `abs(x)` stays exact for `Decimal`
- `pow(x, y)` is exact for `Decimal` when `y` is an integral exponent
- the remaining `Decimal` cases currently use a temporary bridge:
`Decimal -> Real -> host math -> Decimal`
- this is temporary; native decimal implementations are planned
| name | meaning | | name | meaning |
|-----------|------------------------------------------------------| |-----------|------------------------------------------------------|
| sin(x) | sine | | sin(x) | sine |
@@ -91,7 +104,7 @@ or transformed `Real` otherwise.
| log10(x) | $log_{10}(x)$ | | log10(x) | $log_{10}(x)$ |
| pow(x, y) | ${x^y}$ | | pow(x, y) | ${x^y}$ |
| sqrt(x) | $ \sqrt {x}$ | | sqrt(x) | $ \sqrt {x}$ |
| abs(x) | absolute value of x. Int if x is Int, Real otherwise | | abs(x) | absolute value of x. Int if x is Int, Decimal if x is Decimal, Real otherwise |
| clamp(x, range) | limit x to be inside range boundaries | | clamp(x, range) | limit x to be inside range boundaries |
For example: For example:
@@ -104,12 +117,69 @@ For example:
assert( abs(-1) is Int) assert( abs(-1) is Int)
assert( abs(-2.21) == 2.21 ) assert( abs(-2.21) == 2.21 )
import lyng.decimal
// Decimal-aware math works too. Some functions are exact, some still bridge through Real temporarily:
assert( (abs("-2.5".d) as Decimal).toStringExpanded() == "2.5" )
assert( (floor("2.9".d) as Decimal).toStringExpanded() == "2" )
assert( sin("0.5".d) is Decimal )
// clamp() limits value to the range: // clamp() limits value to the range:
assert( clamp(15, 0..10) == 10 ) assert( clamp(15, 0..10) == 10 )
assert( clamp(-5, 0..10) == 0 ) assert( clamp(-5, 0..10) == 0 )
assert( 5.clamp(0..10) == 5 ) assert( 5.clamp(0..10) == 5 )
>>> void >>> void
## Linear algebra: `lyng.matrix`
For vectors and dense matrices, import `lyng.matrix`:
```lyng
import lyng.matrix
```
It provides:
- `Vector`
- `Matrix`
- `vector(values)`
- `matrix(rows)`
Core operations include:
- matrix addition and subtraction
- matrix-matrix multiplication
- matrix-vector multiplication
- transpose
- determinant
- inverse
- linear solve
- vector dot, norm, normalize, cross, outer product
Example:
```lyng
import lyng.matrix
val a: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
val b: Matrix = matrix([[7, 8], [9, 10], [11, 12]])
val product: Matrix = a * b
assertEquals([[58.0, 64.0], [139.0, 154.0]], product.toList())
```
Matrices also support two-axis bracket indexing and slicing:
```lyng
import lyng.matrix
val m: Matrix = matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
assertEquals(6.0, m[1, 2])
val sub: Matrix = m[0..1, 1..2]
assertEquals([[2.0, 3.0], [5.0, 6.0]], sub.toList())
```
See [Matrix](Matrix.md) for the full API.
## Random values ## Random values
Lyng stdlib provides a global random singleton and deterministic seeded generators: Lyng stdlib provides a global random singleton and deterministic seeded generators:
+16 -1
View File
@@ -32,10 +32,25 @@ Depending on the platform, these coroutines may be executed on different CPU and
assert(xIsCalled) assert(xIsCalled)
>>> void >>> void
This example shows how to launch a coroutine with `launch` which returns [Deferred] instance, the latter have ways to await for the coroutine completion and retrieve possible result. This example shows how to launch a coroutine with `launch` which returns [Deferred] instance, the latter have ways to await for the coroutine completion, cancel it if it is no longer needed, and retrieve possible result.
Launch has the only argument which should be a callable (lambda usually) that is run in parallel (or cooperatively in parallel), and return anything as the result. Launch has the only argument which should be a callable (lambda usually) that is run in parallel (or cooperatively in parallel), and return anything as the result.
If you no longer need the result, cancel the deferred. Awaiting a cancelled deferred throws `CancellationException`:
var reached = false
val work = launch {
delay(100)
reached = true
"ok"
}
work.cancel()
assertThrows(CancellationException) { work.await() }
assert(work.isCancelled)
assert(!work.isActive)
assert(!reached)
>>> void
## Synchronization: Mutex ## Synchronization: Mutex
Suppose we have a resource, that could be used concurrently, a counter in our case. If we won't protect it, concurrent usage cause RC, Race Condition, providing wrong result: Suppose we have a resource, that could be used concurrently, a counter in our case. If we won't protect it, concurrent usage cause RC, Race Condition, providing wrong result:
+74
View File
@@ -375,6 +375,18 @@ It is rather simple, like everywhere else:
See [math](math.md) for more on it. Notice using Greek as identifier, all languages are allowed. See [math](math.md) for more on it. Notice using Greek as identifier, all languages are allowed.
For linear algebra, import `lyng.matrix`:
import lyng.matrix
val a: Matrix = matrix([[1, 2], [3, 4]])
val i: Matrix = Matrix.identity(2)
val sum: Matrix = a + i
assertEquals([[2.0, 2.0], [3.0, 5.0]], sum.toList())
>>> void
See [Matrix](Matrix.md) for vectors, matrix multiplication, inversion, and slicing such as `m[0..2, 1]`.
Logical operation could be used the same Logical operation could be used the same
var x = 10 var x = 10
@@ -811,6 +823,14 @@ Lists can contain any type of objects, lists too:
Notice usage of indexing. You can use negative indexes to offset from the end of the list; see more in [Lists](List.md). Notice usage of indexing. You can use negative indexes to offset from the end of the list; see more in [Lists](List.md).
In general, bracket indexing may contain more than one selector:
value[i]
value[i, j]
For built-in lists, strings, maps, and buffers, the selector is usually a single value such as an `Int`, `Range`, or `Regex`.
For types with custom indexers, multiple selectors are packed into one list-like index object and passed to `getAt` / `putAt`.
When you want to "flatten" it to single array, you can use splat syntax: When you want to "flatten" it to single array, you can use splat syntax:
[1, ...[2,3], 4] [1, ...[2,3], 4]
@@ -1573,6 +1593,52 @@ same as:
assert(s[1] == 'a') assert(s[1] == 'a')
>>> void >>> void
### String interpolation
Supported forms:
- `$name`
- `${expr}`
Literal dollar forms:
- `\$` -> `$`
- `$$` -> `$`
Example:
val name = "Lyng"
assertEquals("hello, Lyng!", "hello, $name!")
assertEquals("sum=3", "sum=${1+2}")
assertEquals("\$name", "\$name")
assertEquals("\$name", "$$name")
assertEquals("\\Lyng", "\\$name")
>>> void
Interpolation and `printf`-style formatting can be combined when needed:
val method = "transfer"
val argc = 2
val compact = "%s:%d"(method, argc)
assertEquals("call=transfer:2", "call=$compact")
assertEquals("[transfer:2] ok", "[${"%s:%d"(method, argc)}] ok")
>>> void
Interpolation also works well with regex patterns. To keep a literal `$` in the
regex, escape it in the resulting pattern:
val currency = "USD"
val amount = 15
val escapedDollar = "\\$"
val re = Regex("^${currency}${escapedDollar}${amount}$")
assert("USD$15" =~ re)
assert("USD15" !~ re)
>>> void
If you need old literal behavior in a file, add a leading directive comment:
// feature: interpolation: off
### Char literal escapes ### Char literal escapes
Are the same as in string literals with little difference: Are the same as in string literals with little difference:
@@ -1653,6 +1719,14 @@ Open-ended ranges could be used to get start and end too:
assertEquals( "pult", "catapult"[ 4.. ]) assertEquals( "pult", "catapult"[ 4.. ])
>>> void >>> void
The same bracket syntax is also used by imported numeric modules such as `lyng.matrix`, where indexing can be multi-axis:
import lyng.matrix
val m: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
assertEquals(6.0, m[1, 2])
>>> void
### String operations ### String operations
Concatenation is a `+`: `"hello " + name` works as expected. No confusion. There is also Concatenation is a `+`: `"hello " + name` works as expected. No confusion. There is also
+114
View File
@@ -5,6 +5,120 @@ For a programmer-focused migration summary, see `docs/whats_new_1_5.md`.
## Language Features ## Language Features
### Matrix and Vector Module (`lyng.matrix`)
Lyng now ships a dense linear algebra module with immutable double-precision `Matrix` and `Vector` types.
It provides:
- `matrix([[...]])` and `vector([...])`
- matrix multiplication
- matrix inversion
- determinant, trace, rank
- solving `A * x = b`
- vector operations such as `dot`, `normalize`, `cross`, and `outer`
```lyng
import lyng.matrix
val a: Matrix = matrix([[4, 7], [2, 6]])
val inv: Matrix = a.inverse()
assert(abs(inv.get(0, 0) - 0.6) < 1e-9)
```
Matrices also support Lyng-style slicing:
```lyng
import lyng.matrix
val m: Matrix = matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
assertEquals(6.0, m[1, 2])
val column: Matrix = m[0..2, 2]
val tail: Matrix = m[1.., 1..]
assertEquals([[3.0], [6.0], [9.0]], column.toList())
assertEquals([[5.0, 6.0], [8.0, 9.0]], tail.toList())
```
See [Matrix](Matrix.md).
### Multiple Selectors in Bracket Indexing
Bracket indexing now accepts more than one selector:
```lyng
value[i]
value[i, j]
value[i, j, k]
```
For custom indexers, multiple selectors are packed into one list-like index object and dispatched through `getAt` / `putAt`.
This is the rule used by `lyng.matrix` and by embedding APIs for Kotlin-backed indexers.
### Decimal Arithmetic Module (`lyng.decimal`)
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 ### 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. Classes now support properties with custom `get()` and `set()` accessors. Properties in Lyng do **not** have automatic backing fields; they are pure accessors.
+76
View File
@@ -0,0 +1,76 @@
fun calculateDepth(
T: Real,
m: Real,
d: Real,
rho: Real = 1.2,
c: Real = 340.0,
g: Real = 9.81,
Cd: Real = 0.5,
eps: Real = 1e-3,
maxIter: Int = 100
): Real? {
// Площадь миделя
val r = d / 2.0
val A = π * r * r
// Коэффициент сопротивления
val k = 0.5 * Cd * rho * A
// Предельная скорость
val vTerm = sqrt(m * g / k)
// Функция времени падения с высоты h
fun tFall(h: Real): Real {
// Для численной стабильности при больших h используем логарифмическую форму
val arg = exp(g * h / (vTerm * vTerm))
// arcosh(x) = ln(x + sqrt(x^2 - 1))
val arcosh = ln(arg + sqrt(arg * arg - 1.0))
return vTerm / g * arcosh
}
// Полное расчётное время
fun Tcalc(h: Real): Real = tFall(h) + h / c
// Находим интервал, содержащий корень
// Нижняя граница: глубина не может быть отрицательной
var lo = 0.0
// Верхняя граница: сначала попробуем оценку по свободному падению (без звука)
var hi = 0.5 * g * T * T // максимальная глубина, если бы не было сопротивления и звука
// Уточним hi, чтобы Tcalc(hi) было заведомо больше T
while (Tcalc(hi) < T && hi < 1e4) {
hi *= 2.0
}
// Проверка, что hi достаточно велико
if (Tcalc(hi) < T) return null // слишком большая глубина, не укладываемся в разумное
// Бисекция
var iter = 0
var h = (lo + hi) / 2.0
while (iter < maxIter && (hi - lo) > eps) {
val f = Tcalc(h) - T
if (abs(f) < eps) break
if (f > 0) {
hi = h
} else {
lo = h
}
h = (lo + hi) / 2.0
iter++
}
return h
}
// Пример: T=12 секунд
val T = 26.0
val m = 1.0 // кг
val d = 0.1 // м
val depth = calculateDepth(T, m, d)
if (depth != null) {
println("Глубина: %.2f м"(depth))
// Для проверки выведем теоретическое время при найденной глубине
// (можно добавить функцию для самопроверки)
} else {
println("Расчёт не сошёлся")
}
Regular → Executable
+257 -102
View File
@@ -8,15 +8,25 @@
* - Up arrow or W: rotate * - Up arrow or W: rotate
* - Down arrow or S: soft drop * - Down arrow or S: soft drop
* - Space: hard drop * - Space: hard drop
* - Q or Escape: quit * - P or Escape: pause
* - Q: quit
Tsted to score:
sergeych@sergeych-XPS-17-9720:~$ ~/dev/lyng/examples/tetris_console.lyng
Bye.
Score: 435480
Lines: 271
Level: 28
Ssergeych@sergeych-XPS-17-9720:~$
*/ */
import lyng.io.console import lyng.io.console
import lyng.io.fs
val MIN_COLS = 56 val MIN_COLS = 56
val MIN_ROWS = 24 val MIN_ROWS = 24
val PANEL_WIDTH = 24 val PANEL_WIDTH = 24
val BOARD_MARGIN_ROWS = 8 val BOARD_MARGIN_ROWS = 5
val BOARD_MIN_W = 10 val BOARD_MIN_W = 10
val BOARD_MAX_W = 16 val BOARD_MAX_W = 16
val BOARD_MIN_H = 16 val BOARD_MIN_H = 16
@@ -26,9 +36,11 @@ val DROP_FRAMES_BASE = 15
val DROP_FRAMES_MIN = 3 val DROP_FRAMES_MIN = 3
val FRAME_DELAY_MS = 35 val FRAME_DELAY_MS = 35
val RESIZE_WAIT_MS = 250 val RESIZE_WAIT_MS = 250
val MAX_PENDING_INPUTS = 64
val ROTATION_KICKS = [0, -1, 1, -2, 2] val ROTATION_KICKS = [0, -1, 1, -2, 2]
val ANSI_ESC = "\u001b[" val ANSI_ESC = "\u001b["
val ANSI_RESET = ANSI_ESC + "0m" val ANSI_RESET = ANSI_ESC + "0m"
val ERROR_LOG_PATH = "/tmp/lyng_tetris_errors.log"
val UNICODE_BLOCK = "██" val UNICODE_BLOCK = "██"
val UNICODE_TOP_LEFT = "┌" val UNICODE_TOP_LEFT = "┌"
val UNICODE_TOP_RIGHT = "┐" val UNICODE_TOP_RIGHT = "┐"
@@ -64,6 +76,7 @@ class GameState(
var level = 1 var level = 1
var running = true var running = true
var gameOver = false var gameOver = false
var paused = false
} }
class LoopFrame(val resized: Bool, val originRow: Int, val originCol: Int) {} class LoopFrame(val resized: Bool, val originRow: Int, val originCol: Int) {}
@@ -72,44 +85,44 @@ fun clearAndHome() {
Console.home() Console.home()
} }
fun logError(message: String, err: Object?): Void {
try {
var details = ""
if (err != null) {
try {
details = ": " + err
} catch (_: Object) {
details = ": <error-format-failed>"
}
}
Path(ERROR_LOG_PATH).appendUtf8(message + details + "\n")
} catch (_: Object) {
// Never let logging errors affect gameplay.
}
}
fun repeatText(s: String, n: Int): String { fun repeatText(s: String, n: Int): String {
var out: String = "" var out: String = ""
var i = 0 for (i in 0..<n) {
while (i < n) {
out += s out += s
i = i + 1
} }
out out
} }
fun maxInt(a: Int, b: Int): Int { fun max<T>(a: T, b: T): T = if (a > b) a else b
if (a > b) a else b
}
fun minInt(a: Int, b: Int): Int {
if (a < b) a else b
}
fun clampInt(v: Int, lo: Int, hi: Int): Int {
minInt(hi, maxInt(lo, v))
}
fun emptyRow(width: Int): Row { fun emptyRow(width: Int): Row {
val r: Row = [] val r: Row = []
var x = 0 for (x in 0..<width) {
while (x < width) {
r.add(0) r.add(0)
x = x + 1
} }
r r
} }
fun createBoard(width: Int, height: Int): Board { fun createBoard(width: Int, height: Int): Board {
val b: Board = [] val b: Board = []
var y = 0 for (y in 0..<height) {
while (y < height) {
b.add(emptyRow(width)) b.add(emptyRow(width))
y = y + 1
} }
b b
} }
@@ -139,7 +152,10 @@ fun emptyCellText(useColor: Bool): String {
} }
fun canPlace(board: Board, boardW: Int, boardH: Int, pieceId: Int, rot: Int, px: Int, py: Int): Bool { fun canPlace(board: Board, boardW: Int, boardH: Int, pieceId: Int, rot: Int, px: Int, py: Int): Bool {
try {
if (pieceId < 1 || pieceId > 7) return false
val piece: Piece = PIECES[pieceId - 1] val piece: Piece = PIECES[pieceId - 1]
if (rot < 0 || rot >= piece.rotations.size) return false
val cells = piece.rotations[rot] val cells = piece.rotations[rot]
for (cell in cells) { for (cell in cells) {
@@ -150,11 +166,16 @@ fun canPlace(board: Board, boardW: Int, boardH: Int, pieceId: Int, rot: Int, px:
if (y >= boardH) return false if (y >= boardH) return false
if (y >= 0) { if (y >= 0) {
if (y >= board.size) return false
val row = board[y] val row = board[y]
if (row == null) return false
if (row[x] != 0) return false if (row[x] != 0) return false
} }
} }
true true
} catch (_: Object) {
false
}
} }
fun lockPiece(board: Board, pieceId: Int, rot: Int, px: Int, py: Int): Void { fun lockPiece(board: Board, pieceId: Int, rot: Int, px: Int, py: Int): Void {
@@ -165,12 +186,14 @@ fun lockPiece(board: Board, pieceId: Int, rot: Int, px: Int, py: Int): Void {
val x = px + cell[0] val x = px + cell[0]
val y = py + cell[1] val y = py + cell[1]
if (y >= 0) { if (y >= 0 && y < board.size) {
val row = board[y] val row = board[y]
if (row != null) {
row[x] = pieceId row[x] = pieceId
} }
} }
} }
}
fun clearCompletedLines(board: Board, boardW: Int, boardH: Int): Int { fun clearCompletedLines(board: Board, boardW: Int, boardH: Int): Int {
val b = board val b = board
@@ -178,23 +201,31 @@ fun clearCompletedLines(board: Board, boardW: Int, boardH: Int): Int {
var cleared = 0 var cleared = 0
while (y >= 0) { while (y >= 0) {
if (y >= b.size) {
y--
continue
}
val row = b[y] val row = b[y]
if (row == null) {
b.removeAt(y)
b.insertAt(0, emptyRow(boardW))
cleared++
continue
}
var full = true var full = true
var x = 0 for (x in 0..<boardW) {
while (x < boardW) {
if (row[x] == 0) { if (row[x] == 0) {
full = false full = false
break break
} }
x = x + 1
} }
if (full) { if (full) {
b.removeAt(y) b.removeAt(y)
b.insertAt(0, emptyRow(boardW)) b.insertAt(0, emptyRow(boardW))
cleared = cleared + 1 cleared++
} else { } else {
y = y - 1 y--
} }
} }
@@ -220,7 +251,7 @@ fun tryRotateCw(board: Board, boardW: Int, boardH: Int, pieceId: Int, rot: Int,
val nr = (rot + 1) % rotations val nr = (rot + 1) % rotations
for (kx in ROTATION_KICKS) { for (kx in ROTATION_KICKS) {
val nx = px + kx val nx = px + kx
if (canPlace(board, boardW, boardH, pieceId, nr, nx, py)) { if (canPlace(board, boardW, boardH, pieceId, nr, nx, py) == true) {
return RotateResult(true, nr, nx) return RotateResult(true, nr, nx)
} }
} }
@@ -230,21 +261,18 @@ fun tryRotateCw(board: Board, boardW: Int, boardH: Int, pieceId: Int, rot: Int,
fun nextPreviewLines(pieceId: Int, useColor: Bool): List<String> { fun nextPreviewLines(pieceId: Int, useColor: Bool): List<String> {
val out: List<String> = [] val out: List<String> = []
if (pieceId <= 0) { if (pieceId <= 0) {
for (i in 0..<4) {
out.add(" ") out.add(" ")
out.add(" ") }
out.add(" ")
out.add(" ")
return out return out
} }
val piece: Piece = PIECES[pieceId - 1] val piece: Piece = PIECES[pieceId - 1]
val cells = piece.rotations[0] val cells = piece.rotations[0]
var y = 0 for (y in 0..<4) {
while (y < 4) {
var line = "" var line = ""
var x = 0 for (x in 0..<4) {
while (x < 4) {
var filled = false var filled = false
for (cell in cells) { for (cell in cells) {
if (cell[0] == x && cell[1] == y) { if (cell[0] == x && cell[1] == y) {
@@ -253,10 +281,8 @@ fun nextPreviewLines(pieceId: Int, useColor: Bool): List<String> {
} }
} }
line += if (filled) blockText(pieceId, useColor) else " " line += if (filled) blockText(pieceId, useColor) else " "
x = x + 1
} }
out.add(line) out.add(line)
y = y + 1
} }
out out
} }
@@ -296,52 +322,101 @@ fun render(
panel.add("W/Up: rotate") panel.add("W/Up: rotate")
panel.add("S/Down: drop") panel.add("S/Down: drop")
panel.add("Space: hard drop") panel.add("Space: hard drop")
panel.add("Q/Esc: quit") panel.add("P/Esc: pause")
panel.add("Q: quit")
val frameLines: List<String> = [] val frameLines: List<String> = []
var y = 0 for (y in 0..<boardH) {
while (y < boardH) {
var line = UNICODE_VERTICAL var line = UNICODE_VERTICAL
var x = 0 for (x in 0..<boardW) {
while (x < boardW) {
val a = activeCellId(state.pieceId, state.rot, state.px, state.py, x, y) val a = activeCellId(state.pieceId, state.rot, state.px, state.py, x, y)
val row = board[y] val row = if (y < board.size) board[y] else null
val b = row[x] val b = if (row == null) 0 else row[x]
val id = if (a > 0) a else b val id = if (a > 0) a else b
line += if (id > 0) blockText(id, useColor) else emptyCellText(useColor) line += if (id > 0) blockText(id, useColor) else emptyCellText(useColor)
x = x + 1
} }
line += UNICODE_VERTICAL line += UNICODE_VERTICAL
val p = y if (y < panel.size) {
if (p < panel.size) { line += " " + panel[y]
line += " " + panel[p]
} }
frameLines.add(line) frameLines.add(line)
y = y + 1
} }
frameLines.add(bottomBorder) frameLines.add(bottomBorder)
val prev = prevFrameLines for (i in 0..<frameLines.size) {
var i = 0
while (i < frameLines.size) {
val line = frameLines[i] val line = frameLines[i]
val old = if (i < prev.size) prev[i] else null val old = if (i < prevFrameLines.size) prevFrameLines[i] else null
if (old != line) { if (old != line) {
Console.moveTo(originRow + i, originCol) Console.moveTo(originRow + i, originCol)
Console.clearLine() Console.clearLine()
Console.write(line) Console.write(line)
} }
i = i + 1
} }
frameLines frameLines
} }
fun fitLine(line: String, width: Int): String {
val maxLen = if (width > 0) width else 0
if (maxLen <= 0) return ""
if (line.size >= maxLen) return line[..<maxLen]
line + repeatText(" ", maxLen - line.size)
}
fun renderPauseOverlay(
originRow: Int,
originCol: Int,
boardW: Int,
boardH: Int,
): Void {
val contentWidth = boardW * 2 + 2 + 3 + PANEL_WIDTH
val contentHeight = boardH + 1
val lines: List<String> = []
lines.add("PAUSED")
lines.add("")
lines.add("Any key: continue game")
lines.add("Esc: exit game")
lines.add("")
lines.add("Move: A/D or arrows")
lines.add("Rotate: W or Up")
lines.add("Drop: S/Down, Space hard drop")
var innerWidth = 0
for (line in lines) {
if (line.size > innerWidth) innerWidth = line.size
}
innerWidth += 4
val maxInner = max(12, contentWidth - 2)
if (innerWidth > maxInner) innerWidth = maxInner
if (innerWidth % 2 != 0) innerWidth--
val boxWidth = innerWidth + 2
val boxHeight = lines.size + 2
val left = originCol + max(0, (contentWidth - boxWidth) / 2)
val top = originRow + max(0, (contentHeight - boxHeight) / 2)
val topBorder = UNICODE_TOP_LEFT + repeatText(UNICODE_HORIZONTAL, innerWidth / 2) + UNICODE_TOP_RIGHT
val bottomBorder = UNICODE_BOTTOM_LEFT + repeatText(UNICODE_HORIZONTAL, innerWidth / 2) + UNICODE_BOTTOM_RIGHT
Console.moveTo(top, left)
Console.write(topBorder)
for (i in 0..<lines.size) {
Console.moveTo(top + 1 + i, left)
Console.write(UNICODE_VERTICAL + fitLine(" " + lines[i], innerWidth) + UNICODE_VERTICAL)
}
Console.moveTo(top + boxHeight - 1, left)
Console.write(bottomBorder)
}
fun waitForMinimumSize(minCols: Int, minRows: Int): Object { fun waitForMinimumSize(minCols: Int, minRows: Int): Object {
while (true) { while (true) {
val g = Console.geometry() val g = Console.geometry()
@@ -351,9 +426,23 @@ fun waitForMinimumSize(minCols: Int, minRows: Int): Object {
if (cols >= minCols && rows >= minRows) return g if (cols >= minCols && rows >= minRows) return g
clearAndHome() clearAndHome()
println("Lyng Tetris needs at least %sx%s terminal size."(minCols, minRows)) val lines: List<String> = []
println("Current: %sx%s"(cols, rows)) lines.add("Lyng Tetris needs at least %sx%s terminal size."(minCols, minRows))
println("Resize the console window to continue...") lines.add("Current: %sx%s"(cols, rows))
lines.add("Resize the console window to continue.")
val visibleLines = if (rows < lines.size) rows else lines.size
if (visibleLines > 0) {
val startRow = max(1, ((rows - visibleLines) / 2) + 1)
for (i in 0..<visibleLines) {
val line = lines[i]
val startCol = max(1, ((cols - line.size) / 2) + 1)
Console.moveTo(startRow + i, startCol)
Console.clearLine()
Console.write(line)
}
Console.flush()
}
delay(RESIZE_WAIT_MS) delay(RESIZE_WAIT_MS)
} }
} }
@@ -434,8 +523,8 @@ if (!Console.isSupported()) {
val cols = g0?.columns ?: MIN_COLS val cols = g0?.columns ?: MIN_COLS
val rows = g0?.rows ?: MIN_ROWS val rows = g0?.rows ?: MIN_ROWS
val boardW = clampInt((cols - PANEL_WIDTH) / 2, BOARD_MIN_W, BOARD_MAX_W) val boardW = clamp((cols - PANEL_WIDTH) / 2, BOARD_MIN_W..BOARD_MAX_W)
val boardH = clampInt(rows - BOARD_MARGIN_ROWS, BOARD_MIN_H, BOARD_MAX_H) val boardH = clamp(rows - BOARD_MARGIN_ROWS, BOARD_MIN_H..BOARD_MAX_H)
val board: Board = createBoard(boardW, boardH) val board: Board = createBoard(boardW, boardH)
@@ -452,8 +541,9 @@ if (!Console.isSupported()) {
) )
var prevFrameLines: List<String> = [] var prevFrameLines: List<String> = []
val gameMutex = Mutex() val gameMutex: Mutex = Mutex()
var hasResizeEvent = false var forceRedraw = false
val pendingInputs: List<String> = []
val rawModeEnabled = Console.setRawMode(true) val rawModeEnabled = Console.setRawMode(true)
if (!rawModeEnabled) { if (!rawModeEnabled) {
@@ -461,20 +551,43 @@ if (!Console.isSupported()) {
println("Use jlyng in an interactive terminal with raw input support.") println("Use jlyng in an interactive terminal with raw input support.")
void void
} else { } else {
val useColor = Console.ansiLevel() != "NONE" val useColor = Console.ansiLevel() != ConsoleAnsiLevel.NONE
Console.enterAltScreen() Console.enterAltScreen()
Console.setCursorVisible(false) Console.setCursorVisible(false)
clearAndHome() clearAndHome()
fun resetActivePiece(s: GameState): Void {
s.pieceId = nextPieceId()
s.rot = 0
s.px = (boardW / 2) - 2
s.py = -1
}
fun applyKeyInput(s: GameState, key: String): Void { fun applyKeyInput(s: GameState, key: String): Void {
if (key == "__CTRL_C__" || key == "q" || key == "Q" || key == "Escape") { try {
if (key == "__CTRL_C__") {
s.running = false
}
else if (s.paused) {
if (key == "Escape") {
s.running = false
} else {
s.paused = false
forceRedraw = true
}
}
else if (key == "p" || key == "P" || key == "Escape") {
s.paused = true
forceRedraw = true
}
else if (key == "q" || key == "Q") {
s.running = false s.running = false
} }
else if (key == "ArrowLeft" || key == "a" || key == "A") { else if (key == "ArrowLeft" || key == "a" || key == "A") {
if (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px - 1, s.py)) s.px = s.px - 1 if (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px - 1, s.py) == true) s.px--
} }
else if (key == "ArrowRight" || key == "d" || key == "D") { else if (key == "ArrowRight" || key == "d" || key == "D") {
if (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px + 1, s.py)) s.px = s.px + 1 if (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px + 1, s.py) == true) s.px++
} }
else if (key == "ArrowUp" || key == "w" || key == "W") { else if (key == "ArrowUp" || key == "w" || key == "W") {
val rr: RotateResult = tryRotateCw(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py) val rr: RotateResult = tryRotateCw(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py)
@@ -484,17 +597,21 @@ if (!Console.isSupported()) {
} }
} }
else if (key == "ArrowDown" || key == "s" || key == "S") { else if (key == "ArrowDown" || key == "s" || key == "S") {
if (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py + 1)) { if (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py + 1) == true) {
s.py = s.py + 1 s.py++
s.score = s.score + 1 s.score++
} }
} }
else if (key == " ") { else if (key == " ") {
while (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py + 1)) { while (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py + 1) == true) {
s.py = s.py + 1 s.py++
s.score = s.score + 2 s.score += 2
} }
} }
} catch (inputErr: Object) {
logError("applyKeyInput recovered after error", inputErr)
resetActivePiece(s)
}
} }
var inputRunning = true var inputRunning = true
@@ -503,26 +620,47 @@ if (!Console.isSupported()) {
try { try {
for (ev in Console.events()) { for (ev in Console.events()) {
if (!inputRunning) break if (!inputRunning) break
// Isolate per-event failures so one bad event does not unwind the stream.
try {
if (ev is ConsoleKeyEvent) { if (ev is ConsoleKeyEvent) {
val ke = ev as ConsoleKeyEvent val ke = ev as ConsoleKeyEvent
if (ke.type == "keydown") { if (ke.type == ConsoleEventType.KEY_DOWN) {
val key = ke.key var key = ""
val ctrl = ke.ctrl var ctrl = false
gameMutex.withLock { try {
key = ke.key
} catch (keyErr: Object) {
logError("Input key read error", keyErr)
}
try {
ctrl = ke.ctrl == true
} catch (_: Object) {
ctrl = false
}
if (key == "") {
logError("Dropped key event with empty/null key", null)
continue
}
val mapped = if (ctrl && (key == "c" || key == "C")) "__CTRL_C__" else key val mapped = if (ctrl && (key == "c" || key == "C")) "__CTRL_C__" else key
applyKeyInput(state, mapped) val mm: Mutex = gameMutex
mm.withLock {
if (pendingInputs.size >= MAX_PENDING_INPUTS) {
pendingInputs.removeAt(0)
} }
} pendingInputs.add(mapped)
} else if (ev is ConsoleResizeEvent) {
gameMutex.withLock {
hasResizeEvent = true
prevFrameLines = []
} }
} }
} }
} catch (err: Exception) { } catch (eventErr: Object) {
// Keep game alive: transient console-event failures should not force quit. // Keep the input stream alive; report for diagnostics.
logError("Input event error", eventErr)
}
}
} catch (err: Object) {
// Recover stream-level failures by recreating event stream in next loop turn.
if (!inputRunning) break if (!inputRunning) break
logError("Input stream recovered after error", err)
Console.setRawMode(true) Console.setRawMode(true)
delay(50) delay(50)
} }
@@ -540,16 +678,10 @@ if (!Console.isSupported()) {
return null return null
} }
var resized = false
gameMutex.withLock {
resized = hasResizeEvent
hasResizeEvent = false
}
val contentCols = boardW * 2 + 2 + 3 + PANEL_WIDTH val contentCols = boardW * 2 + 2 + 3 + PANEL_WIDTH
val contentRows = boardH + 1 val contentRows = boardH + 1
val requiredCols = maxInt(MIN_COLS, contentCols) val requiredCols = max(MIN_COLS, contentCols)
val requiredRows = maxInt(MIN_ROWS, contentRows) val requiredRows = max(MIN_ROWS, contentRows)
if (c < requiredCols || r < requiredRows) { if (c < requiredCols || r < requiredRows) {
waitForMinimumSize(requiredCols, requiredRows) waitForMinimumSize(requiredCols, requiredRows)
clearAndHome() clearAndHome()
@@ -557,21 +689,21 @@ if (!Console.isSupported()) {
return null return null
} }
val originCol = maxInt(1, ((c - contentCols) / 2) + 1) val originCol = max(1, ((c - contentCols) / 2) + 1)
val originRow = maxInt(1, ((r - contentRows) / 2) + 1) val originRow = max(1, ((r - contentRows) / 2) + 1)
LoopFrame(resized, originRow, originCol) LoopFrame(false, originRow, originCol)
} }
fun advanceGravity(s: GameState, frame: Int): Int { fun advanceGravity(s: GameState, frame: Int): Int {
s.level = 1 + (s.totalLines / LEVEL_LINES_STEP) s.level = 1 + (s.totalLines / LEVEL_LINES_STEP)
val dropEvery = maxInt(DROP_FRAMES_MIN, DROP_FRAMES_BASE - s.level) val dropEvery = max(DROP_FRAMES_MIN, DROP_FRAMES_BASE - s.level)
var nextFrame = frame + 1 var nextFrame = frame + 1
if (nextFrame < dropEvery) return nextFrame if (nextFrame < dropEvery) return nextFrame
nextFrame = 0 nextFrame = 0
if (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py + 1)) { if (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py + 1) == true) {
s.py = s.py + 1 s.py++
return nextFrame return nextFrame
} }
@@ -579,8 +711,8 @@ if (!Console.isSupported()) {
val cleared = clearCompletedLines(board, boardW, boardH) val cleared = clearCompletedLines(board, boardW, boardH)
if (cleared > 0) { if (cleared > 0) {
s.totalLines = s.totalLines + cleared s.totalLines += cleared
s.score = s.score + scoreForLines(cleared, s.level) s.score += scoreForLines(cleared, s.level)
} }
s.pieceId = s.nextId s.pieceId = s.nextId
@@ -605,25 +737,45 @@ if (!Console.isSupported()) {
var shouldStop = false var shouldStop = false
var prevOriginRow = -1 var prevOriginRow = -1
var prevOriginCol = -1 var prevOriginCol = -1
var prevPaused = false
while (!shouldStop) { while (!shouldStop) {
val frameData = pollLoopFrame() val frameData = pollLoopFrame()
if (frameData == null) { if (frameData == null) {
frame = 0 frame = 0
prevPaused = false
continue continue
} }
gameMutex.withLock { val mm: Mutex = gameMutex
mm.withLock {
if (pendingInputs.size > 0) {
val toApply: List<String> = []
while (pendingInputs.size > 0) {
val k = pendingInputs[0]
pendingInputs.removeAt(0)
toApply.add(k)
}
for (k in toApply) {
applyKeyInput(state, k)
if (!state.running || state.gameOver) break
}
}
}
if (!state.running || state.gameOver) { if (!state.running || state.gameOver) {
shouldStop = true shouldStop = true
} else { } else {
val localForceRedraw = forceRedraw
forceRedraw = false
val movedOrigin = frameData.originRow != prevOriginRow || frameData.originCol != prevOriginCol val movedOrigin = frameData.originRow != prevOriginRow || frameData.originCol != prevOriginCol
if (frameData.resized || movedOrigin) { if (frameData.resized || movedOrigin || localForceRedraw) {
clearAndHome() clearAndHome()
prevFrameLines = [] prevFrameLines = []
} }
prevOriginRow = frameData.originRow prevOriginRow = frameData.originRow
prevOriginCol = frameData.originCol prevOriginCol = frameData.originCol
if (!state.paused) {
frame = advanceGravity(state, frame) frame = advanceGravity(state, frame)
}
prevFrameLines = render( prevFrameLines = render(
state, state,
board, board,
@@ -634,7 +786,10 @@ if (!Console.isSupported()) {
frameData.originCol, frameData.originCol,
useColor useColor
) )
if (state.paused && (!prevPaused || frameData.resized || movedOrigin)) {
renderPauseOverlay(frameData.originRow, frameData.originCol, boardW, boardH)
} }
prevPaused = state.paused
} }
Console.flush() Console.flush()
delay(FRAME_DELAY_MS) delay(FRAME_DELAY_MS)
+1 -4
View File
@@ -27,9 +27,6 @@ kotlin.mpp.enableCInteropCommonization=true
android.useAndroidX=true android.useAndroidX=true
android.nonTransitiveRClass=true android.nonTransitiveRClass=true
# other
kotlin.native.cacheKind.linuxX64=none
# Workaround: Ensure Gradle uses a JDK with `jlink` available for AGP's JDK image transform. # Workaround: Ensure Gradle uses a JDK with `jlink` available for AGP's JDK image transform.
# On this environment, the system JDK 21 installation lacks `jlink`, causing # On this environment, the system JDK 21 installation lacks `jlink`, causing
# :lynglib:androidJdkImage to fail. Point Gradle to a JDK that includes `jlink`. # :lynglib:androidJdkImage to fail. Point Gradle to a JDK that includes `jlink`.
@@ -37,6 +34,6 @@ kotlin.native.cacheKind.linuxX64=none
#org.gradle.java.home=/home/sergeych/.jdks/corretto-21.0.9 #org.gradle.java.home=/home/sergeych/.jdks/corretto-21.0.9
android.experimental.lint.migrateToK2=false android.experimental.lint.migrateToK2=false
android.lint.useK2Uast=false android.lint.useK2Uast=false
kotlin.mpp.applyDefaultHierarchyTemplate=true kotlin.mpp.applyDefaultHierarchyTemplate=false
org.gradle.parallel=true org.gradle.parallel=true
+5 -1
View File
@@ -2,12 +2,14 @@
agp = "8.5.2" agp = "8.5.2"
clikt = "5.0.3" clikt = "5.0.3"
mordant = "3.0.2" mordant = "3.0.2"
kotlin = "2.3.0" kotlin = "2.3.20"
android-minSdk = "24" android-minSdk = "24"
android-compileSdk = "34" android-compileSdk = "34"
kotlinx-coroutines = "1.10.2" kotlinx-coroutines = "1.10.2"
kotlinx-datetime = "0.6.1" kotlinx-datetime = "0.6.1"
mp_bintools = "0.3.2" mp_bintools = "0.3.2"
ionspin-bignum = "0.3.10"
multik = "0.3.0"
firebaseCrashlyticsBuildtools = "3.0.3" firebaseCrashlyticsBuildtools = "3.0.3"
okioVersion = "3.10.2" okioVersion = "3.10.2"
compiler = "3.2.0-alpha11" compiler = "3.2.0-alpha11"
@@ -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-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" } kotlinx-datetime = { module = "org.jetbrains.kotlinx:kotlinx-datetime", version.ref = "kotlinx-datetime" }
mp_bintools = { module = "net.sergeych:mp_bintools", version.ref = "mp_bintools" } mp_bintools = { module = "net.sergeych:mp_bintools", version.ref = "mp_bintools" }
ionspin-bignum = { module = "com.ionspin.kotlin:bignum", version.ref = "ionspin-bignum" }
multik-default = { module = "org.jetbrains.kotlinx:multik-default", version.ref = "multik" }
firebase-crashlytics-buildtools = { group = "com.google.firebase", name = "firebase-crashlytics-buildtools", version.ref = "firebaseCrashlyticsBuildtools" } firebase-crashlytics-buildtools = { group = "com.google.firebase", name = "firebase-crashlytics-buildtools", version.ref = "firebaseCrashlyticsBuildtools" }
okio = { module = "com.squareup.okio:okio", version.ref = "okioVersion" } okio = { module = "com.squareup.okio:okio", version.ref = "okioVersion" }
okio-fakefilesystem = { module = "com.squareup.okio:okio-fakefilesystem", version.ref = "okioVersion" } okio-fakefilesystem = { module = "com.squareup.okio:okio-fakefilesystem", version.ref = "okioVersion" }
@@ -23,6 +23,8 @@ import com.intellij.execution.ui.ConsoleViewContentType
import com.intellij.openapi.actionSystem.AnAction import com.intellij.openapi.actionSystem.AnAction
import com.intellij.openapi.actionSystem.AnActionEvent import com.intellij.openapi.actionSystem.AnActionEvent
import com.intellij.openapi.actionSystem.CommonDataKeys import com.intellij.openapi.actionSystem.CommonDataKeys
import com.intellij.openapi.application.ApplicationManager
import com.intellij.openapi.fileEditor.FileDocumentManager
import com.intellij.openapi.project.Project import com.intellij.openapi.project.Project
import com.intellij.openapi.wm.ToolWindow import com.intellij.openapi.wm.ToolWindow
import com.intellij.openapi.wm.ToolWindowAnchor import com.intellij.openapi.wm.ToolWindowAnchor
@@ -36,9 +38,10 @@ import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.SupervisorJob import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.launch import kotlinx.coroutines.launch
import net.sergeych.lyng.idea.LyngIcons import net.sergeych.lyng.idea.LyngIcons
import java.io.File
class RunLyngScriptAction : AnAction(LyngIcons.FILE) { class RunLyngScriptAction : AnAction(LyngIcons.FILE) {
private val scope = CoroutineScope(Dispatchers.Default + SupervisorJob()) private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
private fun getPsiFile(e: AnActionEvent): PsiFile? { private fun getPsiFile(e: AnActionEvent): PsiFile? {
val project = e.project ?: return null val project = e.project ?: return null
@@ -48,36 +51,99 @@ class RunLyngScriptAction : AnAction(LyngIcons.FILE) {
} }
} }
private fun getRunnableFile(e: AnActionEvent): PsiFile? {
val psiFile = getPsiFile(e) ?: return null
val virtualFile = psiFile.virtualFile ?: return null
if (!virtualFile.isInLocalFileSystem) return null
if (!psiFile.name.endsWith(".lyng")) return null
return psiFile
}
override fun update(e: AnActionEvent) { override fun update(e: AnActionEvent) {
val psiFile = getPsiFile(e) val psiFile = getRunnableFile(e)
val isLyng = psiFile?.name?.endsWith(".lyng") == true val isRunnable = psiFile != null
e.presentation.isEnabledAndVisible = isLyng e.presentation.isEnabledAndVisible = isRunnable
if (isLyng) { if (isRunnable) {
e.presentation.isEnabled = false e.presentation.text = "Run '${psiFile.name}'"
e.presentation.text = "Run '${psiFile.name}' (disabled)" e.presentation.description = "Run the current Lyng script using the Lyng CLI"
e.presentation.description = "Running scripts from the IDE is disabled; use the CLI."
} else { } else {
e.presentation.text = "Run Lyng Script" e.presentation.text = "Run Lyng Script"
e.presentation.description = "Run the current Lyng script"
} }
} }
override fun actionPerformed(e: AnActionEvent) { override fun actionPerformed(e: AnActionEvent) {
val project = e.project ?: return val project = e.project ?: return
val psiFile = getPsiFile(e) ?: return val psiFile = getRunnableFile(e) ?: return
val fileName = psiFile.name val virtualFile = psiFile.virtualFile ?: return
FileDocumentManager.getInstance().getDocument(virtualFile)?.let { document ->
FileDocumentManager.getInstance().saveDocument(document)
}
val filePath = virtualFile.path
val workingDir = virtualFile.parent?.path ?: project.basePath ?: File(filePath).parent
val (console, toolWindow) = getConsoleAndToolWindow(project) val (console, toolWindow) = getConsoleAndToolWindow(project)
console.clear() console.clear()
toolWindow.show { toolWindow.show {
scope.launch { scope.launch {
console.print("--- Run is disabled ---\n", ConsoleViewContentType.SYSTEM_OUTPUT) val command = startLyngProcess(filePath, workingDir)
console.print("Lyng now runs in bytecode-only mode; the IDE no longer evaluates scripts.\n", ConsoleViewContentType.NORMAL_OUTPUT) if (command == null) {
console.print("Use the CLI to run scripts, e.g. `lyng run $fileName`.\n", ConsoleViewContentType.NORMAL_OUTPUT) printToConsole(console, "Unable to start Lyng CLI.\n", ConsoleViewContentType.ERROR_OUTPUT)
printToConsole(console, "Tried commands: lyng, jlyng.\n", ConsoleViewContentType.ERROR_OUTPUT)
printToConsole(console, "Install `lyng` or `jlyng` and make sure it is available on PATH.\n", ConsoleViewContentType.NORMAL_OUTPUT)
return@launch
}
printToConsole(
console,
"Running ${command.commandLine} in ${command.workingDir}\n",
ConsoleViewContentType.SYSTEM_OUTPUT
)
streamProcess(command.process, console)
val exitCode = command.process.waitFor()
val outputType = if (exitCode == 0) ConsoleViewContentType.SYSTEM_OUTPUT else ConsoleViewContentType.ERROR_OUTPUT
printToConsole(console, "\nProcess finished with exit code $exitCode\n", outputType)
} }
} }
} }
private suspend fun streamProcess(process: Process, console: ConsoleView) {
val stdout = scope.launch {
process.inputStream.bufferedReader().useLines { lines ->
lines.forEach { printToConsole(console, "$it\n", ConsoleViewContentType.NORMAL_OUTPUT) }
}
}
val stderr = scope.launch {
process.errorStream.bufferedReader().useLines { lines ->
lines.forEach { printToConsole(console, "$it\n", ConsoleViewContentType.ERROR_OUTPUT) }
}
}
stdout.join()
stderr.join()
}
private fun printToConsole(console: ConsoleView, text: String, type: ConsoleViewContentType) {
ApplicationManager.getApplication().invokeLater {
console.print(text, type)
}
}
private fun startLyngProcess(filePath: String, workingDir: String?): StartedProcess? {
val candidates = listOf("lyng", "jlyng")
for (candidate in candidates) {
try {
val process = ProcessBuilder(candidate, filePath)
.directory(workingDir?.let(::File))
.start()
return StartedProcess(process, "$candidate $filePath", workingDir ?: File(filePath).parent.orEmpty())
} catch (_: java.io.IOException) {
// Try the next candidate when the command is not available.
}
}
return null
}
private fun getConsoleAndToolWindow(project: Project): Pair<ConsoleView, ToolWindow> { private fun getConsoleAndToolWindow(project: Project): Pair<ConsoleView, ToolWindow> {
val toolWindowManager = ToolWindowManager.getInstance(project) val toolWindowManager = ToolWindowManager.getInstance(project)
var toolWindow = toolWindowManager.getToolWindow(ToolWindowId.RUN) var toolWindow = toolWindowManager.getToolWindow(ToolWindowId.RUN)
@@ -106,4 +172,10 @@ class RunLyngScriptAction : AnAction(LyngIcons.FILE) {
contentManager.setSelectedContent(content) contentManager.setSelectedContent(content)
return console to actualToolWindow return console to actualToolWindow
} }
private data class StartedProcess(
val process: Process,
val commandLine: String,
val workingDir: String
)
} }
+8 -8
View File
@@ -1,5 +1,5 @@
/* /*
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com * Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -34,11 +34,13 @@ kotlin {
// Suppress Beta warning for expect/actual classes across all targets in this module // Suppress Beta warning for expect/actual classes across all targets in this module
targets.configureEach { targets.configureEach {
compilations.configureEach { compilations.configureEach {
compilerOptions.configure { compileTaskProvider.configure {
compilerOptions {
freeCompilerArgs.add("-Xexpect-actual-classes") freeCompilerArgs.add("-Xexpect-actual-classes")
} }
} }
} }
}
jvm { jvm {
binaries { binaries {
@@ -75,19 +77,17 @@ kotlin {
implementation(libs.okio.fakefilesystem) implementation(libs.okio.fakefilesystem)
} }
} }
val nativeMain by creating {
dependsOn(commonMain)
}
val jvmTest by getting { val jvmTest by getting {
dependencies { dependencies {
implementation(kotlin("test")) implementation(kotlin("test"))
implementation(kotlin("test-junit")) implementation(kotlin("test-junit"))
} }
} }
// val nativeMain by getting {
// dependencies {
// implementation(kotlin("stdlib-common"))
// }
// }
val linuxX64Main by getting { val linuxX64Main by getting {
dependsOn(nativeMain)
} }
} }
} }
+1
View File
@@ -158,6 +158,7 @@ private class Fmt : CliktCommand(name = "fmt") {
private class Lyng(val launcher: (suspend () -> Unit) -> Unit) : CliktCommand() { private class Lyng(val launcher: (suspend () -> Unit) -> Unit) : CliktCommand() {
override val invokeWithoutSubcommand = true
override val printHelpOnEmptyArgs = true override val printHelpOnEmptyArgs = true
val version by option("-v", "--version", help = "Print version and exit").flag() val version by option("-v", "--version", help = "Print version and exit").flag()
@@ -1,5 +1,5 @@
/* /*
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com * Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -131,4 +131,18 @@ class CliFmtJvmTest {
Files.deleteIfExists(tmp) Files.deleteIfExists(tmp)
} }
} }
@Test
fun inlineExecuteWithDashXStillWorksAndPassesArgv() {
val r = runCli(
"-x",
"""println("INLINE"); println(ARGV[0]); println(ARGV[1])""",
"one",
"two"
)
assertTrue("Expected inline execution output", r.out.contains("INLINE"))
assertTrue("Expected ARGV to include first trailing arg", r.out.contains("one"))
assertTrue("Expected ARGV to include second trailing arg", r.out.contains("two"))
assertTrue("Did not expect CLI exit()", r.exitCode == null)
}
} }
+83 -2
View File
@@ -44,7 +44,6 @@ kotlin {
iosX64() iosX64()
iosArm64() iosArm64()
iosSimulatorArm64() iosSimulatorArm64()
macosX64()
macosArm64() macosArm64()
mingwX64() mingwX64()
linuxX64() linuxX64()
@@ -62,11 +61,13 @@ kotlin {
// Keep expect/actual warning suppressed consistently with other modules // Keep expect/actual warning suppressed consistently with other modules
targets.configureEach { targets.configureEach {
compilations.configureEach { compilations.configureEach {
compilerOptions.configure { compileTaskProvider.configure {
compilerOptions {
freeCompilerArgs.add("-Xexpect-actual-classes") freeCompilerArgs.add("-Xexpect-actual-classes")
} }
} }
} }
}
sourceSets { sourceSets {
all { all {
@@ -81,11 +82,33 @@ kotlin {
api(libs.mordant.core) api(libs.mordant.core)
} }
} }
val nativeMain by creating {
dependsOn(commonMain)
}
val iosMain by creating {
dependsOn(nativeMain)
}
val linuxMain by creating {
dependsOn(nativeMain)
}
val macosMain by creating {
dependsOn(nativeMain)
}
val mingwMain by creating {
dependsOn(nativeMain)
}
val commonTest by getting { val commonTest by getting {
dependencies { dependencies {
implementation(libs.kotlin.test) implementation(libs.kotlin.test)
} }
} }
val iosX64Main by getting { dependsOn(iosMain) }
val iosArm64Main by getting { dependsOn(iosMain) }
val iosSimulatorArm64Main by getting { dependsOn(iosMain) }
val macosArm64Main by getting { dependsOn(macosMain) }
val mingwX64Main by getting { dependsOn(mingwMain) }
val linuxX64Main by getting { dependsOn(linuxMain) }
val linuxArm64Main by getting { dependsOn(linuxMain) }
// JS: use runtime detection in jsMain to select Node vs Browser implementation // JS: use runtime detection in jsMain to select Node vs Browser implementation
val jsMain by getting { val jsMain by getting {
@@ -112,6 +135,64 @@ kotlin {
} }
} }
abstract class GenerateLyngioConsoleDecls : DefaultTask() {
@get:InputFile
@get:PathSensitive(PathSensitivity.RELATIVE)
abstract val sourceFile: RegularFileProperty
@get:OutputDirectory
abstract val outputDir: DirectoryProperty
@TaskAction
fun generate() {
val targetPkg = "net.sergeych.lyngio.stdlib_included"
val pkgPath = targetPkg.replace('.', '/')
val targetDir = outputDir.get().asFile.resolve(pkgPath)
targetDir.mkdirs()
val text = sourceFile.get().asFile.readText()
fun escapeForQuoted(s: String): String = buildString {
for (ch in s) when (ch) {
'\\' -> append("\\\\")
'"' -> append("\\\"")
'\n' -> append("\\n")
'\r' -> {}
'\t' -> append("\\t")
else -> append(ch)
}
}
val out = buildString {
append("package ").append(targetPkg).append("\n\n")
append("@Suppress(\"Unused\", \"MemberVisibilityCanBePrivate\")\n")
append("internal val consoleLyng = \"")
append(escapeForQuoted(text))
append("\"\n")
}
targetDir.resolve("console_types_lyng.generated.kt").writeText(out)
}
}
val lyngioConsoleDeclsFile = layout.projectDirectory.file("stdlib/lyng/io/console.lyng")
val generatedLyngioDeclsDir = layout.buildDirectory.dir("generated/source/lyngioDecls/commonMain/kotlin")
val generateLyngioConsoleDecls by tasks.registering(GenerateLyngioConsoleDecls::class) {
sourceFile.set(lyngioConsoleDeclsFile)
outputDir.set(generatedLyngioDeclsDir)
}
kotlin.sourceSets.named("commonMain") {
kotlin.srcDir(generateLyngioConsoleDecls)
}
kotlin.targets.configureEach {
compilations.configureEach {
compileTaskProvider.configure {
dependsOn(generateLyngioConsoleDecls)
}
}
}
android { android {
namespace = "net.sergeych.lyngio" namespace = "net.sergeych.lyngio"
compileSdk = libs.versions.android.compileSdk.get().toInt() compileSdk = libs.versions.android.compileSdk.get().toInt()
@@ -20,9 +20,11 @@ package net.sergeych.lyng.io.console
import net.sergeych.lyng.ModuleScope import net.sergeych.lyng.ModuleScope
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.ScopeFacade import net.sergeych.lyng.ScopeFacade
import net.sergeych.lyng.miniast.* import net.sergeych.lyng.Source
import net.sergeych.lyng.obj.Obj import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjBool import net.sergeych.lyng.obj.ObjBool
import net.sergeych.lyng.obj.ObjEnumClass
import net.sergeych.lyng.obj.ObjEnumEntry
import net.sergeych.lyng.obj.ObjIterable import net.sergeych.lyng.obj.ObjIterable
import net.sergeych.lyng.obj.ObjIterationFinishedException import net.sergeych.lyng.obj.ObjIterationFinishedException
import net.sergeych.lyng.obj.ObjIterator import net.sergeych.lyng.obj.ObjIterator
@@ -35,13 +37,13 @@ import net.sergeych.lyng.obj.toObj
import net.sergeych.lyng.pacman.ImportManager import net.sergeych.lyng.pacman.ImportManager
import net.sergeych.lyng.raiseIllegalOperation import net.sergeych.lyng.raiseIllegalOperation
import net.sergeych.lyng.requireScope import net.sergeych.lyng.requireScope
import net.sergeych.lyngio.console.ConsoleEvent import net.sergeych.lyngio.console.*
import net.sergeych.lyngio.console.ConsoleEventSource
import net.sergeych.lyngio.console.LyngConsole
import net.sergeych.lyngio.console.getSystemConsole
import net.sergeych.lyngio.console.security.ConsoleAccessDeniedException import net.sergeych.lyngio.console.security.ConsoleAccessDeniedException
import net.sergeych.lyngio.console.security.ConsoleAccessPolicy import net.sergeych.lyngio.console.security.ConsoleAccessPolicy
import net.sergeych.lyngio.console.security.LyngConsoleSecured import net.sergeych.lyngio.console.security.LyngConsoleSecured
import net.sergeych.lyngio.stdlib_included.consoleLyng
private const val CONSOLE_MODULE_NAME = "lyng.io.console"
/** /**
* Install Lyng module `lyng.io.console` into the given scope's ImportManager. * Install Lyng module `lyng.io.console` into the given scope's ImportManager.
@@ -53,10 +55,9 @@ fun createConsole(policy: ConsoleAccessPolicy, scope: Scope): Boolean = createCo
/** Same as [createConsoleModule] but with explicit [ImportManager]. */ /** Same as [createConsoleModule] but with explicit [ImportManager]. */
fun createConsoleModule(policy: ConsoleAccessPolicy, manager: ImportManager): Boolean { fun createConsoleModule(policy: ConsoleAccessPolicy, manager: ImportManager): Boolean {
val name = "lyng.io.console" if (manager.packageNames.contains(CONSOLE_MODULE_NAME)) return false
if (manager.packageNames.contains(name)) return false
manager.addPackage(name) { module -> manager.addPackage(CONSOLE_MODULE_NAME) { module ->
buildConsoleModule(module, policy) buildConsoleModule(module, policy)
} }
return true return true
@@ -65,59 +66,37 @@ fun createConsoleModule(policy: ConsoleAccessPolicy, manager: ImportManager): Bo
fun createConsole(policy: ConsoleAccessPolicy, manager: ImportManager): Boolean = createConsoleModule(policy, manager) fun createConsole(policy: ConsoleAccessPolicy, manager: ImportManager): Boolean = createConsoleModule(policy, manager)
private suspend fun buildConsoleModule(module: ModuleScope, policy: ConsoleAccessPolicy) { private suspend fun buildConsoleModule(module: ModuleScope, policy: ConsoleAccessPolicy) {
// Load Lyng declarations for console enums/types first (module-local source of truth).
module.eval(Source(CONSOLE_MODULE_NAME, consoleLyng))
ConsoleEnums.initialize(module)
val console: LyngConsole = LyngConsoleSecured(getSystemConsole(), policy) val console: LyngConsole = LyngConsoleSecured(getSystemConsole(), policy)
val consoleType = object : net.sergeych.lyng.obj.ObjClass("Console") {} val consoleType = object : net.sergeych.lyng.obj.ObjClass("Console") {}
consoleType.apply { consoleType.apply {
addClassFnDoc( addClassFn("isSupported") {
name = "isSupported",
doc = "Whether console control API is supported on this platform.",
returns = type("lyng.Bool"),
moduleName = module.packageName
) {
ObjBool(console.isSupported) ObjBool(console.isSupported)
} }
addClassFnDoc( addClassFn("isTty") {
name = "isTty",
doc = "Whether current stdout is attached to an interactive TTY.",
returns = type("lyng.Bool"),
moduleName = module.packageName
) {
consoleGuard { consoleGuard {
ObjBool(console.isTty()) ObjBool(console.isTty())
} }
} }
addClassFnDoc( addClassFn("ansiLevel") {
name = "ansiLevel",
doc = "Detected ANSI color capability: NONE, BASIC16, ANSI256, TRUECOLOR.",
returns = type("lyng.String"),
moduleName = module.packageName
) {
consoleGuard { consoleGuard {
ObjString(console.ansiLevel().name) ConsoleEnums.ansiLevel(console.ansiLevel().name)
} }
} }
addClassFnDoc( addClassFn("geometry") {
name = "geometry",
doc = "Current terminal geometry or null.",
returns = type("ConsoleGeometry", nullable = true),
moduleName = module.packageName
) {
consoleGuard { consoleGuard {
console.geometry()?.let { ObjConsoleGeometry(it.columns, it.rows) } ?: ObjNull console.geometry()?.let { ObjConsoleGeometry(it.columns, it.rows) } ?: ObjNull
} }
} }
addClassFnDoc( addClassFn("details") {
name = "details",
doc = "Get consolidated console details.",
returns = type("ConsoleDetails"),
moduleName = module.packageName
) {
consoleGuard { consoleGuard {
val tty = console.isTty() val tty = console.isTty()
val ansi = console.ansiLevel() val ansi = console.ansiLevel()
@@ -125,18 +104,13 @@ private suspend fun buildConsoleModule(module: ModuleScope, policy: ConsoleAcces
ObjConsoleDetails( ObjConsoleDetails(
supported = console.isSupported, supported = console.isSupported,
isTty = tty, isTty = tty,
ansiLevel = ansi.name, ansiLevel = ConsoleEnums.ansiLevel(ansi.name),
geometry = geometry?.let { ObjConsoleGeometry(it.columns, it.rows) }, geometry = geometry?.let { ObjConsoleGeometry(it.columns, it.rows) },
) )
} }
} }
addClassFnDoc( addClassFn("write") {
name = "write",
doc = "Write text directly to console output.",
params = listOf(ParamDoc("text", type("lyng.String"))),
moduleName = module.packageName
) {
consoleGuard { consoleGuard {
val text = requiredArg<ObjString>(0).value val text = requiredArg<ObjString>(0).value
console.write(text) console.write(text)
@@ -144,48 +118,28 @@ private suspend fun buildConsoleModule(module: ModuleScope, policy: ConsoleAcces
} }
} }
addClassFnDoc( addClassFn("flush") {
name = "flush",
doc = "Flush console output buffer.",
moduleName = module.packageName
) {
consoleGuard { consoleGuard {
console.flush() console.flush()
ObjVoid ObjVoid
} }
} }
addClassFnDoc( addClassFn("home") {
name = "home",
doc = "Move cursor to home position (1,1).",
moduleName = module.packageName
) {
consoleGuard { consoleGuard {
console.write("\u001B[H") console.write("\u001B[H")
ObjVoid ObjVoid
} }
} }
addClassFnDoc( addClassFn("clear") {
name = "clear",
doc = "Clear the visible screen buffer.",
moduleName = module.packageName
) {
consoleGuard { consoleGuard {
console.write("\u001B[2J") console.write("\u001B[2J")
ObjVoid ObjVoid
} }
} }
addClassFnDoc( addClassFn("moveTo") {
name = "moveTo",
doc = "Move cursor to 1-based row and column.",
params = listOf(
ParamDoc("row", type("lyng.Int")),
ParamDoc("column", type("lyng.Int")),
),
moduleName = module.packageName
) {
consoleGuard { consoleGuard {
val row = requiredArg<net.sergeych.lyng.obj.ObjInt>(0).value val row = requiredArg<net.sergeych.lyng.obj.ObjInt>(0).value
val col = requiredArg<net.sergeych.lyng.obj.ObjInt>(1).value val col = requiredArg<net.sergeych.lyng.obj.ObjInt>(1).value
@@ -194,45 +148,28 @@ private suspend fun buildConsoleModule(module: ModuleScope, policy: ConsoleAcces
} }
} }
addClassFnDoc( addClassFn("clearLine") {
name = "clearLine",
doc = "Clear the current line.",
moduleName = module.packageName
) {
consoleGuard { consoleGuard {
console.write("\u001B[2K") console.write("\u001B[2K")
ObjVoid ObjVoid
} }
} }
addClassFnDoc( addClassFn("enterAltScreen") {
name = "enterAltScreen",
doc = "Switch to terminal alternate screen buffer.",
moduleName = module.packageName
) {
consoleGuard { consoleGuard {
console.write("\u001B[?1049h") console.write("\u001B[?1049h")
ObjVoid ObjVoid
} }
} }
addClassFnDoc( addClassFn("leaveAltScreen") {
name = "leaveAltScreen",
doc = "Return from alternate screen buffer to normal screen.",
moduleName = module.packageName
) {
consoleGuard { consoleGuard {
console.write("\u001B[?1049l") console.write("\u001B[?1049l")
ObjVoid ObjVoid
} }
} }
addClassFnDoc( addClassFn("setCursorVisible") {
name = "setCursorVisible",
doc = "Show or hide the terminal cursor.",
params = listOf(ParamDoc("visible", type("lyng.Bool"))),
moduleName = module.packageName
) {
consoleGuard { consoleGuard {
val visible = requiredArg<ObjBool>(0).value val visible = requiredArg<ObjBool>(0).value
console.write(if (visible) "\u001B[?25h" else "\u001B[?25l") console.write(if (visible) "\u001B[?25h" else "\u001B[?25l")
@@ -240,24 +177,13 @@ private suspend fun buildConsoleModule(module: ModuleScope, policy: ConsoleAcces
} }
} }
addClassFnDoc( addClassFn("events") {
name = "events",
doc = "Endless iterable console event source (resize, keydown, keyup). Use in a loop, often inside launch.",
returns = type("ConsoleEventStream"),
moduleName = module.packageName
) {
consoleGuard { consoleGuard {
console.events().toConsoleEventStream() console.events().toConsoleEventStream()
} }
} }
addClassFnDoc( addClassFn("setRawMode") {
name = "setRawMode",
doc = "Enable or disable raw keyboard mode. Returns true if mode changed.",
params = listOf(ParamDoc("enabled", type("lyng.Bool"))),
returns = type("lyng.Bool"),
moduleName = module.packageName
) {
consoleGuard { consoleGuard {
val enabled = requiredArg<ObjBool>(0).value val enabled = requiredArg<ObjBool>(0).value
ObjBool(console.setRawMode(enabled)) ObjBool(console.setRawMode(enabled))
@@ -265,55 +191,13 @@ private suspend fun buildConsoleModule(module: ModuleScope, policy: ConsoleAcces
} }
} }
module.addConstDoc( module.addConst("Console", consoleType)
name = "Console", module.addConst("ConsoleGeometry", ObjConsoleGeometry.type)
value = consoleType, module.addConst("ConsoleDetails", ObjConsoleDetails.type)
doc = "Console runtime API.", module.addConst("ConsoleEvent", ObjConsoleEvent.type)
type = type("Console"), module.addConst("ConsoleResizeEvent", ObjConsoleResizeEvent.type)
moduleName = module.packageName module.addConst("ConsoleKeyEvent", ObjConsoleKeyEvent.typeObj)
) module.addConst("ConsoleEventStream", ObjConsoleEventStream.type)
module.addConstDoc(
name = "ConsoleGeometry",
value = ObjConsoleGeometry.type,
doc = "Terminal geometry.",
type = type("lyng.Class"),
moduleName = module.packageName
)
module.addConstDoc(
name = "ConsoleDetails",
value = ObjConsoleDetails.type,
doc = "Consolidated console capability details.",
type = type("lyng.Class"),
moduleName = module.packageName
)
module.addConstDoc(
name = "ConsoleEvent",
value = ObjConsoleEvent.type,
doc = "Base class for console events.",
type = type("lyng.Class"),
moduleName = module.packageName
)
module.addConstDoc(
name = "ConsoleResizeEvent",
value = ObjConsoleResizeEvent.type,
doc = "Terminal resize event.",
type = type("lyng.Class"),
moduleName = module.packageName
)
module.addConstDoc(
name = "ConsoleKeyEvent",
value = ObjConsoleKeyEvent.typeObj,
doc = "Keyboard event.",
type = type("lyng.Class"),
moduleName = module.packageName
)
module.addConstDoc(
name = "ConsoleEventStream",
value = ObjConsoleEventStream.type,
doc = "Endless iterable stream of console events.",
type = type("lyng.Class"),
moduleName = module.packageName
)
} }
private suspend inline fun ScopeFacade.consoleGuard(crossinline block: suspend () -> Obj): Obj { private suspend inline fun ScopeFacade.consoleGuard(crossinline block: suspend () -> Obj): Obj {
@@ -338,12 +222,7 @@ private class ObjConsoleEventStream(
companion object { companion object {
val type = net.sergeych.lyng.obj.ObjClass("ConsoleEventStream", ObjIterable).apply { val type = net.sergeych.lyng.obj.ObjClass("ConsoleEventStream", ObjIterable).apply {
addFnDoc( addFn("iterator") {
name = "iterator",
doc = "Create an iterator over incoming console events.",
returns = type("lyng.Iterator"),
moduleName = "lyng.io.console",
) {
val stream = thisAs<ObjConsoleEventStream>() val stream = thisAs<ObjConsoleEventStream>()
ObjConsoleEventIterator(stream.source) ObjConsoleEventIterator(stream.source)
} }
@@ -363,19 +242,36 @@ private class ObjConsoleEventIterator(
private suspend fun ensureCached(): Boolean { private suspend fun ensureCached(): Boolean {
if (closed) return false if (closed) return false
if (cached != null) return true if (cached != null) return true
val event = source.nextEvent() while (!closed && cached == null) {
val event = try {
source.nextEvent()
} catch (e: Throwable) {
// Consumer loops must survive source/read failures: report and keep polling.
consoleFlowDebug("console-bridge: nextEvent failed; dropping failure and continuing", e)
continue
}
if (event == null) { if (event == null) {
closeSource() closeSource()
return false return false
} }
cached = event.toObjEvent() cached = try {
return true event.toObjEvent()
} catch (e: Throwable) {
// Malformed/native event payload must not terminate consumer iteration.
consoleFlowDebug("console-bridge: malformed event dropped: $event", e)
null
}
}
return cached != null
} }
private suspend fun closeSource() { private suspend fun closeSource() {
if (closed) return if (closed) return
closed = true closed = true
source.close() // Do not close the underlying console source from VM iterator cancellation.
// CmdFrame.cancelIterators() may call cancelIteration() while user code is still
// expected to keep processing input (e.g. recover from app-level exceptions).
// The source lifecycle is managed by the console runtime.
} }
suspend fun hasNext(): Boolean = ensureCached() suspend fun hasNext(): Boolean = ensureCached()
@@ -391,28 +287,13 @@ private class ObjConsoleEventIterator(
companion object { companion object {
val type = net.sergeych.lyng.obj.ObjClass("ConsoleEventIterator", ObjIterator).apply { val type = net.sergeych.lyng.obj.ObjClass("ConsoleEventIterator", ObjIterator).apply {
addFnDoc( addFn("hasNext") {
name = "hasNext",
doc = "Whether another console event is available.",
returns = type("lyng.Bool"),
moduleName = "lyng.io.console",
) {
thisAs<ObjConsoleEventIterator>().hasNext().toObj() thisAs<ObjConsoleEventIterator>().hasNext().toObj()
} }
addFnDoc( addFn("next") {
name = "next",
doc = "Return the next console event.",
returns = type("ConsoleEvent"),
moduleName = "lyng.io.console",
) {
thisAs<ObjConsoleEventIterator>().next(requireScope()) thisAs<ObjConsoleEventIterator>().next(requireScope())
} }
addFnDoc( addFn("cancelIteration") {
name = "cancelIteration",
doc = "Stop reading console events and release resources.",
returns = type("lyng.Void"),
moduleName = "lyng.io.console",
) {
thisAs<ObjConsoleEventIterator>().closeSource() thisAs<ObjConsoleEventIterator>().closeSource()
ObjVoid ObjVoid
} }
@@ -422,27 +303,119 @@ private class ObjConsoleEventIterator(
private fun ConsoleEvent.toObjEvent(): Obj = when (this) { private fun ConsoleEvent.toObjEvent(): Obj = when (this) {
is ConsoleEvent.Resize -> ObjConsoleResizeEvent(columns, rows) is ConsoleEvent.Resize -> ObjConsoleResizeEvent(columns, rows)
is ConsoleEvent.KeyDown -> ObjConsoleKeyEvent(type = "keydown", key = key, code = code, ctrl = ctrl, alt = alt, shift = shift, meta = meta) is ConsoleEvent.KeyDown -> ObjConsoleKeyEvent(type = ConsoleEnums.KEY_DOWN, key = sanitizedKeyOrFallback(key), codeName = code, ctrl = ctrl, alt = alt, shift = shift, meta = meta)
is ConsoleEvent.KeyUp -> ObjConsoleKeyEvent(type = "keyup", key = key, code = code, ctrl = ctrl, alt = alt, shift = shift, meta = meta) is ConsoleEvent.KeyUp -> ObjConsoleKeyEvent(type = ConsoleEnums.KEY_UP, key = sanitizedKeyOrFallback(key), codeName = code, ctrl = ctrl, alt = alt, shift = shift, meta = meta)
}
private fun sanitizedKeyOrFallback(key: String): String {
if (key.isNotEmpty()) return key
consoleFlowDebug("console-bridge: empty key value received; using fallback key name")
return "Unknown"
}
private object ConsoleEnums {
lateinit var eventTypeClass: ObjEnumClass
private set
lateinit var keyCodeClass: ObjEnumClass
private set
lateinit var ansiLevelClass: ObjEnumClass
private set
private lateinit var eventEntries: Map<String, ObjEnumEntry>
private lateinit var keyCodeEntries: Map<String, ObjEnumEntry>
private lateinit var ansiLevelEntries: Map<String, ObjEnumEntry>
val UNKNOWN: ObjEnumEntry get() = event("UNKNOWN")
val RESIZE: ObjEnumEntry get() = event("RESIZE")
val KEY_DOWN: ObjEnumEntry get() = event("KEY_DOWN")
val KEY_UP: ObjEnumEntry get() = event("KEY_UP")
val CODE_UNKNOWN: ObjEnumEntry get() = code("UNKNOWN")
val CHARACTER: ObjEnumEntry get() = code("CHARACTER")
fun initialize(module: ModuleScope) {
eventTypeClass = resolveEnum(module, "ConsoleEventType")
keyCodeClass = resolveEnum(module, "ConsoleKeyCode")
ansiLevelClass = resolveEnum(module, "ConsoleAnsiLevel")
eventEntries = resolveEntries(
eventTypeClass,
listOf("UNKNOWN", "RESIZE", "KEY_DOWN", "KEY_UP")
)
keyCodeEntries = resolveEntries(
keyCodeClass,
listOf(
"UNKNOWN", "CHARACTER", "ARROW_UP", "ARROW_DOWN", "ARROW_LEFT", "ARROW_RIGHT",
"HOME", "END", "INSERT", "DELETE", "PAGE_UP", "PAGE_DOWN",
"ESCAPE", "ENTER", "TAB", "BACKSPACE", "SPACE"
)
)
ansiLevelEntries = resolveEntries(
ansiLevelClass,
listOf("NONE", "BASIC16", "ANSI256", "TRUECOLOR")
)
}
private fun resolveEnum(module: ModuleScope, enumName: String): ObjEnumClass {
val local = module.get(enumName)?.value as? ObjEnumClass
if (local != null) return local
val root = module.importProvider.rootScope.get(enumName)?.value as? ObjEnumClass
return root ?: error("lyng.io.console declaration enum is missing: $enumName")
}
private fun resolveEntries(enumClass: ObjEnumClass, names: List<String>): Map<String, ObjEnumEntry> {
return names.associateWith { name ->
(enumClass.byName[ObjString(name)] as? ObjEnumEntry)
?: error("lyng.io.console enum entry is missing: ${enumClass.className}.$name")
}
}
fun event(name: String): ObjEnumEntry = eventEntries[name]
?: error("lyng.io.console enum entry is missing: ${eventTypeClass.className}.$name")
fun code(name: String): ObjEnumEntry = keyCodeEntries[name]
?: error("lyng.io.console enum entry is missing: ${keyCodeClass.className}.$name")
fun ansiLevel(name: String): ObjEnumEntry = ansiLevelEntries[name]
?: error("lyng.io.console enum entry is missing: ${ansiLevelClass.className}.$name")
}
private val KEY_CODE_BY_KEY_NAME = mapOf(
"ArrowUp" to "ARROW_UP",
"ArrowDown" to "ARROW_DOWN",
"ArrowLeft" to "ARROW_LEFT",
"ArrowRight" to "ARROW_RIGHT",
"Home" to "HOME",
"End" to "END",
"Insert" to "INSERT",
"Delete" to "DELETE",
"PageUp" to "PAGE_UP",
"PageDown" to "PAGE_DOWN",
"Escape" to "ESCAPE",
"Enter" to "ENTER",
"Tab" to "TAB",
"Backspace" to "BACKSPACE",
" " to "SPACE",
)
private fun codeFrom(key: String, codeName: String?): ObjEnumEntry {
val resolved = KEY_CODE_BY_KEY_NAME[codeName ?: key]
return when {
resolved != null -> ConsoleEnums.code(resolved)
key.length == 1 -> ConsoleEnums.CHARACTER
else -> ConsoleEnums.CODE_UNKNOWN
}
} }
private abstract class ObjConsoleEventBase( private abstract class ObjConsoleEventBase(
private val eventType: String, private val type: ObjEnumEntry,
final override val objClass: net.sergeych.lyng.obj.ObjClass, final override val objClass: net.sergeych.lyng.obj.ObjClass,
) : Obj() { ) : Obj() {
fun eventTypeName(): String = eventType fun type(): ObjEnumEntry = type
} }
private class ObjConsoleEvent : ObjConsoleEventBase("event", type) { private class ObjConsoleEvent : ObjConsoleEventBase(ConsoleEnums.UNKNOWN, type) {
companion object { companion object {
val type = net.sergeych.lyng.obj.ObjClass("ConsoleEvent").apply { val type = net.sergeych.lyng.obj.ObjClass("ConsoleEvent").apply {
addPropertyDoc( addProperty(name = "type", getter = { (this.thisObj as ObjConsoleEventBase).type() })
name = "type",
doc = "Event type string: resize, keydown, keyup.",
type = type("lyng.String"),
moduleName = "lyng.io.console",
getter = { ObjString((this.thisObj as ObjConsoleEventBase).eventTypeName()) }
)
} }
} }
} }
@@ -450,83 +423,40 @@ private class ObjConsoleEvent : ObjConsoleEventBase("event", type) {
private class ObjConsoleResizeEvent( private class ObjConsoleResizeEvent(
val columns: Int, val columns: Int,
val rows: Int, val rows: Int,
) : ObjConsoleEventBase("resize", type) { ) : ObjConsoleEventBase(ConsoleEnums.RESIZE, type) {
companion object { companion object {
val type = net.sergeych.lyng.obj.ObjClass("ConsoleResizeEvent", ObjConsoleEvent.type).apply { val type = net.sergeych.lyng.obj.ObjClass("ConsoleResizeEvent", ObjConsoleEvent.type).apply {
addPropertyDoc( addProperty(name = "columns", getter = { (this.thisObj as ObjConsoleResizeEvent).columns.toObj() })
name = "columns", addProperty(name = "rows", getter = { (this.thisObj as ObjConsoleResizeEvent).rows.toObj() })
doc = "Terminal width in character cells.",
type = type("lyng.Int"),
moduleName = "lyng.io.console",
getter = { (this.thisObj as ObjConsoleResizeEvent).columns.toObj() }
)
addPropertyDoc(
name = "rows",
doc = "Terminal height in character cells.",
type = type("lyng.Int"),
moduleName = "lyng.io.console",
getter = { (this.thisObj as ObjConsoleResizeEvent).rows.toObj() }
)
} }
} }
} }
private class ObjConsoleKeyEvent( private class ObjConsoleKeyEvent(
type: String, type: ObjEnumEntry,
val key: String, val key: String,
val code: String?, val codeName: String?,
val ctrl: Boolean, val ctrl: Boolean,
val alt: Boolean, val alt: Boolean,
val shift: Boolean, val shift: Boolean,
val meta: Boolean, val meta: Boolean,
) : ObjConsoleEventBase(type, typeObj) { ) : ObjConsoleEventBase(type, typeObj) {
init {
require(key.isNotEmpty()) { "ConsoleKeyEvent.key must never be empty" }
}
companion object { companion object {
val typeObj = net.sergeych.lyng.obj.ObjClass("ConsoleKeyEvent", ObjConsoleEvent.type).apply { val typeObj = net.sergeych.lyng.obj.ObjClass("ConsoleKeyEvent", ObjConsoleEvent.type).apply {
addPropertyDoc( addProperty(name = "key", getter = { ObjString((this.thisObj as ObjConsoleKeyEvent).key) })
name = "key", addProperty(name = "code", getter = { codeFrom((this.thisObj as ObjConsoleKeyEvent).key, (this.thisObj as ObjConsoleKeyEvent).codeName) })
doc = "Logical key name (e.g. ArrowLeft, a, Escape).", addProperty(name = "codeName", getter = {
type = type("lyng.String"), val code = (this.thisObj as ObjConsoleKeyEvent).codeName
moduleName = "lyng.io.console",
getter = { ObjString((this.thisObj as ObjConsoleKeyEvent).key) }
)
addPropertyDoc(
name = "code",
doc = "Optional hardware/code identifier.",
type = type("lyng.String", nullable = true),
moduleName = "lyng.io.console",
getter = {
val code = (this.thisObj as ObjConsoleKeyEvent).code
code?.let(::ObjString) ?: ObjNull code?.let(::ObjString) ?: ObjNull
} })
) addProperty(name = "ctrl", getter = { (this.thisObj as ObjConsoleKeyEvent).ctrl.toObj() })
addPropertyDoc( addProperty(name = "alt", getter = { (this.thisObj as ObjConsoleKeyEvent).alt.toObj() })
name = "ctrl", addProperty(name = "shift", getter = { (this.thisObj as ObjConsoleKeyEvent).shift.toObj() })
doc = "Whether Ctrl modifier is pressed.", addProperty(name = "meta", getter = { (this.thisObj as ObjConsoleKeyEvent).meta.toObj() })
type = type("lyng.Bool"),
moduleName = "lyng.io.console",
getter = { (this.thisObj as ObjConsoleKeyEvent).ctrl.toObj() }
)
addPropertyDoc(
name = "alt",
doc = "Whether Alt modifier is pressed.",
type = type("lyng.Bool"),
moduleName = "lyng.io.console",
getter = { (this.thisObj as ObjConsoleKeyEvent).alt.toObj() }
)
addPropertyDoc(
name = "shift",
doc = "Whether Shift modifier is pressed.",
type = type("lyng.Bool"),
moduleName = "lyng.io.console",
getter = { (this.thisObj as ObjConsoleKeyEvent).shift.toObj() }
)
addPropertyDoc(
name = "meta",
doc = "Whether Meta/Super modifier is pressed.",
type = type("lyng.Bool"),
moduleName = "lyng.io.console",
getter = { (this.thisObj as ObjConsoleKeyEvent).meta.toObj() }
)
} }
} }
} }
@@ -539,20 +469,8 @@ private class ObjConsoleGeometry(
companion object { companion object {
val type = net.sergeych.lyng.obj.ObjClass("ConsoleGeometry").apply { val type = net.sergeych.lyng.obj.ObjClass("ConsoleGeometry").apply {
addPropertyDoc( addProperty(name = "columns", getter = { (this.thisObj as ObjConsoleGeometry).columns.toObj() })
name = "columns", addProperty(name = "rows", getter = { (this.thisObj as ObjConsoleGeometry).rows.toObj() })
doc = "Terminal width in character cells.",
type = type("lyng.Int"),
moduleName = "lyng.io.console",
getter = { (this.thisObj as ObjConsoleGeometry).columns.toObj() }
)
addPropertyDoc(
name = "rows",
doc = "Terminal height in character cells.",
type = type("lyng.Int"),
moduleName = "lyng.io.console",
getter = { (this.thisObj as ObjConsoleGeometry).rows.toObj() }
)
} }
} }
} }
@@ -560,41 +478,17 @@ private class ObjConsoleGeometry(
private class ObjConsoleDetails( private class ObjConsoleDetails(
val supported: Boolean, val supported: Boolean,
val isTty: Boolean, val isTty: Boolean,
val ansiLevel: String, val ansiLevel: ObjEnumEntry,
val geometry: ObjConsoleGeometry?, val geometry: ObjConsoleGeometry?,
) : Obj() { ) : Obj() {
override val objClass: net.sergeych.lyng.obj.ObjClass get() = type override val objClass: net.sergeych.lyng.obj.ObjClass get() = type
companion object { companion object {
val type = net.sergeych.lyng.obj.ObjClass("ConsoleDetails").apply { val type = net.sergeych.lyng.obj.ObjClass("ConsoleDetails").apply {
addPropertyDoc( addProperty(name = "supported", getter = { (this.thisObj as ObjConsoleDetails).supported.toObj() })
name = "supported", addProperty(name = "isTty", getter = { (this.thisObj as ObjConsoleDetails).isTty.toObj() })
doc = "Whether console API is supported.", addProperty(name = "ansiLevel", getter = { (this.thisObj as ObjConsoleDetails).ansiLevel })
type = type("lyng.Bool"), addProperty(name = "geometry", getter = { (this.thisObj as ObjConsoleDetails).geometry ?: ObjNull })
moduleName = "lyng.io.console",
getter = { (this.thisObj as ObjConsoleDetails).supported.toObj() }
)
addPropertyDoc(
name = "isTty",
doc = "Whether output is connected to a TTY.",
type = type("lyng.Bool"),
moduleName = "lyng.io.console",
getter = { (this.thisObj as ObjConsoleDetails).isTty.toObj() }
)
addPropertyDoc(
name = "ansiLevel",
doc = "Detected ANSI color capability level.",
type = type("lyng.String"),
moduleName = "lyng.io.console",
getter = { ObjString((this.thisObj as ObjConsoleDetails).ansiLevel) }
)
addPropertyDoc(
name = "geometry",
doc = "Current terminal geometry or null.",
type = type("ConsoleGeometry", nullable = true),
moduleName = "lyng.io.console",
getter = { (this.thisObj as ObjConsoleDetails).geometry ?: ObjNull }
)
} }
} }
} }
@@ -100,8 +100,9 @@ object MordantLyngConsole : LyngConsole {
var running = true var running = true
globalLaunch { globalLaunch {
var lastWidth = t.updateSize().width val initialSize = runCatching { t.updateSize() }.getOrNull()
var lastHeight = t.updateSize().height var lastWidth = initialSize?.width ?: 0
var lastHeight = initialSize?.height ?: 0
val startMark = TimeSource.Monotonic.markNow() val startMark = TimeSource.Monotonic.markNow()
var lastHeartbeatMark = startMark var lastHeartbeatMark = startMark
var loops = 0L var loops = 0L
@@ -113,6 +114,18 @@ object MordantLyngConsole : LyngConsole {
var lastKeyMark = startMark var lastKeyMark = startMark
var lastRawRecoveryMark = startMark var lastRawRecoveryMark = startMark
fun tryEmitResize(width: Int, height: Int) {
if (width < 1 || height < 1) {
consoleFlowDebug("events: ignored invalid resize width=$width height=$height")
return
}
if (width == lastWidth && height == lastHeight) return
out.trySend(ConsoleEvent.Resize(width, height))
lastWidth = width
lastHeight = height
resizeEvents += 1
}
consoleFlowDebug("events: collector started") consoleFlowDebug("events: collector started")
try { try {
while (currentCoroutineContext().isActive && sourceState.withLock { running }) { while (currentCoroutineContext().isActive && sourceState.withLock { running }) {
@@ -122,12 +135,7 @@ object MordantLyngConsole : LyngConsole {
delay(150) delay(150)
continue continue
} }
if (currentSize.width != lastWidth || currentSize.height != lastHeight) { tryEmitResize(currentSize.width, currentSize.height)
out.trySend(ConsoleEvent.Resize(currentSize.width, currentSize.height))
lastWidth = currentSize.width
lastHeight = currentSize.height
resizeEvents += 1
}
val raw = stateMutex.withLock { val raw = stateMutex.withLock {
if (!rawModeRequested) { if (!rawModeRequested) {
@@ -173,10 +181,8 @@ object MordantLyngConsole : LyngConsole {
val ev = readResult.getOrNull() val ev = readResult.getOrNull()
val resized = runCatching { t.updateSize() }.getOrNull() val resized = runCatching { t.updateSize() }.getOrNull()
if (resized != null && (resized.width != lastWidth || resized.height != lastHeight)) { if (resized != null) {
out.trySend(ConsoleEvent.Resize(resized.width, resized.height)) tryEmitResize(resized.width, resized.height)
lastWidth = resized.width
lastHeight = resized.height
} }
when (ev) { when (ev) {
@@ -17,248 +17,12 @@
package net.sergeych.lyngio.docs package net.sergeych.lyngio.docs
import net.sergeych.lyng.miniast.BuiltinDocRegistry /**
import net.sergeych.lyng.miniast.ParamDoc * Console docs are declared in `lyngio/stdlib/lyng/io/console.lyng`.
import net.sergeych.lyng.miniast.type * Keep this shim for compatibility with reflective loaders.
*/
object ConsoleBuiltinDocs { object ConsoleBuiltinDocs {
private var registered = false
fun ensure() { fun ensure() {
if (registered) return // No Kotlin-side doc registration: console.lyng is the source of truth.
BuiltinDocRegistry.module("lyng.io.console") {
classDoc(
name = "Console",
doc = "Console runtime API."
) {
method(
name = "isSupported",
doc = "Whether console control API is supported on this platform.",
returns = type("lyng.Bool"),
isStatic = true
)
method(
name = "isTty",
doc = "Whether stdout is attached to an interactive TTY.",
returns = type("lyng.Bool"),
isStatic = true
)
method(
name = "ansiLevel",
doc = "Detected ANSI color capability: NONE, BASIC16, ANSI256, TRUECOLOR.",
returns = type("lyng.String"),
isStatic = true
)
method(
name = "geometry",
doc = "Current terminal geometry or null.",
returns = type("ConsoleGeometry", nullable = true),
isStatic = true
)
method(
name = "details",
doc = "Get consolidated console details.",
returns = type("ConsoleDetails"),
isStatic = true
)
method(
name = "write",
doc = "Write text directly to console output.",
params = listOf(ParamDoc("text", type("lyng.String"))),
isStatic = true
)
method(
name = "flush",
doc = "Flush console output buffer.",
isStatic = true
)
method(
name = "home",
doc = "Move cursor to home position (1,1).",
isStatic = true
)
method(
name = "clear",
doc = "Clear the visible screen buffer.",
isStatic = true
)
method(
name = "moveTo",
doc = "Move cursor to 1-based row and column.",
params = listOf(
ParamDoc("row", type("lyng.Int")),
ParamDoc("column", type("lyng.Int")),
),
isStatic = true
)
method(
name = "clearLine",
doc = "Clear the current line.",
isStatic = true
)
method(
name = "enterAltScreen",
doc = "Switch to terminal alternate screen buffer.",
isStatic = true
)
method(
name = "leaveAltScreen",
doc = "Return from alternate screen buffer to normal screen.",
isStatic = true
)
method(
name = "setCursorVisible",
doc = "Show or hide the terminal cursor.",
params = listOf(ParamDoc("visible", type("lyng.Bool"))),
isStatic = true
)
method(
name = "events",
doc = "Endless iterable console event source (resize, keydown, keyup). Use in a loop, often inside launch.",
returns = type("ConsoleEventStream"),
isStatic = true
)
method(
name = "setRawMode",
doc = "Enable or disable raw keyboard mode. Returns true if mode changed.",
params = listOf(ParamDoc("enabled", type("lyng.Bool"))),
returns = type("lyng.Bool"),
isStatic = true
)
}
classDoc(
name = "ConsoleEventStream",
doc = "Endless iterable stream of console events."
) {
method(
name = "iterator",
doc = "Create an iterator over incoming console events.",
returns = type("lyng.Iterator")
)
}
classDoc(
name = "ConsoleGeometry",
doc = "Terminal geometry."
) {
field(
name = "columns",
doc = "Terminal width in character cells.",
type = type("lyng.Int")
)
field(
name = "rows",
doc = "Terminal height in character cells.",
type = type("lyng.Int")
)
}
classDoc(
name = "ConsoleDetails",
doc = "Consolidated console capability details."
) {
field(
name = "supported",
doc = "Whether console API is supported.",
type = type("lyng.Bool")
)
field(
name = "isTty",
doc = "Whether output is attached to a TTY.",
type = type("lyng.Bool")
)
field(
name = "ansiLevel",
doc = "Detected ANSI color capability.",
type = type("lyng.String")
)
field(
name = "geometry",
doc = "Current geometry or null.",
type = type("ConsoleGeometry", nullable = true)
)
}
classDoc(
name = "ConsoleEvent",
doc = "Base class for console events."
) {
field(
name = "type",
doc = "Event kind string.",
type = type("lyng.String")
)
}
classDoc(
name = "ConsoleResizeEvent",
doc = "Resize event."
) {
field(
name = "type",
doc = "Event kind string: resize.",
type = type("lyng.String")
)
field(
name = "columns",
doc = "Terminal width in character cells.",
type = type("lyng.Int")
)
field(
name = "rows",
doc = "Terminal height in character cells.",
type = type("lyng.Int")
)
}
classDoc(
name = "ConsoleKeyEvent",
doc = "Keyboard event."
) {
field(
name = "type",
doc = "Event kind string: keydown or keyup.",
type = type("lyng.String")
)
field(
name = "key",
doc = "Logical key name.",
type = type("lyng.String")
)
field(
name = "code",
doc = "Optional hardware code.",
type = type("lyng.String", nullable = true)
)
field(
name = "ctrl",
doc = "Ctrl modifier state.",
type = type("lyng.Bool")
)
field(
name = "alt",
doc = "Alt modifier state.",
type = type("lyng.Bool")
)
field(
name = "shift",
doc = "Shift modifier state.",
type = type("lyng.Bool")
)
field(
name = "meta",
doc = "Meta modifier state.",
type = type("lyng.Bool")
)
}
valDoc(
name = "Console",
doc = "Console runtime API.",
type = type("Console")
)
valDoc(name = "ConsoleGeometry", doc = "Terminal geometry class.", type = type("lyng.Class"))
valDoc(name = "ConsoleDetails", doc = "Console details class.", type = type("lyng.Class"))
valDoc(name = "ConsoleEvent", doc = "Base console event class.", type = type("lyng.Class"))
valDoc(name = "ConsoleResizeEvent", doc = "Resize event class.", type = type("lyng.Class"))
valDoc(name = "ConsoleKeyEvent", doc = "Keyboard event class.", type = type("lyng.Class"))
valDoc(name = "ConsoleEventStream", doc = "Iterable console event stream class.", type = type("lyng.Class"))
}
registered = true
} }
} }
@@ -26,6 +26,7 @@ import org.jline.terminal.Terminal
import org.jline.terminal.TerminalBuilder import org.jline.terminal.TerminalBuilder
import org.jline.utils.NonBlockingReader import org.jline.utils.NonBlockingReader
import java.io.EOFException import java.io.EOFException
import java.io.InterruptedIOException
import java.util.* import java.util.*
import java.util.concurrent.atomic.AtomicBoolean import java.util.concurrent.atomic.AtomicBoolean
import java.util.concurrent.atomic.AtomicLong import java.util.concurrent.atomic.AtomicLong
@@ -41,7 +42,7 @@ import kotlin.time.TimeSource
* to avoid dual-terminal contention. * to avoid dual-terminal contention.
*/ */
object JvmLyngConsole : LyngConsole { object JvmLyngConsole : LyngConsole {
private const val DEBUG_REVISION = "jline-r26-force-rebuild-on-noop-recovery-2026-03-19" private const val DEBUG_REVISION = "jline-r27-no-close-on-vm-iterator-cancel-2026-03-19"
private val codeSourceLocation: String by lazy { private val codeSourceLocation: String by lazy {
runCatching { runCatching {
JvmLyngConsole::class.java.protectionDomain?.codeSource?.location?.toString() JvmLyngConsole::class.java.protectionDomain?.codeSource?.location?.toString()
@@ -50,6 +51,44 @@ object JvmLyngConsole : LyngConsole {
private val terminalRef = AtomicReference<Terminal?>(null) private val terminalRef = AtomicReference<Terminal?>(null)
private val terminalInitLock = Any() private val terminalInitLock = Any()
private val shutdownHook = Thread(
{
restoreTerminalStateOnShutdown()
},
"lyng-console-shutdown"
).apply { isDaemon = true }
init {
runCatching { Runtime.getRuntime().addShutdownHook(shutdownHook) }
.onFailure { consoleFlowDebug("jline-events: shutdown hook install failed", it) }
}
private fun restoreTerminalStateOnShutdown() {
val term = terminalRef.get() ?: return
runCatching {
term.writer().print("\u001B[?25h")
term.writer().print("\u001B[?1049l")
term.writer().flush()
}.onFailure {
consoleFlowDebug("jline-events: shutdown visual restore failed", it)
}
val saved = if (runCatching { stateMutex.tryLock() }.getOrNull() == true) {
try {
rawModeRequested = false
val s = rawSavedAttributes
rawSavedAttributes = null
s
} finally {
stateMutex.unlock()
}
} else {
null
}
if (saved != null) {
runCatching { term.setAttributes(saved) }
.onFailure { consoleFlowDebug("jline-events: shutdown raw attrs restore failed", it) }
}
}
private fun currentTerminal(): Terminal? { private fun currentTerminal(): Terminal? {
val existing = terminalRef.get() val existing = terminalRef.get()
@@ -176,10 +215,29 @@ object JvmLyngConsole : LyngConsole {
var reader = activeTerm.reader() var reader = activeTerm.reader()
var keyThread: Thread? = null var keyThread: Thread? = null
var heartbeatThread: Thread? = null var heartbeatThread: Thread? = null
val resizeEmitMutex = Any()
var lastResizeCols = Int.MIN_VALUE
var lastResizeRows = Int.MIN_VALUE
fun emitResize() { fun emitResize() {
val size = runCatching { activeTerm.size }.getOrNull() ?: return val size = runCatching { activeTerm.size }.getOrNull() ?: return
out.trySend(ConsoleEvent.Resize(size.columns, size.rows)) val cols = size.columns
val rows = size.rows
if (cols < 1 || rows < 1) {
consoleFlowDebug("jline-events: ignored invalid resize columns=$cols rows=$rows")
return
}
val shouldEmit = synchronized(resizeEmitMutex) {
if (cols == lastResizeCols && rows == lastResizeRows) {
false
} else {
lastResizeCols = cols
lastResizeRows = rows
true
}
}
if (!shouldEmit) return
out.trySend(ConsoleEvent.Resize(cols, rows))
} }
fun cleanup() { fun cleanup() {
@@ -270,13 +328,13 @@ object JvmLyngConsole : LyngConsole {
.onFailure { consoleFlowDebug("jline-events: reader shutdown failed during recovery", it) } .onFailure { consoleFlowDebug("jline-events: reader shutdown failed during recovery", it) }
reader = activeTerm.reader() reader = activeTerm.reader()
if (reader.hashCode() == prevReader.hashCode()) { if (reader === prevReader) {
consoleFlowDebug("jline-events: reader recovery no-op oldReader=${prevReader.hashCode()} newReader=${reader.hashCode()} -> forcing terminal rebuild") consoleFlowDebug("jline-events: reader recovery no-op oldReader=${System.identityHashCode(prevReader)} newReader=${System.identityHashCode(reader)} -> forcing terminal rebuild")
if (!tryRebuildTerminal()) { if (!tryRebuildTerminal()) {
consoleFlowDebug("jline-events: forced terminal rebuild did not produce a new reader") consoleFlowDebug("jline-events: forced terminal rebuild did not produce a new reader")
} }
} else { } else {
consoleFlowDebug("jline-events: reader recovered oldReader=${prevReader.hashCode()} newReader=${reader.hashCode()}") consoleFlowDebug("jline-events: reader recovered oldReader=${System.identityHashCode(prevReader)} newReader=${System.identityHashCode(reader)}")
} }
readerRecoveries.incrementAndGet() readerRecoveries.incrementAndGet()
@@ -305,18 +363,56 @@ object JvmLyngConsole : LyngConsole {
} else { } else {
keySendFailures.incrementAndGet() keySendFailures.incrementAndGet()
} }
} catch (_: InterruptedException) { } catch (e: InterruptedException) {
break // Keep input alive if this is a transient interrupt while still running.
if (!running.get() || !keyLoopRunning.get()) break
recoveryRequested.set(true)
consoleFlowDebug("jline-events: key-reader interrupted; scheduling reader recovery", e)
Thread.interrupted()
continue
} catch (e: InterruptedIOException) {
// Common during reader shutdown/rebind. Recover silently and keep input flowing.
if (!running.get() || !keyLoopRunning.get()) break
recoveryRequested.set(true)
consoleFlowDebug("jline-events: read interrupted; scheduling reader recovery", e)
try {
Thread.sleep(10)
} catch (ie: InterruptedException) {
if (!running.get() || !keyLoopRunning.get()) break
recoveryRequested.set(true)
consoleFlowDebug("jline-events: interrupted during recovery backoff; continuing", ie)
Thread.interrupted()
}
} catch (e: EOFException) {
// EOF from reader should trigger rebind/rebuild rather than ending input stream.
if (!running.get() || !keyLoopRunning.get()) break
recoveryRequested.set(true)
consoleFlowDebug("jline-events: reader EOF; scheduling reader recovery", e)
try {
Thread.sleep(20)
} catch (ie: InterruptedException) {
if (!running.get() || !keyLoopRunning.get()) break
recoveryRequested.set(true)
consoleFlowDebug("jline-events: interrupted during EOF backoff; continuing", ie)
Thread.interrupted()
}
} catch (e: Throwable) { } catch (e: Throwable) {
readFailures.incrementAndGet() readFailures.incrementAndGet()
recoveryRequested.set(true)
consoleFlowDebug("jline-events: blocking read failed", e) consoleFlowDebug("jline-events: blocking read failed", e)
try { try {
Thread.sleep(50) Thread.sleep(50)
} catch (_: InterruptedException) { } catch (ie: InterruptedException) {
break if (!running.get() || !keyLoopRunning.get()) break
recoveryRequested.set(true)
consoleFlowDebug("jline-events: interrupted during error backoff; continuing", ie)
Thread.interrupted()
} }
} }
} }
consoleFlowDebug(
"jline-events: key-reader thread stopped running=${running.get()} keyLoopRunning=${keyLoopRunning.get()} loops=${keyLoopCount.get()} keys=${keyEvents.get()} readFailures=${readFailures.get()}"
)
} }
heartbeatThread = thread(start = true, isDaemon = true, name = "lyng-jline-heartbeat") { heartbeatThread = thread(start = true, isDaemon = true, name = "lyng-jline-heartbeat") {
@@ -334,13 +430,19 @@ object JvmLyngConsole : LyngConsole {
val readBlockedMs = if (readStartNs > 0L && readEndNs < readStartNs) { val readBlockedMs = if (readStartNs > 0L && readEndNs < readStartNs) {
(System.nanoTime() - readStartNs) / 1_000_000L (System.nanoTime() - readStartNs) / 1_000_000L
} else 0L } else 0L
if (requested && keyCodesRead.get() > 0L && idleMs >= 1400L) { val streamIdle = requested && keyCodesRead.get() > 0L && idleMs >= 1400L
val readStalled = requested && readBlockedMs >= 1600L
if (streamIdle || readStalled) {
val sinceRecoveryMs = (System.nanoTime() - lastRecoveryNs.get()) / 1_000_000L val sinceRecoveryMs = (System.nanoTime() - lastRecoveryNs.get()) / 1_000_000L
if (sinceRecoveryMs >= 1200L) { if (sinceRecoveryMs >= 1200L) {
recoveryRequested.set(true) recoveryRequested.set(true)
if (readStalled) {
consoleFlowDebug("jline-events: key read blocked ${readBlockedMs}ms; scheduling reader recovery")
} else {
consoleFlowDebug("jline-events: key stream idle ${idleMs}ms; scheduling reader recovery") consoleFlowDebug("jline-events: key stream idle ${idleMs}ms; scheduling reader recovery")
} }
} }
}
consoleFlowDebug( consoleFlowDebug(
"jline-events: heartbeat keyCodes=${keyCodesRead.get()} keysSent=${keyEvents.get()} sendFailures=${keySendFailures.get()} readFailures=${readFailures.get()} recoveries=${readerRecoveries.get()} rawRequested=$requested keyLoop=${keyLoopCount.get()} readBlockedMs=$readBlockedMs keyIdleMs=$idleMs keyPath=reader" "jline-events: heartbeat keyCodes=${keyCodesRead.get()} keysSent=${keyEvents.get()} sendFailures=${keySendFailures.get()} readFailures=${readFailures.get()} recoveries=${readerRecoveries.get()} rawRequested=$requested keyLoop=${keyLoopCount.get()} readBlockedMs=$readBlockedMs keyIdleMs=$idleMs keyPath=reader"
) )
@@ -366,6 +468,7 @@ object JvmLyngConsole : LyngConsole {
} }
override suspend fun close() { override suspend fun close() {
consoleFlowDebug("jline-events: collector close requested", Throwable("collector close caller"))
cleanup() cleanup()
consoleFlowDebug( consoleFlowDebug(
"jline-events: collector ended keys=${keyEvents.get()} readFailures=${readFailures.get()}" "jline-events: collector ended keys=${keyEvents.get()} readFailures=${readFailures.get()}"
@@ -485,7 +588,9 @@ object JvmLyngConsole : LyngConsole {
ctrl: Boolean = false, ctrl: Boolean = false,
alt: Boolean = false, alt: Boolean = false,
shift: Boolean = false, shift: Boolean = false,
): ConsoleEvent.KeyDown = ConsoleEvent.KeyDown( ): ConsoleEvent.KeyDown {
require(value.isNotEmpty()) { "ConsoleEvent.KeyDown.key must never be empty" }
return ConsoleEvent.KeyDown(
key = value, key = value,
code = null, code = null,
ctrl = ctrl, ctrl = ctrl,
@@ -494,3 +599,4 @@ object JvmLyngConsole : LyngConsole {
meta = false meta = false
) )
} }
}
@@ -56,7 +56,7 @@ class LyngConsoleModuleTest {
val d = Console.details() val d = Console.details()
assert(d.supported is Bool) assert(d.supported is Bool)
assert(d.isTty is Bool) assert(d.isTty is Bool)
assert(d.ansiLevel is String) assert(d.ansiLevel is ConsoleAnsiLevel)
val g = Console.geometry() val g = Console.geometry()
if (g != null) { if (g != null) {
+157
View File
@@ -0,0 +1,157 @@
package lyng.io.console
/* Console event kinds used by `ConsoleEvent.type`. */
enum ConsoleEventType {
UNKNOWN,
RESIZE,
KEY_DOWN,
KEY_UP
}
/* Normalized key codes used by `ConsoleKeyEvent.code`. */
enum ConsoleKeyCode {
UNKNOWN,
CHARACTER,
ARROW_UP,
ARROW_DOWN,
ARROW_LEFT,
ARROW_RIGHT,
HOME,
END,
INSERT,
DELETE,
PAGE_UP,
PAGE_DOWN,
ESCAPE,
ENTER,
TAB,
BACKSPACE,
SPACE
}
/* Detected ANSI terminal capability level. */
enum ConsoleAnsiLevel {
NONE,
BASIC16,
ANSI256,
TRUECOLOR
}
/* Base class for console events. */
extern class ConsoleEvent {
/* Event kind for stable matching/switching. */
val type: ConsoleEventType
}
/* Terminal resize event. */
extern class ConsoleResizeEvent : ConsoleEvent {
/* Current terminal width in character cells. */
val columns: Int
/* Current terminal height in character cells. */
val rows: Int
}
/* Keyboard event. */
extern class ConsoleKeyEvent : ConsoleEvent {
/*
Logical key name normalized for app-level handling, for example:
"a", "A", "ArrowLeft", "Escape", "Enter".
*/
val key: String
/* Normalized key code enum for robust matching independent of backend specifics. */
val code: ConsoleKeyCode
/*
Optional backend-specific raw identifier (if available).
Not guaranteed to be present or stable across platforms.
*/
val codeName: String?
/* True when Ctrl was pressed during the key event. */
val ctrl: Bool
/* True when Alt/Option was pressed during the key event. */
val alt: Bool
/* True when Shift was pressed during the key event. */
val shift: Bool
/* True when Meta/Super/Command was pressed during the key event. */
val meta: Bool
}
/* Pull iterator over console events. */
extern class ConsoleEventIterator : Iterator<ConsoleEvent> {
/* Whether another event is currently available from the stream. */
override fun hasNext(): Bool
/* Returns next event or throws iteration-finished when exhausted/cancelled. */
override fun next(): ConsoleEvent
/* Stops this iterator. The underlying console service remains managed by runtime. */
override fun cancelIteration(): void
}
/* Endless iterable console event stream. */
extern class ConsoleEventStream : Iterable<ConsoleEvent> {
/* Creates a fresh event iterator bound to the current console input stream. */
override fun iterator(): ConsoleEventIterator
}
/* Terminal geometry in character cells. */
extern class ConsoleGeometry {
val columns: Int
val rows: Int
}
/* Snapshot of console support/capabilities. */
extern class ConsoleDetails {
/* True when current runtime has console control implementation. */
val supported: Bool
/* True when output/input are attached to an interactive terminal. */
val isTty: Bool
/* Detected terminal color capability level. */
val ansiLevel: ConsoleAnsiLevel
/* Current terminal size if available, otherwise null. */
val geometry: ConsoleGeometry?
}
/* Console API singleton object. */
extern object Console {
/* Returns true when console control API is implemented in this runtime. */
fun isSupported(): Bool
/* Returns true when process is attached to interactive TTY. */
fun isTty(): Bool
/* Returns detected color capability level. */
fun ansiLevel(): ConsoleAnsiLevel
/* Returns current terminal geometry, or null when unavailable. */
fun geometry(): ConsoleGeometry?
/* Returns combined capability snapshot in one call. */
fun details(): ConsoleDetails
/* Writes raw text to console output buffer (no implicit newline). */
fun write(text: String): void
/* Flushes pending console output. Call after batched writes. */
fun flush(): void
/* Moves cursor to home position (row 1, column 1). */
fun home(): void
/* Clears visible screen buffer. Cursor position is backend-dependent after clear. */
fun clear(): void
/* Moves cursor to 1-based row/column. Values outside viewport are backend-defined. */
fun moveTo(row: Int, column: Int): void
/* Clears current line content. Cursor stays on the same line. */
fun clearLine(): void
/* Switches terminal into alternate screen buffer (useful for TUIs). */
fun enterAltScreen(): void
/* Returns from alternate screen buffer to the normal terminal screen. */
fun leaveAltScreen(): void
/* Shows or hides the cursor. Prefer restoring visibility in finally blocks. */
fun setCursorVisible(visible: Bool): void
/*
Returns endless event stream (resize + key events).
Typical usage is consuming in a launched loop.
*/
fun events(): ConsoleEventStream
/*
Enables/disables raw keyboard mode.
Returns true when state was actually changed.
*/
fun setRawMode(enabled: Bool): Bool
}
+71 -17
View File
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
import org.jetbrains.kotlin.gradle.dsl.JvmTarget import org.jetbrains.kotlin.gradle.dsl.JvmTarget
group = "net.sergeych" group = "net.sergeych"
version = "1.5.0-RC" version = "1.5.3-SNAPSHOT"
// Removed legacy buildscript classpath declarations; plugins are applied via the plugins DSL below // Removed legacy buildscript classpath declarations; plugins are applied via the plugins DSL below
@@ -29,7 +29,7 @@ plugins {
alias(libs.plugins.kotlinMultiplatform) alias(libs.plugins.kotlinMultiplatform)
alias(libs.plugins.androidLibrary) alias(libs.plugins.androidLibrary)
// alias(libs.plugins.vanniktech.mavenPublish) // alias(libs.plugins.vanniktech.mavenPublish)
kotlin("plugin.serialization") version "2.2.21" kotlin("plugin.serialization") version "2.3.20"
id("com.codingfeline.buildkonfig") version "0.17.1" id("com.codingfeline.buildkonfig") version "0.17.1"
`maven-publish` `maven-publish`
} }
@@ -58,7 +58,6 @@ kotlin {
iosX64() iosX64()
iosArm64() iosArm64()
iosSimulatorArm64() iosSimulatorArm64()
macosX64()
macosArm64() macosArm64()
mingwX64() mingwX64()
linuxX64() linuxX64()
@@ -76,11 +75,13 @@ kotlin {
// Suppress Beta warning for expect/actual classes across all targets // Suppress Beta warning for expect/actual classes across all targets
targets.configureEach { targets.configureEach {
compilations.configureEach { compilations.configureEach {
compilerOptions.configure { compileTaskProvider.configure {
compilerOptions {
freeCompilerArgs.add("-Xexpect-actual-classes") freeCompilerArgs.add("-Xexpect-actual-classes")
} }
} }
} }
}
sourceSets { sourceSets {
all { all {
@@ -94,13 +95,14 @@ kotlin {
} }
val commonMain by getting { val commonMain by getting {
kotlin.srcDir("$buildDir/generated/buildConfig/commonMain/kotlin") kotlin.srcDir(layout.buildDirectory.dir("generated/buildConfig/commonMain/kotlin"))
dependencies { dependencies {
implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.9.0") implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.9.0")
implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.6.1") implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.6.1")
//put your multiplatform dependencies here //put your multiplatform dependencies here
api(libs.kotlinx.coroutines.core) api(libs.kotlinx.coroutines.core)
api(libs.mp.bintools) api(libs.mp.bintools)
implementation(libs.ionspin.bignum)
} }
} }
val commonTest by getting { val commonTest by getting {
@@ -109,6 +111,51 @@ kotlin {
implementation(libs.kotlinx.coroutines.test) implementation(libs.kotlinx.coroutines.test)
} }
} }
val matrixMultikMain by creating {
dependsOn(commonMain)
dependencies {
implementation(libs.multik.default)
}
}
val nativeMain by creating {
dependsOn(commonMain)
}
val matrixPureMain by creating {
dependsOn(commonMain)
}
val jvmMain by getting { dependsOn(matrixMultikMain) }
val androidMain by getting { dependsOn(matrixPureMain) }
val jsMain by getting { dependsOn(matrixMultikMain) }
val wasmJsMain by getting { dependsOn(matrixMultikMain) }
// Multik 0.3.0 does not publish ios native artifacts, so keep iOS on the pure backend.
val iosX64Main by getting {
dependsOn(nativeMain)
dependsOn(matrixPureMain)
}
val iosArm64Main by getting {
dependsOn(nativeMain)
dependsOn(matrixPureMain)
}
val iosSimulatorArm64Main by getting {
dependsOn(nativeMain)
dependsOn(matrixPureMain)
}
val macosArm64Main by getting {
dependsOn(nativeMain)
dependsOn(matrixPureMain)
}
val mingwX64Main by getting {
dependsOn(nativeMain)
dependsOn(matrixPureMain)
}
val linuxX64Main by getting {
dependsOn(nativeMain)
dependsOn(matrixPureMain)
}
val linuxArm64Main by getting {
dependsOn(nativeMain)
dependsOn(matrixPureMain)
}
val jvmTest by getting { val jvmTest by getting {
dependencies { dependencies {
// Allow tests to load external docs like lyng.io.fs via registrar // Allow tests to load external docs like lyng.io.fs via registrar
@@ -148,6 +195,9 @@ abstract class GenerateLyngStdlib : DefaultTask() {
val outBase = outputDir.get().asFile val outBase = outputDir.get().asFile
val targetDir = outBase.resolve(pkgPath) val targetDir = outBase.resolve(pkgPath)
targetDir.mkdirs() targetDir.mkdirs()
targetDir.listFiles()
?.filter { it.isFile && it.name.endsWith(".generated.kt") }
?.forEach { it.delete() }
val srcDir = sourceDir.get().asFile val srcDir = sourceDir.get().asFile
val files = srcDir.walkTopDown() val files = srcDir.walkTopDown()
@@ -155,34 +205,38 @@ abstract class GenerateLyngStdlib : DefaultTask() {
.sortedBy { it.name } .sortedBy { it.name }
.toList() .toList()
val content = if (files.isEmpty()) "" else buildString {
files.forEachIndexed { idx, f ->
val text = f.readText()
if (idx > 0) append("\n\n")
append(text)
}
}
fun escapeForQuoted(s: String): String = buildString { fun escapeForQuoted(s: String): String = buildString {
for (ch in s) when (ch) { for (ch in s) when (ch) {
'\\' -> append("\\\\") '\\' -> append("\\\\")
'"' -> append("\\\"") '"' -> append("\\\"")
'$' -> append("\\$")
'\n' -> append("\\n") '\n' -> append("\\n")
'\r' -> {} '\r' -> {}
'\t' -> append("\\t") '\t' -> append("\\t")
else -> append(ch) else -> append(ch)
} }
} }
val body = escapeForQuoted(content)
fun constantName(baseName: String): String {
val parts = baseName.split(Regex("[^A-Za-z0-9]+")).filter { it.isNotEmpty() }
if (parts.isEmpty()) return "moduleLyng"
val head = parts.first().replaceFirstChar { it.lowercase() }
val tail = parts.drop(1).joinToString("") { part ->
part.replaceFirstChar { it.uppercase() }
}
return "${head}${tail}Lyng"
}
for (file in files) {
val body = escapeForQuoted(file.readText())
val sb = StringBuilder() val sb = StringBuilder()
sb.append("package ").append(targetPkg).append("\n\n") sb.append("package ").append(targetPkg).append("\n\n")
sb.append("@Suppress(\"Unused\", \"MemberVisibilityCanBePrivate\")\n") sb.append("@Suppress(\"Unused\", \"MemberVisibilityCanBePrivate\")\n")
sb.append("internal val rootLyng = \"") sb.append("internal val ").append(constantName(file.nameWithoutExtension)).append(" = \"")
sb.append(body) sb.append(body)
sb.append("\"\n") sb.append("\"\n")
targetDir.resolve("${file.nameWithoutExtension}_lyng.generated.kt").writeText(sb.toString())
targetDir.resolve("root_lyng.generated.kt").writeText(sb.toString()) }
} }
} }
@@ -172,6 +172,7 @@ class Compiler(
private val callReturnTypeDeclByRef: MutableMap<CallRef, TypeDecl> = mutableMapOf() private val callReturnTypeDeclByRef: MutableMap<CallRef, TypeDecl> = mutableMapOf()
private val callableReturnTypeByScopeId: MutableMap<Int, MutableMap<Int, ObjClass>> = mutableMapOf() private val callableReturnTypeByScopeId: MutableMap<Int, MutableMap<Int, ObjClass>> = mutableMapOf()
private val callableReturnTypeByName: MutableMap<String, ObjClass> = mutableMapOf() private val callableReturnTypeByName: MutableMap<String, ObjClass> = mutableMapOf()
private val callableReturnTypeDeclByName: MutableMap<String, TypeDecl> = mutableMapOf()
private val lambdaReturnTypeByRef: MutableMap<ObjRef, ObjClass> = mutableMapOf() private val lambdaReturnTypeByRef: MutableMap<ObjRef, ObjClass> = mutableMapOf()
private val lambdaCaptureEntriesByRef: MutableMap<ValueFnRef, List<net.sergeych.lyng.bytecode.LambdaCaptureEntry>> = private val lambdaCaptureEntriesByRef: MutableMap<ValueFnRef, List<net.sergeych.lyng.bytecode.LambdaCaptureEntry>> =
mutableMapOf() mutableMapOf()
@@ -184,7 +185,10 @@ class Compiler(
private val encodedPayloadTypeByName: MutableMap<String, ObjClass> = mutableMapOf() private val encodedPayloadTypeByName: MutableMap<String, ObjClass> = mutableMapOf()
private val objectDeclNames: MutableSet<String> = mutableSetOf() private val objectDeclNames: MutableSet<String> = mutableSetOf()
private val externCallableNames: MutableSet<String> = mutableSetOf() private val externCallableNames: MutableSet<String> = mutableSetOf()
private val externBindingNames: MutableSet<String> = mutableSetOf()
private val moduleDeclaredNames: MutableSet<String> = mutableSetOf() private val moduleDeclaredNames: MutableSet<String> = mutableSetOf()
private val predeclaredTopLevelValueNames: MutableSet<String> = mutableSetOf()
private val moduleReferencePosByName: MutableMap<String, Pos> = mutableMapOf()
private var seedingSlotPlan: Boolean = false private var seedingSlotPlan: Boolean = false
private fun moduleForcedLocalSlotInfo(): Map<String, ForcedLocalSlotInfo> { private fun moduleForcedLocalSlotInfo(): Map<String, ForcedLocalSlotInfo> {
@@ -192,6 +196,7 @@ class Compiler(
if (plan.slots.isEmpty()) return emptyMap() if (plan.slots.isEmpty()) return emptyMap()
val result = LinkedHashMap<String, ForcedLocalSlotInfo>(plan.slots.size) val result = LinkedHashMap<String, ForcedLocalSlotInfo>(plan.slots.size)
for ((name, entry) in plan.slots) { for ((name, entry) in plan.slots) {
if (externBindingNames.contains(name)) continue
result[name] = ForcedLocalSlotInfo( result[name] = ForcedLocalSlotInfo(
index = entry.index, index = entry.index,
isMutable = entry.isMutable, isMutable = entry.isMutable,
@@ -338,6 +343,73 @@ class Compiler(
} }
return t return t
} }
fun handleTopLevelKeyword(keyword: Token): Boolean {
when (keyword.value) {
"fun", "fn" -> {
val nameToken = nextNonWs()
if (nameToken.type != Token.Type.ID) return true
val afterName = cc.peekNextNonWhitespace()
if (afterName.type == Token.Type.DOT) {
cc.nextNonWhitespace()
val actual = cc.nextNonWhitespace()
if (actual.type == Token.Type.ID) {
extensionNames.add(actual.value)
registerExtensionName(nameToken.value, actual.value)
declareSlotNameIn(plan, extensionCallableName(nameToken.value, actual.value), isMutable = false, isDelegated = false)
moduleDeclaredNames.add(extensionCallableName(nameToken.value, actual.value))
}
return true
}
declareSlotNameIn(plan, nameToken.value, isMutable = false, isDelegated = false)
moduleDeclaredNames.add(nameToken.value)
return true
}
"val", "var" -> {
val nameToken = nextNonWs()
if (nameToken.type != Token.Type.ID) return true
val afterName = cc.peekNextNonWhitespace()
if (afterName.type == Token.Type.DOT) {
cc.nextNonWhitespace()
val actual = cc.nextNonWhitespace()
if (actual.type == Token.Type.ID) {
extensionNames.add(actual.value)
registerExtensionName(nameToken.value, actual.value)
declareSlotNameIn(plan, extensionPropertyGetterName(nameToken.value, actual.value), isMutable = false, isDelegated = false)
moduleDeclaredNames.add(extensionPropertyGetterName(nameToken.value, actual.value))
if (keyword.value == "var") {
declareSlotNameIn(plan, extensionPropertySetterName(nameToken.value, actual.value), isMutable = false, isDelegated = false)
moduleDeclaredNames.add(extensionPropertySetterName(nameToken.value, actual.value))
}
}
return true
}
declareSlotNameIn(plan, nameToken.value, isMutable = keyword.value == "var", isDelegated = false)
moduleDeclaredNames.add(nameToken.value)
predeclaredTopLevelValueNames.add(nameToken.value)
return true
}
"class", "object" -> {
val nameToken = nextNonWs()
if (nameToken.type == Token.Type.ID) {
declareSlotNameIn(plan, nameToken.value, isMutable = false, isDelegated = false)
scopeSeedNames.add(nameToken.value)
moduleDeclaredNames.add(nameToken.value)
}
return true
}
"enum" -> {
val next = nextNonWs()
val nameToken = if (next.type == Token.Type.ID && next.value == "class") nextNonWs() else next
if (nameToken.type == Token.Type.ID) {
declareSlotNameIn(plan, nameToken.value, isMutable = false, isDelegated = false)
scopeSeedNames.add(nameToken.value)
moduleDeclaredNames.add(nameToken.value)
}
return true
}
}
return false
}
try { try {
while (cc.hasNext()) { while (cc.hasNext()) {
val t = cc.next() val t = cc.next()
@@ -350,65 +422,11 @@ class Compiler(
Token.Type.RBRACKET -> if (bracketDepth > 0) bracketDepth-- Token.Type.RBRACKET -> if (bracketDepth > 0) bracketDepth--
Token.Type.ID -> if (depth == 0) { Token.Type.ID -> if (depth == 0) {
if (parenDepth > 0 || bracketDepth > 0) continue if (parenDepth > 0 || bracketDepth > 0) continue
when (t.value) { if (t.value == "extern") {
"fun", "fn" -> { handleTopLevelKeyword(nextNonWs())
val nameToken = nextNonWs()
if (nameToken.type != Token.Type.ID) continue
val afterName = cc.peekNextNonWhitespace()
if (afterName.type == Token.Type.DOT) {
cc.nextNonWhitespace()
val actual = cc.nextNonWhitespace()
if (actual.type == Token.Type.ID) {
extensionNames.add(actual.value)
registerExtensionName(nameToken.value, actual.value)
declareSlotNameIn(plan, extensionCallableName(nameToken.value, actual.value), isMutable = false, isDelegated = false)
moduleDeclaredNames.add(extensionCallableName(nameToken.value, actual.value))
}
continue continue
} }
declareSlotNameIn(plan, nameToken.value, isMutable = false, isDelegated = false) handleTopLevelKeyword(t)
moduleDeclaredNames.add(nameToken.value)
}
"val", "var" -> {
val nameToken = nextNonWs()
if (nameToken.type != Token.Type.ID) continue
val afterName = cc.peekNextNonWhitespace()
if (afterName.type == Token.Type.DOT) {
cc.nextNonWhitespace()
val actual = cc.nextNonWhitespace()
if (actual.type == Token.Type.ID) {
extensionNames.add(actual.value)
registerExtensionName(nameToken.value, actual.value)
declareSlotNameIn(plan, extensionPropertyGetterName(nameToken.value, actual.value), isMutable = false, isDelegated = false)
moduleDeclaredNames.add(extensionPropertyGetterName(nameToken.value, actual.value))
if (t.value == "var") {
declareSlotNameIn(plan, extensionPropertySetterName(nameToken.value, actual.value), isMutable = false, isDelegated = false)
moduleDeclaredNames.add(extensionPropertySetterName(nameToken.value, actual.value))
}
}
continue
}
declareSlotNameIn(plan, nameToken.value, isMutable = t.value == "var", isDelegated = false)
moduleDeclaredNames.add(nameToken.value)
}
"class", "object" -> {
val nameToken = nextNonWs()
if (nameToken.type == Token.Type.ID) {
declareSlotNameIn(plan, nameToken.value, isMutable = false, isDelegated = false)
scopeSeedNames.add(nameToken.value)
moduleDeclaredNames.add(nameToken.value)
}
}
"enum" -> {
val next = nextNonWs()
val nameToken = if (next.type == Token.Type.ID && next.value == "class") nextNonWs() else next
if (nameToken.type == Token.Type.ID) {
declareSlotNameIn(plan, nameToken.value, isMutable = false, isDelegated = false)
scopeSeedNames.add(nameToken.value)
moduleDeclaredNames.add(nameToken.value)
}
}
}
} }
else -> {} else -> {}
} }
@@ -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>) { private fun predeclareClassMembers(target: MutableSet<String>, overrides: MutableMap<String, Boolean>) {
val saved = cc.savePos() val saved = cc.savePos()
var depth = 0 var depth = 0
@@ -581,7 +605,7 @@ class Compiler(
val baseNames = cls.directParents.map { it.className } val baseNames = cls.directParents.map { it.className }
val nextFieldId = (fieldIds.values.maxOrNull() ?: -1) + 1 val nextFieldId = (fieldIds.values.maxOrNull() ?: -1) + 1
val nextMethodId = (methodIds.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( private data class BaseMemberIds(
@@ -885,6 +909,7 @@ class Compiler(
name = declaredName, name = declaredName,
isMutable = false, isMutable = false,
visibility = Visibility.Public, visibility = Visibility.Public,
actualExtern = false,
initializer = initStmt, initializer = initStmt,
isTransient = false, isTransient = false,
typeDecl = null, typeDecl = null,
@@ -929,6 +954,7 @@ class Compiler(
} }
} }
captureLocalRef(name, slotLoc, pos)?.let { ref -> captureLocalRef(name, slotLoc, pos)?.let { ref ->
rememberModuleReferencePos(name, pos)
resolutionSink?.reference(name, pos) resolutionSink?.reference(name, pos)
return ref return ref
} }
@@ -974,8 +1000,11 @@ class Compiler(
if (moduleLoc != null) { if (moduleLoc != null) {
val moduleDeclaredNames = localNamesStack.firstOrNull() val moduleDeclaredNames = localNamesStack.firstOrNull()
if (moduleDeclaredNames == null || !moduleDeclaredNames.contains(name)) { if (moduleDeclaredNames == null || !moduleDeclaredNames.contains(name)) {
resolveImportBinding(name, pos)?.let { resolved -> val resolvedImport = resolveImportBinding(name, pos)
registerImportBinding(name, resolved.binding, pos) if (resolvedImport != null) {
registerImportBinding(name, resolvedImport.binding, pos)
} else if (predeclaredTopLevelValueNames.contains(name)) {
throw ScriptError(pos, "symbol '$name' is not defined")
} }
} }
val ref = LocalSlotRef( val ref = LocalSlotRef(
@@ -1004,8 +1033,11 @@ class Compiler(
if (moduleEntry != null) { if (moduleEntry != null) {
val moduleDeclaredNames = localNamesStack.firstOrNull() val moduleDeclaredNames = localNamesStack.firstOrNull()
if (moduleDeclaredNames == null || !moduleDeclaredNames.contains(name)) { if (moduleDeclaredNames == null || !moduleDeclaredNames.contains(name)) {
resolveImportBinding(name, pos)?.let { resolved -> val resolvedImport = resolveImportBinding(name, pos)
registerImportBinding(name, resolved.binding, pos) if (resolvedImport != null) {
registerImportBinding(name, resolvedImport.binding, pos)
} else if (predeclaredTopLevelValueNames.contains(name)) {
throw ScriptError(pos, "symbol '$name' is not defined")
} }
} }
val moduleLoc = SlotLocation( val moduleLoc = SlotLocation(
@@ -1016,6 +1048,7 @@ class Compiler(
moduleEntry.isDelegated moduleEntry.isDelegated
) )
captureLocalRef(name, moduleLoc, pos)?.let { ref -> captureLocalRef(name, moduleLoc, pos)?.let { ref ->
rememberModuleReferencePos(name, pos)
resolutionSink?.reference(name, pos) resolutionSink?.reference(name, pos)
return ref return ref
} }
@@ -1042,6 +1075,7 @@ class Compiler(
strictSlotRefs strictSlotRefs
) )
} }
rememberModuleReferencePos(name, pos)
resolutionSink?.reference(name, pos) resolutionSink?.reference(name, pos)
return ref return ref
} }
@@ -1076,6 +1110,7 @@ class Compiler(
val slot = lookupSlotLocation(name) val slot = lookupSlotLocation(name)
if (slot != null) { if (slot != null) {
captureLocalRef(name, slot, pos)?.let { ref -> captureLocalRef(name, slot, pos)?.let { ref ->
rememberModuleReferencePos(name, pos)
resolutionSink?.reference(name, pos) resolutionSink?.reference(name, pos)
return ref return ref
} }
@@ -1102,6 +1137,7 @@ class Compiler(
strictSlotRefs strictSlotRefs
) )
} }
rememberModuleReferencePos(name, pos)
resolutionSink?.reference(name, pos) resolutionSink?.reference(name, pos)
return ref return ref
} }
@@ -1278,23 +1314,11 @@ class Compiler(
} }
} }
if (seedRecord != null) { if (seedRecord != null) {
val value = seedRecord.value seedImportTypeMetadata(name, seedRecord)
if (!nameObjClass.containsKey(name)) {
when (value) {
is ObjClass -> nameObjClass[name] = value
is ObjInstance -> nameObjClass[name] = value.objClass
}
}
return ImportBindingResolution(ImportBinding(name, ImportBindingSource.Seed), seedRecord) return ImportBindingResolution(ImportBinding(name, ImportBindingSource.Seed), seedRecord)
} }
if (rootRecord != null) { if (rootRecord != null) {
val value = rootRecord.value seedImportTypeMetadata(name, rootRecord)
if (!nameObjClass.containsKey(name)) {
when (value) {
is ObjClass -> nameObjClass[name] = value
is ObjInstance -> nameObjClass[name] = value.objClass
}
}
return ImportBindingResolution(ImportBinding(name, ImportBindingSource.Root), rootRecord) return ImportBindingResolution(ImportBinding(name, ImportBindingSource.Root), rootRecord)
} }
if (moduleMatches.isEmpty()) return null if (moduleMatches.isEmpty()) return null
@@ -1309,13 +1333,7 @@ class Compiler(
val candidates = byOrigin[origin] ?: mutableListOf() val candidates = byOrigin[origin] ?: mutableListOf()
val preferred = candidates.firstOrNull { it.first.scope.packageName == origin } ?: candidates.first() val preferred = candidates.firstOrNull { it.first.scope.packageName == origin } ?: candidates.first()
val binding = ImportBinding(name, ImportBindingSource.Module(origin, preferred.first.pos)) val binding = ImportBinding(name, ImportBindingSource.Module(origin, preferred.first.pos))
val value = preferred.second.value seedImportTypeMetadata(name, preferred.second)
if (!nameObjClass.containsKey(name)) {
when (value) {
is ObjClass -> nameObjClass[name] = value
is ObjInstance -> nameObjClass[name] = value.objClass
}
}
return ImportBindingResolution(binding, preferred.second) return ImportBindingResolution(binding, preferred.second)
} }
val moduleNames = moduleMatches.keys.toList() val moduleNames = moduleMatches.keys.toList()
@@ -1323,14 +1341,24 @@ class Compiler(
} }
val (module, record) = moduleMatches.values.first() val (module, record) = moduleMatches.values.first()
val binding = ImportBinding(name, ImportBindingSource.Module(module.scope.packageName, module.pos)) val binding = ImportBinding(name, ImportBindingSource.Module(module.scope.packageName, module.pos))
val value = record.value seedImportTypeMetadata(name, record)
return ImportBindingResolution(binding, record)
}
private fun seedImportTypeMetadata(name: String, record: ObjRecord) {
if (record.typeDecl != null && nameTypeDecl[name] == null) {
nameTypeDecl[name] = record.typeDecl
}
if (!nameObjClass.containsKey(name)) { if (!nameObjClass.containsKey(name)) {
when (value) { record.typeDecl?.let { resolveTypeDeclObjClass(it) }?.let {
nameObjClass[name] = it
return
}
when (val value = record.value) {
is ObjClass -> nameObjClass[name] = value is ObjClass -> nameObjClass[name] = value
is ObjInstance -> nameObjClass[name] = value.objClass is ObjInstance -> nameObjClass[name] = value.objClass
} }
} }
return ImportBindingResolution(binding, record)
} }
private fun collectModuleRecordMatches( private fun collectModuleRecordMatches(
@@ -1550,6 +1578,7 @@ class Compiler(
private data class CompileClassInfo( private data class CompileClassInfo(
val name: String, val name: String,
val packageName: String?,
val fieldIds: Map<String, Int>, val fieldIds: Map<String, Int>,
val methodIds: Map<String, Int>, val methodIds: Map<String, Int>,
val nextFieldId: Int, val nextFieldId: Int,
@@ -1751,6 +1780,9 @@ class Compiler(
enumEntriesByName = enumEntriesByName, enumEntriesByName = enumEntriesByName,
callableReturnTypeByScopeId = callableReturnTypeByScopeId, callableReturnTypeByScopeId = callableReturnTypeByScopeId,
callableReturnTypeByName = callableReturnTypeByName, callableReturnTypeByName = callableReturnTypeByName,
externBindingNames = externBindingNames,
preparedModuleBindingNames = importBindings.keys,
scopeRefPosByName = moduleReferencePosByName,
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
) as BytecodeStatement ) as BytecodeStatement
unwrapped to bytecodeStmt.bytecodeFunction() unwrapped to bytecodeStmt.bytecodeFunction()
@@ -1957,6 +1989,9 @@ class Compiler(
val scopeIndex = slotPlanStack.indexOfLast { it.id == slotLoc.scopeId } val scopeIndex = slotPlanStack.indexOfLast { it.id == slotLoc.scopeId }
if (functionIndex >= 0 && scopeIndex >= functionIndex) return null if (functionIndex >= 0 && scopeIndex >= functionIndex) return null
val modulePlan = moduleSlotPlan() val modulePlan = moduleSlotPlan()
if (modulePlan != null && slotLoc.scopeId == modulePlan.id && externBindingNames.contains(name)) {
return null
}
if (useScopeSlots && modulePlan != null && slotLoc.scopeId == modulePlan.id) { if (useScopeSlots && modulePlan != null && slotLoc.scopeId == modulePlan.id) {
return null return null
} }
@@ -2075,6 +2110,9 @@ class Compiler(
callableReturnTypeByScopeId = callableReturnTypeByScopeId, callableReturnTypeByScopeId = callableReturnTypeByScopeId,
callableReturnTypeByName = callableReturnTypeByName, callableReturnTypeByName = callableReturnTypeByName,
externCallableNames = externCallableNames, externCallableNames = externCallableNames,
externBindingNames = externBindingNames,
preparedModuleBindingNames = importBindings.keys,
scopeRefPosByName = moduleReferencePosByName,
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
) )
} }
@@ -2105,6 +2143,9 @@ class Compiler(
callableReturnTypeByScopeId = callableReturnTypeByScopeId, callableReturnTypeByScopeId = callableReturnTypeByScopeId,
callableReturnTypeByName = callableReturnTypeByName, callableReturnTypeByName = callableReturnTypeByName,
externCallableNames = externCallableNames, externCallableNames = externCallableNames,
externBindingNames = externBindingNames,
preparedModuleBindingNames = importBindings.keys,
scopeRefPosByName = moduleReferencePosByName,
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
) )
} }
@@ -2160,6 +2201,9 @@ class Compiler(
callableReturnTypeByScopeId = callableReturnTypeByScopeId, callableReturnTypeByScopeId = callableReturnTypeByScopeId,
callableReturnTypeByName = callableReturnTypeByName, callableReturnTypeByName = callableReturnTypeByName,
externCallableNames = externCallableNames, externCallableNames = externCallableNames,
externBindingNames = externBindingNames,
preparedModuleBindingNames = importBindings.keys,
scopeRefPosByName = moduleReferencePosByName,
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
) )
} }
@@ -2343,6 +2387,7 @@ class Compiler(
stmt.name, stmt.name,
stmt.isMutable, stmt.isMutable,
stmt.visibility, stmt.visibility,
stmt.actualExtern,
init, init,
stmt.isTransient, stmt.isTransient,
stmt.typeDecl, stmt.typeDecl,
@@ -2903,9 +2948,9 @@ class Compiler(
operand?.let { left -> operand?.let { left ->
// array access via ObjRef // array access via ObjRef
val isOptional = t.type == Token.Type.NULL_COALESCE_INDEX val isOptional = t.type == Token.Type.NULL_COALESCE_INDEX
val index = parseStatement() ?: throw ScriptError(t.pos, "Expecting index expression") val index = parseIndexExpression() ?: throw ScriptError(t.pos, "Expecting index expression")
cc.skipTokenOfType(Token.Type.RBRACKET, "missing ']' at the end of the list literal") cc.skipTokenOfType(Token.Type.RBRACKET, "missing ']' at the end of the list literal")
operand = IndexRef(left, StatementRef(index), isOptional) operand = IndexRef(left, index, isOptional)
} ?: run { } ?: run {
// array literal // array literal
val entries = parseArrayLiteral() val entries = parseArrayLiteral()
@@ -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> { private suspend fun parseDestructuringPattern(): List<ListEntry> {
// it should be called after Token.Type.LBRACKET is consumed // it should be called after Token.Type.LBRACKET is consumed
val entries = mutableListOf<ListEntry>() val entries = mutableListOf<ListEntry>()
@@ -4287,14 +4346,22 @@ class Compiler(
is MapLiteralRef -> inferMapLiteralTypeDecl(ref) is MapLiteralRef -> inferMapLiteralTypeDecl(ref)
is ConstRef -> inferTypeDeclFromConst(ref.constValue) is ConstRef -> inferTypeDeclFromConst(ref.constValue)
is CallRef -> { is CallRef -> {
inferCallReturnClass(ref)?.let { TypeDecl.Simple(it.className, false) } val targetDecl = resolveReceiverTypeDecl(ref.target)
?: run {
val targetName = when (val target = ref.target) { val targetName = when (val target = ref.target) {
is LocalVarRef -> target.name is LocalVarRef -> target.name
is FastLocalVarRef -> target.name is FastLocalVarRef -> target.name
is LocalSlotRef -> target.name is LocalSlotRef -> target.name
else -> null else -> null
} }
if (targetDecl is TypeDecl.Function) {
return targetDecl.returnType
}
if (targetName != null) {
callableReturnTypeDeclByName[targetName]?.let { return it }
(seedTypeDeclByName(targetName) as? TypeDecl.Function)?.let { return it.returnType }
}
inferCallReturnClass(ref)?.let { TypeDecl.Simple(it.className, false) }
?: run {
if (targetName != null && targetName.firstOrNull()?.isUpperCase() == true) { if (targetName != null && targetName.firstOrNull()?.isUpperCase() == true) {
TypeDecl.Simple(targetName, false) TypeDecl.Simple(targetName, false)
} else { } else {
@@ -4625,6 +4692,17 @@ class Compiler(
return null return null
} }
private fun lookupLocalTypeDeclByName(name: String): TypeDecl? {
val slotLoc = lookupSlotLocation(name, includeModule = true) ?: return null
return slotTypeDeclByScopeId[slotLoc.scopeId]?.get(slotLoc.slot)
}
private fun lookupLocalObjClassByName(name: String): ObjClass? {
val slotLoc = lookupSlotLocation(name, includeModule = true) ?: return null
return slotTypeByScopeId[slotLoc.scopeId]?.get(slotLoc.slot)
?: slotTypeDeclByScopeId[slotLoc.scopeId]?.get(slotLoc.slot)?.let { resolveTypeDeclObjClass(it) }
}
private fun resolveReceiverTypeDecl(ref: ObjRef): TypeDecl? { private fun resolveReceiverTypeDecl(ref: ObjRef): TypeDecl? {
return when (ref) { return when (ref) {
is LocalSlotRef -> { is LocalSlotRef -> {
@@ -4634,8 +4712,12 @@ class Compiler(
?: nameTypeDecl[ref.name] ?: nameTypeDecl[ref.name]
?: seedTypeDeclByName(ref.name) ?: seedTypeDeclByName(ref.name)
} }
is LocalVarRef -> nameTypeDecl[ref.name] ?: seedTypeDeclByName(ref.name) is LocalVarRef -> nameTypeDecl[ref.name]
is FastLocalVarRef -> nameTypeDecl[ref.name] ?: seedTypeDeclByName(ref.name) ?: lookupLocalTypeDeclByName(ref.name)
?: seedTypeDeclByName(ref.name)
is FastLocalVarRef -> nameTypeDecl[ref.name]
?: lookupLocalTypeDeclByName(ref.name)
?: seedTypeDeclByName(ref.name)
is FieldRef -> { is FieldRef -> {
val targetDecl = resolveReceiverTypeDecl(ref.target) ?: return null val targetDecl = resolveReceiverTypeDecl(ref.target) ?: return null
val targetClass = resolveTypeDeclObjClass(targetDecl) ?: resolveReceiverClassForMember(ref.target) val targetClass = resolveTypeDeclObjClass(targetDecl) ?: resolveReceiverClassForMember(ref.target)
@@ -4655,6 +4737,7 @@ class Compiler(
} }
is MethodCallRef -> methodReturnTypeDeclByRef[ref] is MethodCallRef -> methodReturnTypeDeclByRef[ref]
is CallRef -> callReturnTypeDeclByRef[ref] is CallRef -> callReturnTypeDeclByRef[ref]
is BinaryOpRef -> inferBinaryOpReturnTypeDecl(ref)
is StatementRef -> (ref.statement as? ExpressionStatement)?.let { resolveReceiverTypeDecl(it.ref) } is StatementRef -> (ref.statement as? ExpressionStatement)?.let { resolveReceiverTypeDecl(it.ref) }
else -> null else -> null
} }
@@ -4680,11 +4763,13 @@ class Compiler(
is LocalVarRef -> nameObjClass[ref.name] is LocalVarRef -> nameObjClass[ref.name]
?.takeIf { it == ObjDynamic.type } ?.takeIf { it == ObjDynamic.type }
?: nameObjClass[ref.name] ?: nameObjClass[ref.name]
?: lookupLocalObjClassByName(ref.name)
?: nameTypeDecl[ref.name]?.let { resolveTypeDeclObjClass(it) } ?: nameTypeDecl[ref.name]?.let { resolveTypeDeclObjClass(it) }
?: resolveClassByName(ref.name) ?: resolveClassByName(ref.name)
is FastLocalVarRef -> nameObjClass[ref.name] is FastLocalVarRef -> nameObjClass[ref.name]
?.takeIf { it == ObjDynamic.type } ?.takeIf { it == ObjDynamic.type }
?: nameObjClass[ref.name] ?: nameObjClass[ref.name]
?: lookupLocalObjClassByName(ref.name)
?: nameTypeDecl[ref.name]?.let { resolveTypeDeclObjClass(it) } ?: nameTypeDecl[ref.name]?.let { resolveTypeDeclObjClass(it) }
?: resolveClassByName(ref.name) ?: resolveClassByName(ref.name)
is ClassScopeMemberRef -> { is ClassScopeMemberRef -> {
@@ -4718,6 +4803,7 @@ class Compiler(
is ThisMethodSlotCallRef -> inferMethodCallReturnClass(ref.methodName()) is ThisMethodSlotCallRef -> inferMethodCallReturnClass(ref.methodName())
is QualifiedThisMethodSlotCallRef -> inferMethodCallReturnClass(ref.methodName()) is QualifiedThisMethodSlotCallRef -> inferMethodCallReturnClass(ref.methodName())
is CallRef -> inferCallReturnClass(ref) is CallRef -> inferCallReturnClass(ref)
is BinaryOpRef -> inferBinaryOpReturnClass(ref)
is FieldRef -> { is FieldRef -> {
val targetClass = resolveReceiverClassForMember(ref.target) val targetClass = resolveReceiverClassForMember(ref.target)
inferFieldReturnClass(targetClass, ref.name) 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? { private fun inferBinaryOpReturnClass(ref: BinaryOpRef): ObjClass? {
inferBinaryOpReturnTypeDecl(ref)?.let { declared ->
resolveTypeDeclObjClass(declared)?.let { return it }
}
val leftClass = resolveReceiverClassForMember(ref.left) ?: inferObjClassFromRef(ref.left) val leftClass = resolveReceiverClassForMember(ref.left) ?: inferObjClassFromRef(ref.left)
val rightClass = resolveReceiverClassForMember(ref.right) ?: inferObjClassFromRef(ref.right) val rightClass = resolveReceiverClassForMember(ref.right) ?: inferObjClassFromRef(ref.right)
if (leftClass == null || rightClass == null) return null 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) { return when (ref.op) {
BinOp.PLUS, BinOp.MINUS -> when { BinOp.PLUS, BinOp.MINUS -> when {
leftClass == ObjInstant.type && rightClass == ObjInstant.type && ref.op == BinOp.MINUS -> ObjDuration.type leftClass == ObjInstant.type && rightClass == ObjInstant.type && ref.op == BinOp.MINUS -> ObjDuration.type
@@ -6446,7 +6627,7 @@ class Compiler(
WhenStatement(value, cases, elseCase, whenPos) WhenStatement(value, cases, elseCase, whenPos)
} else { } else {
// when { cond -> ... } // when { cond -> ... }
TODO("when without object is not yet implemented") throw ScriptError(t.pos, "when without subject is not implemented")
} }
return wrapBytecode(stmt) return wrapBytecode(stmt)
} }
@@ -6699,6 +6880,7 @@ class Compiler(
) )
compileClassInfos[qualifiedName] = CompileClassInfo( compileClassInfos[qualifiedName] = CompileClassInfo(
name = qualifiedName, name = qualifiedName,
packageName = packageName,
fieldIds = fieldIds, fieldIds = fieldIds,
methodIds = methodIds, methodIds = methodIds,
nextFieldId = fieldIds.size, nextFieldId = fieldIds.size,
@@ -6821,6 +7003,7 @@ class Compiler(
classCtx?.let { ctx -> classCtx?.let { ctx ->
compileClassInfos[className] = CompileClassInfo( compileClassInfos[className] = CompileClassInfo(
name = className, name = className,
packageName = packageName,
fieldIds = ctx.memberFieldIds.toMap(), fieldIds = ctx.memberFieldIds.toMap(),
methodIds = ctx.memberMethodIds.toMap(), methodIds = ctx.memberMethodIds.toMap(),
nextFieldId = ctx.nextFieldId, nextFieldId = ctx.nextFieldId,
@@ -6862,6 +7045,7 @@ class Compiler(
val baseIds = collectBaseMemberIds(baseSpecs.map { it.name }) val baseIds = collectBaseMemberIds(baseSpecs.map { it.name })
compileClassInfos[className] = CompileClassInfo( compileClassInfos[className] = CompileClassInfo(
name = className, name = className,
packageName = packageName,
fieldIds = baseIds.fieldIds, fieldIds = baseIds.fieldIds,
methodIds = baseIds.methodIds, methodIds = baseIds.methodIds,
nextFieldId = baseIds.nextFieldId, nextFieldId = baseIds.nextFieldId,
@@ -7110,6 +7294,7 @@ class Compiler(
} }
compileClassInfos[qualifiedName] = CompileClassInfo( compileClassInfos[qualifiedName] = CompileClassInfo(
name = qualifiedName, name = qualifiedName,
packageName = packageName,
fieldIds = ctx.memberFieldIds.toMap(), fieldIds = ctx.memberFieldIds.toMap(),
methodIds = ctx.memberMethodIds.toMap(), methodIds = ctx.memberMethodIds.toMap(),
nextFieldId = ctx.nextFieldId, nextFieldId = ctx.nextFieldId,
@@ -7125,6 +7310,7 @@ class Compiler(
classCtx?.let { ctx -> classCtx?.let { ctx ->
compileClassInfos[qualifiedName] = CompileClassInfo( compileClassInfos[qualifiedName] = CompileClassInfo(
name = qualifiedName, name = qualifiedName,
packageName = packageName,
fieldIds = ctx.memberFieldIds.toMap(), fieldIds = ctx.memberFieldIds.toMap(),
methodIds = ctx.memberMethodIds.toMap(), methodIds = ctx.memberMethodIds.toMap(),
nextFieldId = ctx.nextFieldId, nextFieldId = ctx.nextFieldId,
@@ -7211,6 +7397,7 @@ class Compiler(
} }
compileClassInfos[qualifiedName] = CompileClassInfo( compileClassInfos[qualifiedName] = CompileClassInfo(
name = qualifiedName, name = qualifiedName,
packageName = packageName,
fieldIds = ctx.memberFieldIds.toMap(), fieldIds = ctx.memberFieldIds.toMap(),
methodIds = ctx.memberMethodIds.toMap(), methodIds = ctx.memberMethodIds.toMap(),
nextFieldId = ctx.nextFieldId, nextFieldId = ctx.nextFieldId,
@@ -8028,6 +8215,10 @@ class Compiler(
inferredReturnClass inferredReturnClass
} }
} }
val inferredReturnDecl = returnTypeDecl ?: inferredReturnClass?.let { TypeDecl.Simple(it.className, false) }
if (declKind != SymbolKind.MEMBER && inferredReturnDecl != null) {
callableReturnTypeDeclByName[name] = inferredReturnDecl
}
val fnStatements = rawFnStatements?.let { stmt -> val fnStatements = rawFnStatements?.let { stmt ->
if (!compileBytecode) return@let stmt if (!compileBytecode) return@let stmt
val paramKnownClasses = mutableMapOf<String, ObjClass>() val paramKnownClasses = mutableMapOf<String, ObjClass>()
@@ -8138,7 +8329,7 @@ class Compiler(
?: context.parent?.get(localName) ?: context.parent?.get(localName)
?: context.get(localName) ?: context.get(localName)
?: continue ?: continue
val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property) { val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is ObjProperty) {
context.resolve(record, localName) context.resolve(record, localName)
} else { } else {
record.value record.value
@@ -8390,7 +8581,7 @@ class Compiler(
is ImplicitThisMethodCallRef -> { is ImplicitThisMethodCallRef -> {
when (directRef.methodName()) { when (directRef.methodName()) {
"iterator" -> ObjIterator "iterator" -> ObjIterator
"lazy" -> ObjLazyDelegate.type "lazy" -> resolveClassByName("lazy") ?: inferMethodCallReturnClass(directRef.methodName())
else -> inferMethodCallReturnClass(directRef.methodName()) else -> inferMethodCallReturnClass(directRef.methodName())
} }
} }
@@ -8409,7 +8600,7 @@ class Compiler(
when { when {
target is LocalSlotRef -> { target is LocalSlotRef -> {
when (target.name) { when (target.name) {
"lazy" -> ObjLazyDelegate.type "lazy" -> resolveClassByName("lazy")
"iterator" -> ObjIterator "iterator" -> ObjIterator
"flow" -> ObjFlow.type "flow" -> ObjFlow.type
"launch" -> ObjDeferred.type "launch" -> ObjDeferred.type
@@ -8420,7 +8611,7 @@ class Compiler(
} }
target is LocalVarRef -> { target is LocalVarRef -> {
when (target.name) { when (target.name) {
"lazy" -> ObjLazyDelegate.type "lazy" -> resolveClassByName("lazy")
"iterator" -> ObjIterator "iterator" -> ObjIterator
"flow" -> ObjFlow.type "flow" -> ObjFlow.type
"launch" -> ObjDeferred.type "launch" -> ObjDeferred.type
@@ -8459,7 +8650,9 @@ class Compiler(
?: unwrapDirectRef(initializer)?.let { inferObjClassFromRef(it) } ?: unwrapDirectRef(initializer)?.let { inferObjClassFromRef(it) }
?: throw ScriptError(initializer.pos, "Delegate type must be known at compile time") ?: throw ScriptError(initializer.pos, "Delegate type must be known at compile time")
if (initClass !== delegateClass && if (initClass !== delegateClass &&
initClass.logicalName != delegateClass.logicalName &&
!initClass.allParentsSet.contains(delegateClass) && !initClass.allParentsSet.contains(delegateClass) &&
!initClass.allParentsSet.any { it.logicalName == delegateClass.logicalName } &&
!initClass.allImplementingNames.contains(delegateClass.className) !initClass.allImplementingNames.contains(delegateClass.className)
) { ) {
throw ScriptError( throw ScriptError(
@@ -8549,7 +8742,9 @@ class Compiler(
if (closedParent != null) { if (closedParent != null) {
throw ScriptError(Pos.builtIn, "can't inherit from closed class ${closedParent.className}") 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) { if (stub is ObjInstanceClass) {
for ((fieldName, fieldId) in info.fieldIds) { for ((fieldName, fieldId) in info.fieldIds) {
@@ -8893,7 +9088,10 @@ class Compiler(
val effectiveEqToken = if (isProperty) null else eqToken val effectiveEqToken = if (isProperty) null else eqToken
// Register the local name at compile time so that subsequent identifiers can be emitted as fast locals // Register the local name at compile time so that subsequent identifiers can be emitted as fast locals
if (!isStatic && declaringClassNameCaptured == null) declareLocalName(name, isMutable) val isTopLevelExtern = actualExtern && declaringClassNameCaptured == null && slotPlanStack.size == 1
if (!isStatic && declaringClassNameCaptured == null && (!actualExtern || isTopLevelExtern)) {
declareLocalName(name, isMutable)
}
val declKind = if (codeContexts.lastOrNull() is CodeContext.ClassBody) { val declKind = if (codeContexts.lastOrNull() is CodeContext.ClassBody) {
SymbolKind.MEMBER SymbolKind.MEMBER
} else { } else {
@@ -8902,6 +9100,8 @@ class Compiler(
resolutionSink?.declareSymbol(name, declKind, isMutable, nameStartPos, isOverride = isOverride) resolutionSink?.declareSymbol(name, declKind, isMutable, nameStartPos, isOverride = isOverride)
if (declKind == SymbolKind.MEMBER && extTypeName == null) { if (declKind == SymbolKind.MEMBER && extTypeName == null) {
(codeContexts.lastOrNull() as? CodeContext.ClassBody)?.declaredMembers?.add(name) (codeContexts.lastOrNull() as? CodeContext.ClassBody)?.declaredMembers?.add(name)
} else if (actualExtern) {
externBindingNames.add(name)
} }
val isDelegate = if (isAbstract || actualExtern) { val isDelegate = if (isAbstract || actualExtern) {
@@ -8967,7 +9167,11 @@ class Compiler(
if (isDelegate && initialExpression != null) { if (isDelegate && initialExpression != null) {
ensureDelegateType(initialExpression) 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") throw ScriptError(initialExpression.pos, "lazy delegate is read-only")
} }
} }
@@ -9059,6 +9263,7 @@ class Compiler(
name, name,
isMutable, isMutable,
visibility, visibility,
actualExtern,
initialExpression, initialExpression,
isTransient, isTransient,
declaredType, 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 { override suspend fun callOn(scope: Scope): Obj {
val resolved = read() val resolved = read()
if (resolved === this) { if (resolved === this) {
@@ -193,4 +206,18 @@ class RecordSlotRef(
record.value = value record.value = value
} }
} }
suspend fun write(scope: Scope, name: String?, value: Obj): Boolean {
val direct = record.value
if (name != null && (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || direct is ObjProperty)) {
scope.assign(record, name, value)
return true
}
when (direct) {
is ScopeSlotRef -> direct.write(value)
is RecordSlotRef -> if (direct.write(scope, name, value)) return true else direct.write(value)
else -> record.value = value
}
return false
}
} }
@@ -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
}
}
@@ -26,7 +26,10 @@ val idNextChars = { d: Char -> d.isLetter() || d == '_' || d.isDigit() || d == '
val idFirstChars = { d: Char -> d.isLetter() || d == '_' || d == '$' } val idFirstChars = { d: Char -> d.isLetter() || d == '_' || d == '$' }
fun parseLyng(source: Source): List<Token> { fun parseLyng(source: Source): List<Token> {
val p = Parser(fromPos = source.startPos) val p = Parser(
fromPos = source.startPos,
interpolationEnabled = detectInterpolationEnabled(source.text)
)
val tokens = mutableListOf<Token>() val tokens = mutableListOf<Token>()
do { do {
val t = p.nextToken() val t = p.nextToken()
@@ -35,9 +38,70 @@ fun parseLyng(source: Source): List<Token> {
return tokens return tokens
} }
private class Parser(fromPos: Pos) { private fun parseLyng(source: Source, interpolationEnabled: Boolean): List<Token> {
val p = Parser(
fromPos = source.startPos,
interpolationEnabled = interpolationEnabled
)
val tokens = mutableListOf<Token>()
do {
val t = p.nextToken()
tokens += t
} while (t.type != Token.Type.EOF)
return tokens
}
private fun detectInterpolationEnabled(text: String): Boolean {
// Per-file feature switch in leading comments:
// // feature: interpolation: off
// // feature: interpolation: on
var enabled = true
val lines = text.split('\n')
var i = 0
while (i < lines.size) {
val line = lines[i]
val trimmed = line.trim()
if (trimmed.isBlank()) {
i++
continue
}
if (i == 0 && trimmed.startsWith("#!")) {
i++
continue
}
if (trimmed.startsWith("//")) {
val m = Regex("^//\\s*feature\\s*:\\s*interpolation\\s*:\\s*(on|off)\\s*$", RegexOption.IGNORE_CASE)
.matchEntire(trimmed)
if (m != null) {
enabled = m.groupValues[1].equals("on", ignoreCase = true)
}
i++
continue
}
if (trimmed.startsWith("/*")) {
// Skip leading block comment(s); directives are intentionally line-comment based.
var j = i
var closed = false
while (j < lines.size) {
if (lines[j].contains("*/")) {
closed = true
break
}
j++
}
if (!closed) break
i = j + 1
continue
}
break
}
return enabled
}
private class Parser(fromPos: Pos, private val interpolationEnabled: Boolean = true) {
private val pos = MutablePos(fromPos) private val pos = MutablePos(fromPos)
private val bufferedTokens = ArrayDeque<Token>()
/** /**
* Immutable copy of current position * Immutable copy of current position
@@ -47,6 +111,7 @@ private class Parser(fromPos: Pos) {
private fun raise(msg: String): Nothing = throw ScriptError(currentPos, msg) private fun raise(msg: String): Nothing = throw ScriptError(currentPos, msg)
fun nextToken(): Token { fun nextToken(): Token {
if (bufferedTokens.isNotEmpty()) return bufferedTokens.removeFirst()
skipws() skipws()
if (pos.end) return Token("", currentPos, Token.Type.EOF) if (pos.end) return Token("", currentPos, Token.Type.EOF)
val from = currentPos val from = currentPos
@@ -296,7 +361,7 @@ private class Parser(fromPos: Pos) {
Token(":", from, Token.Type.COLON) Token(":", from, Token.Type.COLON)
} }
'"' -> loadStringToken() '"' -> loadStringTokens(from)
in digitsSet -> { in digitsSet -> {
pos.back() pos.back()
@@ -485,11 +550,6 @@ private class Parser(fromPos: Pos) {
private fun loadStringToken(): Token { private fun loadStringToken(): Token {
val start = currentPos val start = currentPos
// if (currentChar == '"') pos.advance()
// else start = start.back()
// start = start.back()
val sb = StringBuilder() val sb = StringBuilder()
var newlineDetected = false var newlineDetected = false
while (currentChar != '"') { while (currentChar != '"') {
@@ -548,6 +608,271 @@ private class Parser(fromPos: Pos) {
return Token(result, start, Token.Type.STRING) return Token(result, start, Token.Type.STRING)
} }
private sealed interface StringChunk {
data class Literal(val text: String, val pos: Pos) : StringChunk
data class Expr(val tokens: List<Token>, val pos: Pos) : StringChunk
}
private fun loadStringTokens(startQuotePos: Pos): Token {
if (!interpolationEnabled) return loadStringToken()
val tokenPos = currentPos
val chunks = mutableListOf<StringChunk>()
val literal = StringBuilder()
var newlineDetected = false
var hasInterpolation = false
fun flushLiteralChunk() {
if (literal.isNotEmpty()) {
chunks += StringChunk.Literal(literal.toString(), tokenPos)
literal.clear()
}
}
while (currentChar != '"') {
if (pos.end) throw ScriptError(startQuotePos, "unterminated string started there")
when (currentChar) {
'\\' -> {
pos.advance() ?: raise("unterminated string")
when (currentChar) {
'n' -> {
literal.append('\n'); pos.advance()
}
'r' -> {
literal.append('\r'); pos.advance()
}
't' -> {
literal.append('\t'); pos.advance()
}
'"' -> {
literal.append('"'); pos.advance()
}
'\\' -> {
literal.append('\\'); pos.advance()
}
'u' -> {
literal.append(loadUnicodeEscape(tokenPos))
}
'$' -> {
// Backslash-escaped dollar is always literal.
literal.append('$')
pos.advance()
}
else -> {
literal.append('\\').append(currentChar)
pos.advance()
}
}
}
'$' -> {
pos.advance()
when {
currentChar == '$' -> {
// $$ -> literal '$'
literal.append('$')
pos.advance()
}
currentChar == '{' -> {
hasInterpolation = true
flushLiteralChunk()
val exprStart = pos.toPos()
pos.advance() // consume '{'
val exprText = readInterpolationExprText(startQuotePos)
val exprTokens = parseEmbeddedExpressionTokens(exprText, exprStart)
chunks += StringChunk.Expr(exprTokens, exprStart)
}
idFirstChars(currentChar) -> {
hasInterpolation = true
flushLiteralChunk()
val idPos = pos.toPos()
val id = loadChars(idNextChars)
val idToken = Token(id, idPos, Token.Type.ID)
chunks += StringChunk.Expr(listOf(idToken), idPos)
}
else -> {
// Bare '$' before non-interpolation text stays literal.
literal.append('$')
}
}
}
'\n', '\r' -> {
newlineDetected = true
literal.append(currentChar)
pos.advance()
}
else -> {
literal.append(currentChar)
pos.advance()
}
}
}
pos.advance() // closing quote
if (!hasInterpolation) {
val result = literal.toString().let { if (newlineDetected) fixMultilineStringLiteral(it) else it }
return Token(result, tokenPos, Token.Type.STRING)
}
flushLiteralChunk()
if (chunks.isEmpty()) {
return Token("", tokenPos, Token.Type.STRING)
}
val expanded = mutableListOf<Token>()
expanded += Token("(", tokenPos, Token.Type.LPAREN)
expanded += Token("", tokenPos, Token.Type.STRING)
var emittedPieces = 1
for (chunk in chunks) {
val pieceTokens = when (chunk) {
is StringChunk.Literal -> {
if (chunk.text.isEmpty()) emptyList()
else listOf(Token(chunk.text, chunk.pos, Token.Type.STRING))
}
is StringChunk.Expr -> {
if (chunk.tokens.isEmpty()) throw ScriptError(chunk.pos, "empty interpolation expression")
if (chunk.tokens.size == 1) {
chunk.tokens
} else {
listOf(Token("(", chunk.pos, Token.Type.LPAREN)) +
chunk.tokens +
listOf(Token(")", chunk.pos, Token.Type.RPAREN))
}
}
}
if (pieceTokens.isEmpty()) continue
if (emittedPieces > 0) expanded += Token("+", tokenPos, Token.Type.PLUS)
expanded += pieceTokens
emittedPieces++
}
expanded += Token(")", tokenPos, Token.Type.RPAREN)
val first = expanded.first()
for (i in 1 until expanded.size) bufferedTokens.addLast(expanded[i])
return first
}
private fun parseEmbeddedExpressionTokens(text: String, exprPos: Pos): List<Token> {
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.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 {
val out = StringBuilder()
var depth = 1
while (!pos.end) {
val ch = currentChar
if (ch == '"') {
appendQuoted(out, '"')
continue
}
if (ch == '\'') {
appendQuoted(out, '\'')
continue
}
if (ch == '/' && peekChar() == '/') {
out.append('/').append('/')
pos.advance()
pos.advance()
while (!pos.end && currentChar != '\n') {
out.append(currentChar)
pos.advance()
}
continue
}
if (ch == '/' && peekChar() == '*') {
out.append('/').append('*')
pos.advance()
pos.advance()
var closed = false
while (!pos.end) {
val c = currentChar
if (c == '*' && peekChar() == '/') {
out.append('*').append('/')
pos.advance()
pos.advance()
closed = true
break
}
out.append(c)
pos.advance()
}
if (!closed) throw ScriptError(start, "unterminated block comment in interpolation")
continue
}
if (ch == '{') {
depth++
out.append(ch)
pos.advance()
continue
}
if (ch == '}') {
depth--
if (depth == 0) {
pos.advance() // consume closing '}'
return out.toString()
}
out.append(ch)
pos.advance()
continue
}
out.append(ch)
pos.advance()
}
throw ScriptError(start, "unterminated interpolation expression")
}
private fun appendQuoted(out: StringBuilder, quote: Char) {
out.append(quote)
pos.advance()
while (!pos.end) {
val c = currentChar
out.append(c)
pos.advance()
if (c == '\\') {
if (!pos.end) {
out.append(currentChar)
pos.advance()
}
continue
}
if (c == quote) return
}
}
private fun peekChar(): Char {
if (pos.end) return 0.toChar()
val mark = pos.toPos()
pos.advance()
val result = currentChar
pos.resetTo(mark)
return result
}
private fun loadUnicodeEscape(start: Pos): Char { private fun loadUnicodeEscape(start: Pos): Char {
// Called when currentChar points to 'u' right after a backslash. // Called when currentChar points to 'u' right after a backslash.
if (currentChar != 'u') throw ScriptError(currentPos, "expected unicode escape marker: u") if (currentChar != 'u') throw ScriptError(currentPos, "expected unicode escape marker: u")
@@ -17,6 +17,7 @@
package net.sergeych.lyng package net.sergeych.lyng
import com.ionspin.kotlin.bignum.decimal.BigDecimal
import net.sergeych.lyng.obj.* import net.sergeych.lyng.obj.*
/** /**
@@ -133,3 +134,6 @@ fun ScopeFacade.raiseIllegalOperation(message: String = "Operation is illegal"):
fun ScopeFacade.raiseIterationFinished(): Nothing = fun ScopeFacade.raiseIterationFinished(): Nothing =
raiseError(ObjIterationFinishedException(requireScope())) raiseError(ObjIterationFinishedException(requireScope()))
suspend fun ScopeFacade.newDecimal(value: BigDecimal): ObjInstance =
ObjDecimalSupport.newDecimal(this, value)
@@ -27,7 +27,11 @@ import net.sergeych.lyng.bytecode.CmdVm
import net.sergeych.lyng.miniast.* import net.sergeych.lyng.miniast.*
import net.sergeych.lyng.obj.* import net.sergeych.lyng.obj.*
import net.sergeych.lyng.pacman.ImportManager import net.sergeych.lyng.pacman.ImportManager
import net.sergeych.lyng.stdlib_included.complexLyng
import net.sergeych.lyng.stdlib_included.decimalLyng
import net.sergeych.lyng.stdlib_included.matrixLyng
import net.sergeych.lyng.stdlib_included.observableLyng import net.sergeych.lyng.stdlib_included.observableLyng
import net.sergeych.lyng.stdlib_included.operatorsLyng
import net.sergeych.lyng.stdlib_included.rootLyng import net.sergeych.lyng.stdlib_included.rootLyng
import net.sergeych.lynon.ObjLynonClass import net.sergeych.lynon.ObjLynonClass
import net.sergeych.mp_tools.globalDefer import net.sergeych.mp_tools.globalDefer
@@ -46,6 +50,28 @@ class Script(
// private val catchReturn: Boolean = false, // private val catchReturn: Boolean = false,
) : Statement() { ) : Statement() {
fun statements(): List<Statement> = statements 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 { override suspend fun execute(scope: Scope): Obj {
scope.pos = pos scope.pos = pos
val execScope = resolveModuleScope(scope) ?: scope val execScope = resolveModuleScope(scope) ?: scope
@@ -75,6 +101,19 @@ class Script(
return ObjVoid 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) { private suspend fun seedModuleSlots(scope: Scope, seedScope: Scope) {
if (importBindings.isEmpty() && importedModules.isEmpty()) return if (importBindings.isEmpty() && importedModules.isEmpty()) return
seedImportBindings(scope, seedScope) seedImportBindings(scope, seedScope)
@@ -213,6 +252,44 @@ class Script(
companion object { companion object {
private suspend fun ScopeFacade.numberToDouble(value: Obj): Double =
ObjDecimalSupport.toDoubleOrNull(value) ?: value.toDouble()
private suspend fun ScopeFacade.decimalAwareUnaryMath(
value: Obj,
exactDecimal: (suspend ScopeFacade.(Obj) -> Obj?)? = null,
fallback: (Double) -> Double
): Obj {
exactDecimal?.let { exact ->
exact(value)?.let { return it }
}
if (ObjDecimalSupport.isDecimalValue(value)) {
return ObjDecimalSupport.fromRealLike(this, value, fallback(numberToDouble(value)))
?: raiseIllegalState("failed to convert Real result back to Decimal")
}
return ObjReal(fallback(numberToDouble(value)))
}
private suspend fun ScopeFacade.decimalAwareRoundLike(
value: Obj,
exactDecimal: suspend ScopeFacade.(Obj) -> Obj?,
realFallback: (Double) -> Double
): Obj {
if (value is ObjInt) return value
exactDecimal(value)?.let { return it }
return ObjReal(realFallback(numberToDouble(value)))
}
private suspend fun ScopeFacade.decimalAwarePow(base: Obj, exponent: Obj): Obj {
ObjDecimalSupport.exactPow(this, base, exponent)?.let { return it }
if (ObjDecimalSupport.isDecimalValue(base) || ObjDecimalSupport.isDecimalValue(exponent)) {
return ObjDecimalSupport.fromRealLike(this, base, numberToDouble(base).pow(numberToDouble(exponent)))
?: ObjDecimalSupport.fromRealLike(this, exponent, numberToDouble(base).pow(numberToDouble(exponent)))
?: raiseIllegalState("failed to convert Real pow result back to Decimal")
}
return ObjReal(numberToDouble(base).pow(numberToDouble(exponent)))
}
/** /**
* Create new scope using a standard safe set of modules, using [defaultImportManager]. It is * Create new scope using a standard safe set of modules, using [defaultImportManager]. It is
* suspended as first time invocation requires compilation of standard library or other * suspended as first time invocation requires compilation of standard library or other
@@ -250,87 +327,92 @@ class Script(
} }
addFn("floor") { addFn("floor") {
val x = args.firstAndOnly() val x = args.firstAndOnly()
(if (x is ObjInt) x decimalAwareRoundLike(x, ObjDecimalSupport::exactFloor, ::floor)
else ObjReal(floor(x.toDouble())))
} }
addFn("ceil") { addFn("ceil") {
val x = args.firstAndOnly() val x = args.firstAndOnly()
(if (x is ObjInt) x decimalAwareRoundLike(x, ObjDecimalSupport::exactCeil, ::ceil)
else ObjReal(ceil(x.toDouble())))
} }
addFn("round") { addFn("round") {
val x = args.firstAndOnly() val x = args.firstAndOnly()
(if (x is ObjInt) x decimalAwareRoundLike(x, ObjDecimalSupport::exactRound, ::round)
else ObjReal(round(x.toDouble())))
} }
addFn("sin") { addFn("sin") {
ObjReal(sin(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sin)
} }
addFn("cos") { addFn("cos") {
ObjReal(cos(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::cos)
} }
addFn("tan") { addFn("tan") {
ObjReal(tan(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::tan)
} }
addFn("asin") { addFn("asin") {
ObjReal(asin(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::asin)
} }
addFn("acos") { addFn("acos") {
ObjReal(acos(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::acos)
} }
addFn("atan") { addFn("atan") {
ObjReal(atan(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::atan)
} }
addFn("sinh") { addFn("sinh") {
ObjReal(sinh(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sinh)
} }
addFn("cosh") { addFn("cosh") {
ObjReal(cosh(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::cosh)
} }
addFn("tanh") { addFn("tanh") {
ObjReal(tanh(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::tanh)
} }
addFn("asinh") { addFn("asinh") {
ObjReal(asinh(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::asinh)
} }
addFn("acosh") { addFn("acosh") {
ObjReal(acosh(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::acosh)
} }
addFn("atanh") { addFn("atanh") {
ObjReal(atanh(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::atanh)
} }
addFn("exp") { addFn("exp") {
ObjReal(exp(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::exp)
} }
addFn("ln") { addFn("ln") {
ObjReal(ln(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::ln)
} }
addFn("log10") { addFn("log10") {
ObjReal(log10(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::log10)
} }
addFn("log2") { addFn("log2") {
ObjReal(log2(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::log2)
} }
addFn("pow") { addFn("pow") {
requireExactCount(2) requireExactCount(2)
ObjReal( decimalAwarePow(args[0], args[1])
(args[0].toDouble()).pow(args[1].toDouble())
)
} }
addFn("sqrt") { addItem(
ObjReal( "sqrt",
sqrt(args.firstAndOnly().toDouble()) false,
ObjExternCallable.fromBridge {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sqrt)
},
recordType = ObjRecord.Type.Fun,
typeDecl = TypeDecl.Function(
receiver = null,
params = listOf(TypeDecl.TypeAny),
returnType = TypeDecl.Simple("Real", false),
nullable = false
)
) )
}
addFn("abs") { addFn("abs") {
val x = args.firstAndOnly() val x = args.firstAndOnly()
if (x is ObjInt) ObjInt(x.value.absoluteValue) else ObjReal(x.toDouble().absoluteValue) if (x is ObjInt) ObjInt(x.value.absoluteValue)
else decimalAwareUnaryMath(x, ObjDecimalSupport::exactAbs) { it.absoluteValue }
} }
addFnDoc( addFnDoc(
@@ -505,10 +587,6 @@ class Script(
cachedValue cachedValue
} }
} }
addFn("lazy") {
val builder = requireOnlyArg<Obj>()
ObjLazyDelegate(builder, requireScope())
}
addVoidFn("delay") { addVoidFn("delay") {
val a = args.firstAndOnly() val a = args.firstAndOnly()
when (a) { when (a) {
@@ -582,12 +660,88 @@ class Script(
type = type("lyng.Real") type = type("lyng.Real")
) )
getOrCreateNamespace("Math").apply { getOrCreateNamespace("Math").apply {
fun ensureFn(name: String, fn: suspend ScopeFacade.() -> Obj) {
if (members.containsKey(name)) return
addFn(name, code = fn)
}
addConstDoc( addConstDoc(
name = "PI", name = "PI",
value = pi, value = pi,
doc = "The mathematical constant pi (π) in the Math namespace.", doc = "The mathematical constant pi (π) in the Math namespace.",
type = type("lyng.Real") type = type("lyng.Real")
) )
ensureFn("floor") {
val x = args.firstAndOnly()
decimalAwareRoundLike(x, ObjDecimalSupport::exactFloor, ::floor)
}
ensureFn("ceil") {
val x = args.firstAndOnly()
decimalAwareRoundLike(x, ObjDecimalSupport::exactCeil, ::ceil)
}
ensureFn("round") {
val x = args.firstAndOnly()
decimalAwareRoundLike(x, ObjDecimalSupport::exactRound, ::round)
}
ensureFn("sin") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sin)
}
ensureFn("cos") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::cos)
}
ensureFn("tan") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::tan)
}
ensureFn("asin") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::asin)
}
ensureFn("acos") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::acos)
}
ensureFn("atan") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::atan)
}
ensureFn("sinh") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sinh)
}
ensureFn("cosh") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::cosh)
}
ensureFn("tanh") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::tanh)
}
ensureFn("asinh") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::asinh)
}
ensureFn("acosh") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::acosh)
}
ensureFn("atanh") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::atanh)
}
ensureFn("exp") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::exp)
}
ensureFn("ln") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::ln)
}
ensureFn("log10") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::log10)
}
ensureFn("log2") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::log2)
}
ensureFn("pow") {
requireExactCount(2)
decimalAwarePow(args[0], args[1])
}
ensureFn("sqrt") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sqrt)
}
ensureFn("abs") {
val x = args.firstAndOnly()
if (x is ObjInt) ObjInt(x.value.absoluteValue)
else decimalAwareUnaryMath(x, ObjDecimalSupport::exactAbs) { it.absoluteValue }
}
} }
} }
@@ -696,6 +850,44 @@ class Script(
module.addConst("ChangeRejectionException", ObjChangeRejectionExceptionClass) module.addConst("ChangeRejectionException", ObjChangeRejectionExceptionClass)
module.eval(Source("lyng.observable", observableLyng)) 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") { addPackage("lyng.buffer") {
it.addConstDoc( it.addConstDoc(
name = "Buffer", name = "Buffer",
@@ -24,6 +24,7 @@ class VarDeclStatement(
val name: String, val name: String,
val isMutable: Boolean, val isMutable: Boolean,
val visibility: Visibility, val visibility: Visibility,
val actualExtern: Boolean,
val initializer: Statement?, val initializer: Statement?,
val isTransient: Boolean, val isTransient: Boolean,
val typeDecl: TypeDecl?, val typeDecl: TypeDecl?,
@@ -42,6 +42,9 @@ class BytecodeCompiler(
private val callableReturnTypeByScopeId: Map<Int, Map<Int, ObjClass>> = emptyMap(), private val callableReturnTypeByScopeId: Map<Int, Map<Int, ObjClass>> = emptyMap(),
private val callableReturnTypeByName: Map<String, ObjClass> = emptyMap(), private val callableReturnTypeByName: Map<String, ObjClass> = emptyMap(),
private val externCallableNames: Set<String> = emptySet(), private val externCallableNames: Set<String> = emptySet(),
private val externBindingNames: Set<String> = emptySet(),
private val preparedModuleBindingNames: Set<String> = emptySet(),
private val scopeRefPosByName: Map<String, Pos> = emptyMap(),
private val lambdaCaptureEntriesByRef: Map<ValueFnRef, List<LambdaCaptureEntry>> = emptyMap(), private val lambdaCaptureEntriesByRef: Map<ValueFnRef, List<LambdaCaptureEntry>> = emptyMap(),
) { ) {
private val useScopeSlots: Boolean = allowedScopeNames != null || scopeSlotNameSet != null private val useScopeSlots: Boolean = allowedScopeNames != null || scopeSlotNameSet != null
@@ -52,12 +55,15 @@ class BytecodeCompiler(
private var scopeSlotIndices = IntArray(0) private var scopeSlotIndices = IntArray(0)
private var scopeSlotNames = emptyArray<String?>() private var scopeSlotNames = emptyArray<String?>()
private var scopeSlotIsModule = BooleanArray(0) private var scopeSlotIsModule = BooleanArray(0)
private var scopeSlotRequiresPreparedBinding = BooleanArray(0)
private var scopeSlotRefPos = emptyArray<Pos?>()
private var scopeSlotMutables = BooleanArray(0) private var scopeSlotMutables = BooleanArray(0)
private var scopeKeyByIndex = emptyArray<ScopeSlotKey?>() private var scopeKeyByIndex = emptyArray<ScopeSlotKey?>()
private val scopeSlotMap = LinkedHashMap<ScopeSlotKey, Int>() private val scopeSlotMap = LinkedHashMap<ScopeSlotKey, Int>()
private val scopeSlotNameMap = LinkedHashMap<ScopeSlotKey, String>() private val scopeSlotNameMap = LinkedHashMap<ScopeSlotKey, String>()
private val scopeSlotMutableMap = LinkedHashMap<ScopeSlotKey, Boolean>() private val scopeSlotMutableMap = LinkedHashMap<ScopeSlotKey, Boolean>()
private val scopeSlotIndexByName = LinkedHashMap<String, Int>() private val scopeSlotIndexByName = LinkedHashMap<String, Int>()
private val scopeSlotRefPosByKey = LinkedHashMap<ScopeSlotKey, Pos>()
private val pendingScopeNameRefs = LinkedHashSet<String>() private val pendingScopeNameRefs = LinkedHashSet<String>()
private val addrSlotByScopeSlot = LinkedHashMap<Int, Int>() private val addrSlotByScopeSlot = LinkedHashMap<Int, Int>()
private data class LocalSlotInfo(val name: String, val isMutable: Boolean, val isDelegated: Boolean) private data class LocalSlotInfo(val name: String, val isMutable: Boolean, val isDelegated: Boolean)
@@ -118,6 +124,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -139,6 +147,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -157,6 +167,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -175,6 +187,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -193,6 +207,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -211,6 +227,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -229,6 +247,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -247,6 +267,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -265,6 +287,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -283,6 +307,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -301,6 +327,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -321,6 +349,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -339,6 +369,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -357,6 +389,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -375,6 +409,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -394,6 +430,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -415,6 +453,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -438,6 +478,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -458,6 +500,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -533,6 +577,7 @@ class BytecodeCompiler(
resolved = SlotType.INT resolved = SlotType.INT
} }
if (mapped < scopeSlotCount && resolved != SlotType.UNKNOWN) { if (mapped < scopeSlotCount && resolved != SlotType.UNKNOWN) {
noteScopeSlotRef(mapped, ref.pos())
val addrSlot = ensureScopeAddr(mapped) val addrSlot = ensureScopeAddr(mapped)
val local = allocSlot() val local = allocSlot()
emitLoadFromAddr(addrSlot, local, resolved) emitLoadFromAddr(addrSlot, local, resolved)
@@ -543,6 +588,7 @@ class BytecodeCompiler(
return CompiledValue(local, resolved) return CompiledValue(local, resolved)
} }
if (mapped < scopeSlotCount && resolved == SlotType.UNKNOWN) { if (mapped < scopeSlotCount && resolved == SlotType.UNKNOWN) {
noteScopeSlotRef(mapped, ref.pos())
val addrSlot = ensureScopeAddr(mapped) val addrSlot = ensureScopeAddr(mapped)
val local = allocSlot() val local = allocSlot()
emitLoadFromAddr(addrSlot, local, SlotType.OBJ) emitLoadFromAddr(addrSlot, local, SlotType.OBJ)
@@ -562,6 +608,7 @@ class BytecodeCompiler(
} }
if (allowLocalSlots) { if (allowLocalSlots) {
scopeSlotIndexByName[ref.name]?.let { slot -> scopeSlotIndexByName[ref.name]?.let { slot ->
noteScopeSlotRef(slot, callSitePos())
val resolved = slotTypes[slot] ?: SlotType.UNKNOWN val resolved = slotTypes[slot] ?: SlotType.UNKNOWN
return CompiledValue(slot, resolved) return CompiledValue(slot, resolved)
} }
@@ -584,6 +631,7 @@ class BytecodeCompiler(
return CompiledValue(slot, resolved) return CompiledValue(slot, resolved)
} }
scopeSlotIndexByName[ref.name]?.let { slot -> scopeSlotIndexByName[ref.name]?.let { slot ->
noteScopeSlotRef(slot, callSitePos())
val resolved = slotTypes[slot] ?: SlotType.UNKNOWN val resolved = slotTypes[slot] ?: SlotType.UNKNOWN
return CompiledValue(slot, resolved) return CompiledValue(slot, resolved)
} }
@@ -595,6 +643,7 @@ class BytecodeCompiler(
val slot = ref.slotIndex() val slot = ref.slotIndex()
val resolved = slotTypes[slot] ?: SlotType.UNKNOWN val resolved = slotTypes[slot] ?: SlotType.UNKNOWN
if (slot < scopeSlotCount && resolved != SlotType.UNKNOWN) { if (slot < scopeSlotCount && resolved != SlotType.UNKNOWN) {
noteScopeSlotRef(slot, callSitePos())
val addrSlot = ensureScopeAddr(slot) val addrSlot = ensureScopeAddr(slot)
val local = allocSlot() val local = allocSlot()
emitLoadFromAddr(addrSlot, local, resolved) emitLoadFromAddr(addrSlot, local, resolved)
@@ -1088,7 +1137,6 @@ class BytecodeCompiler(
private fun isDelegateClass(receiverClass: ObjClass): Boolean = private fun isDelegateClass(receiverClass: ObjClass): Boolean =
receiverClass.className == "Delegate" || receiverClass.className == "Delegate" ||
receiverClass.className == "LazyDelegate" ||
receiverClass.implementingNames.contains("Delegate") receiverClass.implementingNames.contains("Delegate")
private fun operatorMemberName(op: BinOp): String? = when (op) { private fun operatorMemberName(op: BinOp): String? = when (op) {
@@ -2396,7 +2444,8 @@ class BytecodeCompiler(
builder.emit(Opcode.THROW, posId, msgSlot) builder.emit(Opcode.THROW, posId, msgSlot)
return value return value
} }
val slot = resolveSlot(localTarget) val slot = resolveCapturedOwnerScopeSlot(localTarget)
?: resolveSlot(localTarget)
?: resolveAssignableSlotByName(localTarget.name)?.first ?: resolveAssignableSlotByName(localTarget.name)?.first
?: return null ?: return null
if (slot < scopeSlotCount && value.type != SlotType.UNKNOWN) { if (slot < scopeSlotCount && value.type != SlotType.UNKNOWN) {
@@ -2702,7 +2751,7 @@ class BytecodeCompiler(
return CompiledValue(result, SlotType.OBJ) return CompiledValue(result, SlotType.OBJ)
} }
if (localTarget.isDelegated) return compileEvalRef(ref) if (localTarget.isDelegated) return compileEvalRef(ref)
val slot = resolveSlot(localTarget) ?: return null val slot = resolveCapturedOwnerScopeSlot(localTarget) ?: resolveSlot(localTarget) ?: return null
val targetType = slotTypes[slot] ?: SlotType.OBJ val targetType = slotTypes[slot] ?: SlotType.OBJ
if (!localTarget.isMutable) { if (!localTarget.isMutable) {
if (targetType != SlotType.OBJ && targetType != SlotType.UNKNOWN) return compileEvalRef(ref) if (targetType != SlotType.OBJ && targetType != SlotType.UNKNOWN) return compileEvalRef(ref)
@@ -4508,7 +4557,7 @@ class BytecodeCompiler(
val resolved = slotTypes[slot] ?: SlotType.UNKNOWN val resolved = slotTypes[slot] ?: SlotType.UNKNOWN
return CompiledValue(slot, resolved) return CompiledValue(slot, resolved)
} }
if (useScopeSlots && allowedScopeNames?.contains(name) == true) { if (useScopeSlots && isPreparedScopeName(name)) {
scopeSlotIndexByName[name]?.let { slot -> scopeSlotIndexByName[name]?.let { slot ->
val resolved = slotTypes[slot] ?: SlotType.UNKNOWN val resolved = slotTypes[slot] ?: SlotType.UNKNOWN
return CompiledValue(slot, resolved) return CompiledValue(slot, resolved)
@@ -5001,6 +5050,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -5020,6 +5071,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -5040,6 +5093,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -5060,6 +5115,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -5083,6 +5140,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -5102,6 +5161,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -5726,6 +5787,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -7598,6 +7661,14 @@ class BytecodeCompiler(
private fun assignValue(ref: AssignRef): ObjRef = ref.value private fun assignValue(ref: AssignRef): ObjRef = ref.value
private fun refPos(ref: BinaryOpRef): Pos = Pos.builtIn private fun refPos(ref: BinaryOpRef): Pos = Pos.builtIn
private fun noteScopeSlotRef(slot: Int, pos: Pos) {
if (slot >= scopeSlotCount) return
val key = scopeKeyByIndex.getOrNull(slot) ?: return
if (!scopeSlotRefPosByKey.containsKey(key)) {
scopeSlotRefPosByKey[key] = pos
}
}
private fun resolveSlot(ref: LocalSlotRef): Int? { private fun resolveSlot(ref: LocalSlotRef): Int? {
loopSlotOverrides[ref.name]?.let { return it } loopSlotOverrides[ref.name]?.let { return it }
val scopeId = refScopeId(ref) val scopeId = refScopeId(ref)
@@ -7605,8 +7676,18 @@ class BytecodeCompiler(
val key = ScopeSlotKey(scopeId, refSlot(ref)) val key = ScopeSlotKey(scopeId, refSlot(ref))
val localIndex = localSlotIndexByKey[key] val localIndex = localSlotIndexByKey[key]
if (localIndex != null) return scopeSlotCount + localIndex if (localIndex != null) return scopeSlotCount + localIndex
scopeSlotMap[key]?.let { return it } scopeSlotMap[key]?.let {
scopeSlotIndexByName[ref.name]?.let { return it } if (!scopeSlotRefPosByKey.containsKey(key)) {
scopeSlotRefPosByKey[key] = ref.pos()
}
return it
}
scopeSlotIndexByName[ref.name]?.let {
if (!scopeSlotRefPosByKey.containsKey(key)) {
scopeSlotRefPosByKey[key] = ref.pos()
}
return it
}
} }
if (ref.captureOwnerScopeId != null) { if (ref.captureOwnerScopeId != null) {
val scopeKey = ScopeSlotKey(refScopeId(ref), refSlot(ref)) val scopeKey = ScopeSlotKey(refScopeId(ref), refSlot(ref))
@@ -7616,7 +7697,13 @@ class BytecodeCompiler(
return scopeSlotCount + localIndex return scopeSlotCount + localIndex
} }
} }
return scopeSlotMap[scopeKey] val resolved = scopeSlotMap[scopeKey]
if (resolved != null) {
if (!scopeSlotRefPosByKey.containsKey(scopeKey)) {
scopeSlotRefPosByKey[scopeKey] = ref.pos()
}
}
return resolved
} }
if (ref.isDelegated) { if (ref.isDelegated) {
val localKey = ScopeSlotKey(refScopeId(ref), refSlot(ref)) val localKey = ScopeSlotKey(refScopeId(ref), refSlot(ref))
@@ -7627,7 +7714,20 @@ class BytecodeCompiler(
val localIndex = localSlotIndexByKey[localKey] val localIndex = localSlotIndexByKey[localKey]
if (localIndex != null) return scopeSlotCount + localIndex if (localIndex != null) return scopeSlotCount + localIndex
val scopeKey = ScopeSlotKey(refScopeId(ref), refSlot(ref)) val scopeKey = ScopeSlotKey(refScopeId(ref), refSlot(ref))
return scopeSlotMap[scopeKey] val resolved = scopeSlotMap[scopeKey]
if (resolved != null) {
if (!scopeSlotRefPosByKey.containsKey(scopeKey)) {
scopeSlotRefPosByKey[scopeKey] = ref.pos()
}
}
return resolved
}
private fun resolveCapturedOwnerScopeSlot(ref: LocalSlotRef): Int? {
val ownerScopeId = ref.captureOwnerScopeId ?: return null
val ownerSlot = ref.captureOwnerSlot ?: return null
val key = ScopeSlotKey(ownerScopeId, ownerSlot)
return scopeSlotMap[key]
} }
private fun updateSlotType(slot: Int, type: SlotType) { private fun updateSlotType(slot: Int, type: SlotType) {
@@ -7850,6 +7950,8 @@ class BytecodeCompiler(
scopeSlotIndices = IntArray(scopeSlotCount) scopeSlotIndices = IntArray(scopeSlotCount)
scopeSlotNames = arrayOfNulls(scopeSlotCount) scopeSlotNames = arrayOfNulls(scopeSlotCount)
scopeSlotIsModule = BooleanArray(scopeSlotCount) scopeSlotIsModule = BooleanArray(scopeSlotCount)
scopeSlotRequiresPreparedBinding = BooleanArray(scopeSlotCount)
scopeSlotRefPos = arrayOfNulls(scopeSlotCount)
scopeSlotMutables = BooleanArray(scopeSlotCount) { true } scopeSlotMutables = BooleanArray(scopeSlotCount) { true }
scopeKeyByIndex = arrayOfNulls(scopeSlotCount) scopeKeyByIndex = arrayOfNulls(scopeSlotCount)
for ((key, index) in scopeSlotMap) { for ((key, index) in scopeSlotMap) {
@@ -7857,6 +7959,8 @@ class BytecodeCompiler(
scopeSlotIndices[index] = key.slot scopeSlotIndices[index] = key.slot
scopeSlotNames[index] = name scopeSlotNames[index] = name
scopeSlotIsModule[index] = moduleScopeId != null && key.scopeId == moduleScopeId scopeSlotIsModule[index] = moduleScopeId != null && key.scopeId == moduleScopeId
scopeSlotRequiresPreparedBinding[index] = name != null && preparedModuleBindingNames.contains(name)
scopeSlotRefPos[index] = name?.let { scopeRefPosByName[it] } ?: scopeSlotRefPosByKey[key]
scopeSlotMutableMap[key]?.let { scopeSlotMutables[index] = it } scopeSlotMutableMap[key]?.let { scopeSlotMutables[index] = it }
scopeKeyByIndex[index] = key scopeKeyByIndex[index] = key
} }
@@ -8073,7 +8177,7 @@ class BytecodeCompiler(
slotInitClassByKey[ScopeSlotKey(scopeId, slotIndex)] = cls 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) val key = ScopeSlotKey(scopeId, slotIndex)
declaredLocalKeys.add(key) declaredLocalKeys.add(key)
if (!localSlotInfoMap.containsKey(key)) { if (!localSlotInfoMap.containsKey(key)) {
@@ -8100,7 +8204,7 @@ class BytecodeCompiler(
val scopeId = stmt.spec.scopeId ?: 0 val scopeId = stmt.spec.scopeId ?: 0
if (slotIndex != null) { if (slotIndex != null) {
val key = ScopeSlotKey(scopeId, slotIndex) val key = ScopeSlotKey(scopeId, slotIndex)
if (allowLocalSlots && !shouldUseScopeSlotFor(scopeId)) { if (allowLocalSlots && !shouldUseScopeSlotFor(scopeId, stmt.spec.name, isDelegated = false)) {
if (!localSlotInfoMap.containsKey(key)) { if (!localSlotInfoMap.containsKey(key)) {
localSlotInfoMap[key] = LocalSlotInfo(stmt.spec.name, isMutable = false, isDelegated = false) localSlotInfoMap[key] = LocalSlotInfo(stmt.spec.name, isMutable = false, isDelegated = false)
} }
@@ -8117,7 +8221,7 @@ class BytecodeCompiler(
is DelegatedVarDeclStatement -> { is DelegatedVarDeclStatement -> {
val slotIndex = stmt.slotIndex val slotIndex = stmt.slotIndex
val scopeId = stmt.scopeId ?: 0 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) val key = ScopeSlotKey(scopeId, slotIndex)
declaredLocalKeys.add(key) declaredLocalKeys.add(key)
if (!localSlotInfoMap.containsKey(key)) { if (!localSlotInfoMap.containsKey(key)) {
@@ -8283,15 +8387,26 @@ class BytecodeCompiler(
private fun isModuleSlot(scopeId: Int, name: String?): Boolean { private fun isModuleSlot(scopeId: Int, name: String?): Boolean {
if (moduleScopeId != null && scopeId != moduleScopeId) return false if (moduleScopeId != null && scopeId != moduleScopeId) return false
val scopeNames = allowedScopeNames ?: scopeSlotNameSet return isPreparedScopeName(name)
if (scopeNames == null || name == null) return false
return scopeNames.contains(name)
} }
private fun shouldUseScopeSlotFor(scopeId: Int): Boolean { private fun shouldUseScopeSlotFor(scopeId: Int): Boolean {
return useScopeSlots && moduleScopeId != null && scopeId == moduleScopeId 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) { private fun collectLoopVarNames(stmt: Statement) {
if (stmt is BytecodeStatement) { if (stmt is BytecodeStatement) {
collectLoopVarNames(stmt.original) collectLoopVarNames(stmt.original)
@@ -8400,8 +8515,9 @@ class BytecodeCompiler(
captureSlotKeys.add(key) captureSlotKeys.add(key)
return return
} }
val forceScopeSlot = shouldUseScopeSlotFor(scopeId, ref.name, ref.isDelegated)
val isModuleSlot = if (ref.isDelegated) false else isModuleSlot(scopeId, ref.name) val isModuleSlot = if (ref.isDelegated) false else isModuleSlot(scopeId, ref.name)
if (allowLocalSlots && !isModuleSlot) { if (allowLocalSlots && !isModuleSlot && !forceScopeSlot) {
if (!localSlotInfoMap.containsKey(key)) { if (!localSlotInfoMap.containsKey(key)) {
localSlotInfoMap[key] = LocalSlotInfo(ref.name, ref.isMutable, ref.isDelegated) localSlotInfoMap[key] = LocalSlotInfo(ref.name, ref.isMutable, ref.isDelegated)
} }
@@ -8448,8 +8564,9 @@ class BytecodeCompiler(
} }
captureSlotKeys.add(key) captureSlotKeys.add(key)
} else { } else {
val forceScopeSlot = shouldUseScopeSlotFor(scopeId, target.name, target.isDelegated)
val isModuleSlot = if (target.isDelegated) false else isModuleSlot(scopeId, target.name) val isModuleSlot = if (target.isDelegated) false else isModuleSlot(scopeId, target.name)
if (allowLocalSlots && !isModuleSlot) { if (allowLocalSlots && !isModuleSlot && !forceScopeSlot) {
if (!localSlotInfoMap.containsKey(key)) { if (!localSlotInfoMap.containsKey(key)) {
localSlotInfoMap[key] = LocalSlotInfo(target.name, target.isMutable, target.isDelegated) localSlotInfoMap[key] = LocalSlotInfo(target.name, target.isMutable, target.isDelegated)
} }
@@ -50,7 +50,7 @@ class BytecodeStatement private constructor(
?: scope.parent?.get(name) ?: scope.parent?.get(name)
?: scope.get(name) ?: scope.get(name)
?: continue ?: continue
val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property) { val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is net.sergeych.lyng.obj.ObjProperty) {
scope.resolve(record, name) scope.resolve(record, name)
} else { } else {
record.value record.value
@@ -87,6 +87,9 @@ class BytecodeStatement private constructor(
callableReturnTypeByScopeId: Map<Int, Map<Int, ObjClass>> = emptyMap(), callableReturnTypeByScopeId: Map<Int, Map<Int, ObjClass>> = emptyMap(),
callableReturnTypeByName: Map<String, ObjClass> = emptyMap(), callableReturnTypeByName: Map<String, ObjClass> = emptyMap(),
externCallableNames: Set<String> = emptySet(), externCallableNames: Set<String> = emptySet(),
externBindingNames: Set<String> = emptySet(),
preparedModuleBindingNames: Set<String> = emptySet(),
scopeRefPosByName: Map<String, Pos> = emptyMap(),
lambdaCaptureEntriesByRef: Map<ValueFnRef, List<LambdaCaptureEntry>> = emptyMap(), lambdaCaptureEntriesByRef: Map<ValueFnRef, List<LambdaCaptureEntry>> = emptyMap(),
slotTypeDeclByScopeId: Map<Int, Map<Int, TypeDecl>> = emptyMap(), slotTypeDeclByScopeId: Map<Int, Map<Int, TypeDecl>> = emptyMap(),
): Statement { ): Statement {
@@ -122,6 +125,9 @@ class BytecodeStatement private constructor(
callableReturnTypeByScopeId = callableReturnTypeByScopeId, callableReturnTypeByScopeId = callableReturnTypeByScopeId,
callableReturnTypeByName = callableReturnTypeByName, callableReturnTypeByName = callableReturnTypeByName,
externCallableNames = externCallableNames, externCallableNames = externCallableNames,
externBindingNames = externBindingNames,
preparedModuleBindingNames = preparedModuleBindingNames,
scopeRefPosByName = scopeRefPosByName,
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
) )
val compiled = compiler.compileStatement(nameHint, statement) val compiled = compiler.compileStatement(nameHint, statement)
@@ -236,6 +242,7 @@ class BytecodeStatement private constructor(
stmt.name, stmt.name,
stmt.isMutable, stmt.isMutable,
stmt.visibility, stmt.visibility,
stmt.actualExtern,
stmt.initializer?.let { unwrapDeep(it) }, stmt.initializer?.let { unwrapDeep(it) },
stmt.isTransient, stmt.isTransient,
stmt.typeDecl, stmt.typeDecl,
@@ -67,6 +67,8 @@ class CmdBuilder {
scopeSlotIndices: IntArray = IntArray(0), scopeSlotIndices: IntArray = IntArray(0),
scopeSlotNames: Array<String?> = emptyArray(), scopeSlotNames: Array<String?> = emptyArray(),
scopeSlotIsModule: BooleanArray = BooleanArray(0), scopeSlotIsModule: BooleanArray = BooleanArray(0),
scopeSlotRequiresPreparedBinding: BooleanArray = BooleanArray(0),
scopeSlotRefPos: Array<net.sergeych.lyng.Pos?> = emptyArray(),
localSlotNames: Array<String?> = emptyArray(), localSlotNames: Array<String?> = emptyArray(),
localSlotMutables: BooleanArray = BooleanArray(0), localSlotMutables: BooleanArray = BooleanArray(0),
localSlotDelegated: BooleanArray = BooleanArray(0), localSlotDelegated: BooleanArray = BooleanArray(0),
@@ -79,6 +81,12 @@ class CmdBuilder {
require(scopeSlotIsModule.isEmpty() || scopeSlotIsModule.size == scopeSlotCount) { require(scopeSlotIsModule.isEmpty() || scopeSlotIsModule.size == scopeSlotCount) {
"scope slot module mapping size mismatch" "scope slot module mapping size mismatch"
} }
require(scopeSlotRequiresPreparedBinding.isEmpty() || scopeSlotRequiresPreparedBinding.size == scopeSlotCount) {
"scope slot prepared-binding mapping size mismatch"
}
require(scopeSlotRefPos.isEmpty() || scopeSlotRefPos.size == scopeSlotCount) {
"scope slot position mapping size mismatch"
}
require(localSlotNames.size == localSlotMutables.size) { "local slot metadata size mismatch" } require(localSlotNames.size == localSlotMutables.size) { "local slot metadata size mismatch" }
require(localSlotNames.size == localSlotDelegated.size) { "local slot delegation size mismatch" } require(localSlotNames.size == localSlotDelegated.size) { "local slot delegation size mismatch" }
require(localSlotNames.size == localSlotCaptures.size) { "local slot capture size mismatch" } require(localSlotNames.size == localSlotCaptures.size) { "local slot capture size mismatch" }
@@ -113,6 +121,8 @@ class CmdBuilder {
scopeSlotIndices = scopeSlotIndices, scopeSlotIndices = scopeSlotIndices,
scopeSlotNames = if (scopeSlotNames.isEmpty()) Array(scopeSlotCount) { null } else scopeSlotNames, scopeSlotNames = if (scopeSlotNames.isEmpty()) Array(scopeSlotCount) { null } else scopeSlotNames,
scopeSlotIsModule = if (scopeSlotIsModule.isEmpty()) BooleanArray(scopeSlotCount) else scopeSlotIsModule, scopeSlotIsModule = if (scopeSlotIsModule.isEmpty()) BooleanArray(scopeSlotCount) else scopeSlotIsModule,
scopeSlotRequiresPreparedBinding = if (scopeSlotRequiresPreparedBinding.isEmpty()) BooleanArray(scopeSlotCount) else scopeSlotRequiresPreparedBinding,
scopeSlotRefPos = if (scopeSlotRefPos.isEmpty()) Array(scopeSlotCount) { null } else scopeSlotRefPos,
localSlotNames = localSlotNames, localSlotNames = localSlotNames,
localSlotMutables = localSlotMutables, localSlotMutables = localSlotMutables,
localSlotDelegated = localSlotDelegated, localSlotDelegated = localSlotDelegated,
@@ -26,6 +26,8 @@ data class CmdFunction(
val scopeSlotIndices: IntArray, val scopeSlotIndices: IntArray,
val scopeSlotNames: Array<String?>, val scopeSlotNames: Array<String?>,
val scopeSlotIsModule: BooleanArray, val scopeSlotIsModule: BooleanArray,
val scopeSlotRequiresPreparedBinding: BooleanArray,
val scopeSlotRefPos: Array<net.sergeych.lyng.Pos?>,
val localSlotNames: Array<String?>, val localSlotNames: Array<String?>,
val localSlotMutables: BooleanArray, val localSlotMutables: BooleanArray,
val localSlotDelegated: BooleanArray, val localSlotDelegated: BooleanArray,
@@ -38,6 +40,8 @@ data class CmdFunction(
require(scopeSlotIndices.size == scopeSlotCount) { "scopeSlotIndices size mismatch" } require(scopeSlotIndices.size == scopeSlotCount) { "scopeSlotIndices size mismatch" }
require(scopeSlotNames.size == scopeSlotCount) { "scopeSlotNames size mismatch" } require(scopeSlotNames.size == scopeSlotCount) { "scopeSlotNames size mismatch" }
require(scopeSlotIsModule.size == scopeSlotCount) { "scopeSlotIsModule size mismatch" } require(scopeSlotIsModule.size == scopeSlotCount) { "scopeSlotIsModule size mismatch" }
require(scopeSlotRequiresPreparedBinding.size == scopeSlotCount) { "scopeSlotRequiresPreparedBinding size mismatch" }
require(scopeSlotRefPos.size == scopeSlotCount) { "scopeSlotRefPos size mismatch" }
require(localSlotNames.size == localSlotMutables.size) { "localSlot metadata size mismatch" } require(localSlotNames.size == localSlotMutables.size) { "localSlot metadata size mismatch" }
require(localSlotNames.size == localSlotDelegated.size) { "localSlot delegation size mismatch" } require(localSlotNames.size == localSlotDelegated.size) { "localSlot delegation size mismatch" }
require(localSlotNames.size == localSlotCaptures.size) { "localSlot capture size mismatch" } require(localSlotNames.size == localSlotCaptures.size) { "localSlot capture size mismatch" }
@@ -85,6 +85,9 @@ class CmdNop : Cmd() {
class CmdMoveObj(internal val src: Int, internal val dst: Int) : Cmd() { class CmdMoveObj(internal val src: Int, internal val dst: Int) : Cmd() {
override suspend fun perform(frame: CmdFrame) { override suspend fun perform(frame: CmdFrame) {
val value = frame.slotToObj(src) val value = frame.slotToObj(src)
if (frame.writeThroughPropertyLikeSlot(dst, value)) {
return
}
if (frame.shouldBypassImmutableWrite(dst)) { if (frame.shouldBypassImmutableWrite(dst)) {
frame.setObjUnchecked(dst, value) frame.setObjUnchecked(dst, value)
} else { } else {
@@ -97,6 +100,9 @@ class CmdMoveObj(internal val src: Int, internal val dst: Int) : Cmd() {
class CmdMoveInt(internal val src: Int, internal val dst: Int) : Cmd() { class CmdMoveInt(internal val src: Int, internal val dst: Int) : Cmd() {
override suspend fun perform(frame: CmdFrame) { override suspend fun perform(frame: CmdFrame) {
val value = frame.getInt(src) val value = frame.getInt(src)
if (frame.writeThroughPropertyLikeSlot(dst, ObjInt.of(value))) {
return
}
if (frame.shouldBypassImmutableWrite(dst)) { if (frame.shouldBypassImmutableWrite(dst)) {
frame.setIntUnchecked(dst, value) frame.setIntUnchecked(dst, value)
} else { } else {
@@ -117,6 +123,9 @@ class CmdMoveIntLocal(internal val src: Int, internal val dst: Int) : Cmd() {
class CmdMoveReal(internal val src: Int, internal val dst: Int) : Cmd() { class CmdMoveReal(internal val src: Int, internal val dst: Int) : Cmd() {
override suspend fun perform(frame: CmdFrame) { override suspend fun perform(frame: CmdFrame) {
val value = frame.getReal(src) val value = frame.getReal(src)
if (frame.writeThroughPropertyLikeSlot(dst, ObjReal.of(value))) {
return
}
if (frame.shouldBypassImmutableWrite(dst)) { if (frame.shouldBypassImmutableWrite(dst)) {
frame.setRealUnchecked(dst, value) frame.setRealUnchecked(dst, value)
} else { } else {
@@ -137,6 +146,9 @@ class CmdMoveRealLocal(internal val src: Int, internal val dst: Int) : Cmd() {
class CmdMoveBool(internal val src: Int, internal val dst: Int) : Cmd() { class CmdMoveBool(internal val src: Int, internal val dst: Int) : Cmd() {
override suspend fun perform(frame: CmdFrame) { override suspend fun perform(frame: CmdFrame) {
val value = frame.getBool(src) val value = frame.getBool(src)
if (frame.writeThroughPropertyLikeSlot(dst, if (value) ObjTrue else ObjFalse)) {
return
}
if (frame.shouldBypassImmutableWrite(dst)) { if (frame.shouldBypassImmutableWrite(dst)) {
frame.setBoolUnchecked(dst, value) frame.setBoolUnchecked(dst, value)
} else { } else {
@@ -2392,8 +2404,13 @@ class CmdDeclLocal(internal val constId: Int, internal val slot: Int) : Cmd() {
?: error("DECL_LOCAL expects LocalDecl at $constId") ?: error("DECL_LOCAL expects LocalDecl at $constId")
if (slot < frame.fn.scopeSlotCount) { if (slot < frame.fn.scopeSlotCount) {
val target = frame.scopeTarget(slot) val target = frame.scopeTarget(slot)
frame.ensureScopeSlot(target, slot) val index = frame.ensureScopeSlot(target, slot)
val value = frame.slotToObj(slot).byValueCopy() val raw = target.getSlotRecord(index).value
val value = when (raw) {
is FrameSlotRef -> raw.read()
is RecordSlotRef -> raw.read()
else -> raw
}.byValueCopy()
target.updateSlotFor( target.updateSlotFor(
decl.name, decl.name,
ObjRecord( 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) val scoped = frame.scope.chainLookupIgnoreClosure(name, followClosure = true) ?: frame.scope.get(name)
if (scoped != null) { if (scoped != null) {
records += ObjRecord(RecordSlotRef(scoped), isMutable = scoped.isMutable) records += scoped
continue continue
} }
frame.ensureScope().raiseSymbolNotFound("capture $name not found") frame.ensureScope().raiseSymbolNotFound("capture $name not found")
@@ -2853,7 +2870,7 @@ class CmdDeclInstanceProperty(internal val constId: Int, internal val slot: Int)
val decl = frame.fn.constants[constId] as? BytecodeConst.InstancePropertyDecl val decl = frame.fn.constants[constId] as? BytecodeConst.InstancePropertyDecl
?: error("DECL_INSTANCE_PROPERTY expects InstancePropertyDecl at $constId") ?: error("DECL_INSTANCE_PROPERTY expects InstancePropertyDecl at $constId")
val scope = frame.ensureScope() val scope = frame.ensureScope()
val prop = frame.slotToObj(slot) val prop = frame.storedSlotObj(slot)
scope.addItem( scope.addItem(
decl.name, decl.name,
decl.isMutable, decl.isMutable,
@@ -3719,7 +3736,7 @@ class BytecodeLambdaCallable(
?: context.parent?.get(name) ?: context.parent?.get(name)
?: context.get(name) ?: context.get(name)
?: continue ?: continue
val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property) { val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is ObjProperty) {
context.resolve(record, name) context.resolve(record, name)
} else { } else {
record.value record.value
@@ -3812,7 +3829,29 @@ class CmdFrame(
} }
internal fun getLocalSlotTypeCode(localIndex: Int): Byte = frame.getSlotTypeCode(localIndex) internal fun getLocalSlotTypeCode(localIndex: Int): Byte = frame.getSlotTypeCode(localIndex)
internal fun readLocalObj(localIndex: Int): Obj = localSlotToObj(localIndex) internal fun readLocalObj(localIndex: Int): Obj {
return when (frame.getSlotTypeCode(localIndex)) {
SlotType.INT.code -> ObjInt.of(frame.getInt(localIndex))
SlotType.REAL.code -> ObjReal.of(frame.getReal(localIndex))
SlotType.BOOL.code -> if (frame.getBool(localIndex)) ObjTrue else ObjFalse
SlotType.OBJ.code -> {
val obj = frame.getObj(localIndex)
when (obj) {
is FrameSlotRef -> obj.read()
is RecordSlotRef -> obj.read()
else -> obj
}
}
else -> {
val obj = frame.getObj(localIndex)
when (obj) {
is FrameSlotRef -> obj.read()
is RecordSlotRef -> obj.read()
else -> obj
}
}
}
}
internal fun isFastLocalSlot(slot: Int): Boolean { internal fun isFastLocalSlot(slot: Int): Boolean {
if (slot < fn.scopeSlotCount) return false if (slot < fn.scopeSlotCount) return false
val localIndex = slot - fn.scopeSlotCount val localIndex = slot - fn.scopeSlotCount
@@ -3930,7 +3969,7 @@ class CmdFrame(
} else { } else {
val raw = frame.getRawObj(localIndex) val raw = frame.getRawObj(localIndex)
if (raw == null && name != null) { if (raw == null && name != null) {
val record = scope.get(name) val record = findNamedExistingRecord(scope, name)
if (record != null) { if (record != null) {
val value = record.value val value = record.value
return@mapIndexed when (value) { return@mapIndexed when (value) {
@@ -3939,6 +3978,12 @@ class CmdFrame(
else -> ObjRecord(value, isMutable) 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) { when (raw) {
is FrameSlotRef -> ObjRecord(raw, isMutable) is FrameSlotRef -> ObjRecord(raw, isMutable)
@@ -3952,22 +3997,27 @@ class CmdFrame(
val target = moduleScope val target = moduleScope
val name = captureNames?.getOrNull(index) val name = captureNames?.getOrNull(index)
if (name != null) { if (name != null) {
target.tryGetLocalRecord(target, name, target.currentClassCtx)?.let { return@mapIndexed it } findNamedExistingRecord(target, name)?.let { return@mapIndexed it }
target.getSlotIndexOf(name)?.let { return@mapIndexed target.getSlotRecord(it) }
target.get(name)?.let { return@mapIndexed it }
// Fallback to current scope in case the module scope isn't in the parent chain // Fallback to current scope in case the module scope isn't in the parent chain
// or doesn't carry the imported symbol yet. // or doesn't carry the imported symbol yet.
scope.tryGetLocalRecord(scope, name, scope.currentClassCtx)?.let { return@mapIndexed it } findNamedExistingRecord(scope, name)?.let { return@mapIndexed it }
scope.get(name)?.let { return@mapIndexed it }
} }
if (slotId < target.slotCount) { 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) { if (name != null) {
target.applySlotPlan(mapOf(name to slotId)) throw ScriptError(
return@mapIndexed target.getSlotRecord(slotId) 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 { fun ensureScope(): Scope {
val pos = posForIp(ip - 1) val pos = currentErrorPos()
if (pos != null && lastScopePosIp != ip) { if (pos != null && lastScopePosIp != ip) {
scope.pos = pos scope.pos = pos
lastScopePosIp = ip lastScopePosIp = ip
@@ -4139,6 +4189,33 @@ class CmdFrame(
return fn.posByIp.getOrNull(ip) return fn.posByIp.getOrNull(ip)
} }
private fun currentErrorPos(): Pos? {
val center = ip - 1
if (center < 0) return null
var fallback: Pos? = null
val maxRadius = maxOf(center, fn.posByIp.size - 1 - center)
for (radius in 0..maxRadius) {
val before = center - radius
if (before >= 0) {
val pos = posForIp(before)
if (pos != null) {
if (pos.source !== Source.builtIn && pos.source !== Source.UNKNOWN) return pos
if (fallback == null) fallback = pos
}
}
if (radius == 0) continue
val after = center + radius
if (after < fn.posByIp.size) {
val pos = posForIp(after)
if (pos != null) {
if (pos.source !== Source.builtIn && pos.source !== Source.UNKNOWN) return pos
if (fallback == null) fallback = pos
}
}
}
return fallback
}
fun pushScope(plan: Map<String, Int>, captures: List<String>) { fun pushScope(plan: Map<String, Int>, captures: List<String>) {
if (scope.skipScopeCreation) { if (scope.skipScopeCreation) {
val snapshot = emptyMap<String, Int?>() val snapshot = emptyMap<String, Int?>()
@@ -4246,7 +4323,7 @@ class CmdFrame(
return if (slot < fn.scopeSlotCount) { return if (slot < fn.scopeSlotCount) {
getScopeSlotValue(slot) getScopeSlotValue(slot)
} else { } else {
localSlotToObj(slot - fn.scopeSlotCount) readLocalSlotValue(slot - fn.scopeSlotCount)
} }
} }
@@ -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 { suspend fun getInt(slot: Int): Long {
return if (slot < fn.scopeSlotCount) { return if (slot < fn.scopeSlotCount) {
getScopeSlotValue(slot).toLong() getScopeSlotValue(slot).toLong()
@@ -4298,14 +4404,7 @@ class CmdFrame(
SlotType.INT.code -> frame.getInt(local) SlotType.INT.code -> frame.getInt(local)
SlotType.REAL.code -> frame.getReal(local).toLong() SlotType.REAL.code -> frame.getReal(local).toLong()
SlotType.BOOL.code -> if (frame.getBool(local)) 1L else 0L SlotType.BOOL.code -> if (frame.getBool(local)) 1L else 0L
SlotType.OBJ.code -> { SlotType.OBJ.code -> readLocalSlotValue(local).toLong()
val obj = frame.getObj(local)
when (obj) {
is FrameSlotRef -> obj.read().toLong()
is RecordSlotRef -> obj.read().toLong()
else -> obj.toLong()
}
}
else -> 0L else -> 0L
} }
} }
@@ -4385,14 +4484,7 @@ class CmdFrame(
SlotType.REAL.code -> frame.getReal(local) SlotType.REAL.code -> frame.getReal(local)
SlotType.INT.code -> frame.getInt(local).toDouble() SlotType.INT.code -> frame.getInt(local).toDouble()
SlotType.BOOL.code -> if (frame.getBool(local)) 1.0 else 0.0 SlotType.BOOL.code -> if (frame.getBool(local)) 1.0 else 0.0
SlotType.OBJ.code -> { SlotType.OBJ.code -> readLocalSlotValue(local).toDouble()
val obj = frame.getObj(local)
when (obj) {
is FrameSlotRef -> obj.read().toDouble()
is RecordSlotRef -> obj.read().toDouble()
else -> obj.toDouble()
}
}
else -> 0.0 else -> 0.0
} }
} }
@@ -4461,14 +4553,7 @@ class CmdFrame(
SlotType.BOOL.code -> frame.getBool(local) SlotType.BOOL.code -> frame.getBool(local)
SlotType.INT.code -> frame.getInt(local) != 0L SlotType.INT.code -> frame.getInt(local) != 0L
SlotType.REAL.code -> frame.getReal(local) != 0.0 SlotType.REAL.code -> frame.getReal(local) != 0.0
SlotType.OBJ.code -> { SlotType.OBJ.code -> readLocalSlotValue(local).toBool()
val obj = frame.getObj(local)
when (obj) {
is FrameSlotRef -> obj.read().toBool()
is RecordSlotRef -> obj.read().toBool()
else -> obj.toBool()
}
}
else -> false else -> false
} }
} }
@@ -4546,7 +4631,7 @@ class CmdFrame(
return getScopeSlotValueAtAddr(addrSlot) return getScopeSlotValueAtAddr(addrSlot)
} }
fun setAddrObj(addrSlot: Int, value: Obj) { suspend fun setAddrObj(addrSlot: Int, value: Obj) {
setScopeSlotValueAtAddr(addrSlot, value) setScopeSlotValueAtAddr(addrSlot, value)
} }
@@ -4554,7 +4639,7 @@ class CmdFrame(
return getScopeSlotValueAtAddr(addrSlot).toLong() return getScopeSlotValueAtAddr(addrSlot).toLong()
} }
fun setAddrInt(addrSlot: Int, value: Long) { suspend fun setAddrInt(addrSlot: Int, value: Long) {
setScopeSlotValueAtAddr(addrSlot, ObjInt.of(value)) setScopeSlotValueAtAddr(addrSlot, ObjInt.of(value))
} }
@@ -4562,7 +4647,7 @@ class CmdFrame(
return getScopeSlotValueAtAddr(addrSlot).toDouble() return getScopeSlotValueAtAddr(addrSlot).toDouble()
} }
fun setAddrReal(addrSlot: Int, value: Double) { suspend fun setAddrReal(addrSlot: Int, value: Double) {
setScopeSlotValueAtAddr(addrSlot, ObjReal.of(value)) setScopeSlotValueAtAddr(addrSlot, ObjReal.of(value))
} }
@@ -4570,7 +4655,7 @@ class CmdFrame(
return getScopeSlotValueAtAddr(addrSlot).toBool() return getScopeSlotValueAtAddr(addrSlot).toBool()
} }
fun setAddrBool(addrSlot: Int, value: Boolean) { suspend fun setAddrBool(addrSlot: Int, value: Boolean) {
setScopeSlotValueAtAddr(addrSlot, if (value) ObjTrue else ObjFalse) setScopeSlotValueAtAddr(addrSlot, if (value) ObjTrue else ObjFalse)
} }
@@ -4580,21 +4665,42 @@ class CmdFrame(
} }
val local = slot - fn.scopeSlotCount val local = slot - fn.scopeSlotCount
if (fn.localSlotCaptures.getOrNull(local) == true) { if (fn.localSlotCaptures.getOrNull(local) == true) {
return localSlotToObj(local) return readLocalSlotValue(local)
} }
return when (frame.getSlotTypeCode(local)) { return when (frame.getSlotTypeCode(local)) {
SlotType.INT.code -> ObjInt.of(frame.getInt(local)) SlotType.INT.code -> ObjInt.of(frame.getInt(local))
SlotType.REAL.code -> ObjReal.of(frame.getReal(local)) SlotType.REAL.code -> ObjReal.of(frame.getReal(local))
SlotType.BOOL.code -> if (frame.getBool(local)) ObjTrue else ObjFalse SlotType.BOOL.code -> if (frame.getBool(local)) ObjTrue else ObjFalse
SlotType.OBJ.code -> { SlotType.OBJ.code -> readLocalSlotValue(local)
val obj = frame.getObj(local) else -> readLocalSlotValue(local)
when (obj) {
is FrameSlotRef -> obj.read()
is RecordSlotRef -> obj.read()
else -> obj
} }
} }
else -> localSlotToObj(local)
fun storedSlotObj(slot: Int): Obj {
if (slot < fn.scopeSlotCount) {
val target = scopeTarget(slot)
val index = ensureScopeSlot(target, slot)
val record = target.getSlotRecord(index)
return when (val direct = record.value) {
is FrameSlotRef -> direct.read()
is RecordSlotRef -> direct.read()
is ScopeSlotRef -> direct.read()
else -> direct
}
}
val local = slot - fn.scopeSlotCount
return when (frame.getSlotTypeCode(local)) {
SlotType.INT.code -> ObjInt.of(frame.getInt(local))
SlotType.REAL.code -> ObjReal.of(frame.getReal(local))
SlotType.BOOL.code -> if (frame.getBool(local)) ObjTrue else ObjFalse
SlotType.OBJ.code, SlotType.UNKNOWN.code -> when (val raw = frame.getRawObj(local)) {
is FrameSlotRef -> raw.read()
is RecordSlotRef -> raw.read()
is ScopeSlotRef -> raw.read()
null -> ObjNull
else -> raw
}
else -> frame.getRawObj(local) ?: ObjNull
} }
} }
@@ -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)) { return when (frame.getSlotTypeCode(localIndex)) {
SlotType.INT.code -> ObjInt.of(frame.getInt(localIndex)) SlotType.INT.code -> ObjInt.of(frame.getInt(localIndex))
SlotType.REAL.code -> ObjReal.of(frame.getReal(localIndex)) SlotType.REAL.code -> ObjReal.of(frame.getReal(localIndex))
@@ -4759,7 +4866,9 @@ class CmdFrame(
val obj = frame.getObj(localIndex) val obj = frame.getObj(localIndex)
when (obj) { when (obj) {
is FrameSlotRef -> obj.read() is FrameSlotRef -> obj.read()
is RecordSlotRef -> obj.read() is RecordSlotRef -> obj.read(scope, localName)
is ObjProperty -> resolvePropertyLikeLocal(localName, obj)
ObjUnset -> resolveUnsetLocal(localName)
else -> obj else -> obj
} }
} }
@@ -4767,21 +4876,43 @@ class CmdFrame(
val obj = frame.getObj(localIndex) val obj = frame.getObj(localIndex)
when (obj) { when (obj) {
is FrameSlotRef -> obj.read() is FrameSlotRef -> obj.read()
is RecordSlotRef -> obj.read() is RecordSlotRef -> obj.read(scope, localName)
is ObjProperty -> resolvePropertyLikeLocal(localName, obj)
ObjUnset -> resolveUnsetLocal(localName)
else -> obj else -> obj
} }
} }
} }
} }
private suspend fun resolvePropertyLikeLocal(localName: String?, property: ObjProperty): Obj {
if (localName != null) {
val record = scope.parent?.get(localName) ?: scope.get(localName)
if (record != null && (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is ObjProperty)) {
return scope.resolve(record, localName)
}
}
return property.callGetter(scope, scope.thisObj)
}
private suspend fun resolveUnsetLocal(localName: String?): Obj {
if (localName == null) return ObjUnset
val record = scope.parent?.get(localName) ?: scope.get(localName) ?: return ObjUnset
if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is ObjProperty) {
return scope.resolve(record, localName)
}
return record.value
}
private suspend fun getScopeSlotValue(slot: Int): Obj { private suspend fun getScopeSlotValue(slot: Int): Obj {
val target = scopeTarget(slot) val target = scopeTarget(slot)
val name = fn.scopeSlotNames[slot]
val hadNamedBinding = name != null && hasResolvedNamedScopeBinding(target, name)
val index = ensureScopeSlot(target, slot) val index = ensureScopeSlot(target, slot)
val record = target.getSlotRecord(index) val record = target.getSlotRecord(index)
val direct = record.value val direct = record.value
if (direct is FrameSlotRef) return direct.read() if (direct is FrameSlotRef) return direct.read()
if (direct is RecordSlotRef) return direct.read() if (direct is RecordSlotRef) return direct.read()
val name = fn.scopeSlotNames[slot]
if (name != null && record.memberName != null && record.memberName != name) { if (name != null && record.memberName != null && record.memberName != name) {
val resolved = target.get(name) val resolved = target.get(name)
if (resolved != null) { if (resolved != null) {
@@ -4802,9 +4933,15 @@ class CmdFrame(
return direct return direct
} }
if (name == null) return record.value 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) { if (resolved.value !== ObjUnset) {
target.updateSlotFor(name, resolved) target.updateSlotFor(name, resolved)
} else {
failMissingPreparedModuleBinding(slot, name, hadNamedBinding, resolved)
} }
return resolved.value return resolved.value
} }
@@ -4812,12 +4949,13 @@ class CmdFrame(
private suspend fun getScopeSlotValueAtAddr(addrSlot: Int): Obj { private suspend fun getScopeSlotValueAtAddr(addrSlot: Int): Obj {
val target = addrScopes[addrSlot] ?: error("Address slot $addrSlot is not resolved") val target = addrScopes[addrSlot] ?: error("Address slot $addrSlot is not resolved")
val index = addrIndices[addrSlot] val index = addrIndices[addrSlot]
val slotId = addrScopeSlots[addrSlot]
val name = fn.scopeSlotNames.getOrNull(slotId)
val hadNamedBinding = name != null && hasResolvedNamedScopeBinding(target, name)
val record = target.getSlotRecord(index) val record = target.getSlotRecord(index)
val direct = record.value val direct = record.value
if (direct is FrameSlotRef) return direct.read() if (direct is FrameSlotRef) return direct.read()
if (direct is RecordSlotRef) 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) { if (name != null && record.memberName != null && record.memberName != name) {
val resolved = target.get(name) val resolved = target.get(name)
if (resolved != null) { if (resolved != null) {
@@ -4838,19 +4976,49 @@ class CmdFrame(
return direct return direct
} }
if (name == null) return record.value 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) { if (resolved.value !== ObjUnset) {
target.updateSlotFor(name, resolved) target.updateSlotFor(name, resolved)
} else {
failMissingPreparedModuleBinding(slotId, name, hadNamedBinding, resolved)
} }
return resolved.value 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 target = addrScopes[addrSlot] ?: error("Address slot $addrSlot is not resolved")
val index = addrIndices[addrSlot] 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) target.setSlotValue(index, value)
} }
private fun resolveScopeSlotRecordForWrite(target: Scope, index: Int, name: String?): ObjRecord? {
val record = target.getSlotRecord(index)
if (name == null) return record
if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is ObjProperty) {
return record
}
if (record.value !== ObjUnset && record.memberName == null) {
return record
}
val resolved = target.get(name) ?: return record
if (resolved.value !== ObjUnset || resolved.type == ObjRecord.Type.Delegated || resolved.type == ObjRecord.Type.Property || resolved.value is ObjProperty) {
target.updateSlotFor(name, resolved)
return resolved
}
return record
}
internal fun ensureScopeSlot(target: Scope, slot: Int): Int { internal fun ensureScopeSlot(target: Scope, slot: Int): Int {
val name = fn.scopeSlotNames[slot] val name = fn.scopeSlotNames[slot]
if (name != null) { if (name != null) {
@@ -4875,6 +5043,45 @@ class CmdFrame(
return index 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) { private fun ensureLocalMutable(localIndex: Int) {
val name = fn.localSlotNames.getOrNull(localIndex) ?: return val name = fn.localSlotNames.getOrNull(localIndex) ?: return
val isMutable = fn.localSlotMutables.getOrNull(localIndex) ?: true val isMutable = fn.localSlotMutables.getOrNull(localIndex) ?: true
@@ -31,12 +31,12 @@ internal suspend fun seedFrameLocalsFromScope(frame: CmdFrame, scope: Scope) {
val record = scope.getLocalRecordDirect(name) val record = scope.getLocalRecordDirect(name)
?: scope.chainLookupIgnoreClosure(name, followClosure = true) ?: scope.chainLookupIgnoreClosure(name, followClosure = true)
?: continue ?: continue
val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property) { val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is net.sergeych.lyng.obj.ObjProperty) {
scope.resolve(record, name) scope.resolve(record, name)
} else { } else {
record.value record.value
} }
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 continue
} }
frame.setObjUnchecked(base + i, value) 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) // Math helpers (scalar versions)
fun math1(name: String) = mod.funDoc( fun math1(name: String) = mod.funDoc(
name = name, name = name,
doc = StdlibInlineDocIndex.topFunDoc(name) ?: "Compute $name(x).", doc = StdlibInlineDocIndex.topFunDoc(name) ?: "Compute $name(x). Accepts Int, Real, and Decimal. Decimal currently uses a temporary Real bridge and will get native decimal implementations later.",
params = listOf(ParamDoc("x", type("lyng.Number"))) params = listOf(ParamDoc("x", type("lyng.Number")))
) )
math1("sin"); math1("cos"); math1("tan"); math1("asin"); math1("acos"); math1("atan") math1("sin"); math1("cos"); math1("tan"); math1("asin"); math1("acos"); math1("atan")
mod.funDoc(name = "floor", doc = StdlibInlineDocIndex.topFunDoc("floor") ?: "Round down the number to the nearest integer.", params = listOf(ParamDoc("x", type("lyng.Number")))) mod.funDoc(name = "floor", doc = StdlibInlineDocIndex.topFunDoc("floor") ?: "Round down the number to the nearest integer. Decimal is handled directly and stays Decimal.", params = listOf(ParamDoc("x", type("lyng.Number"))))
mod.funDoc(name = "ceil", doc = StdlibInlineDocIndex.topFunDoc("ceil") ?: "Round up the number to the nearest integer.", params = listOf(ParamDoc("x", type("lyng.Number")))) mod.funDoc(name = "ceil", doc = StdlibInlineDocIndex.topFunDoc("ceil") ?: "Round up the number to the nearest integer. Decimal is handled directly and stays Decimal.", params = listOf(ParamDoc("x", type("lyng.Number"))))
mod.funDoc(name = "round", doc = StdlibInlineDocIndex.topFunDoc("round") ?: "Round the number to the nearest integer.", params = listOf(ParamDoc("x", type("lyng.Number")))) mod.funDoc(name = "round", doc = StdlibInlineDocIndex.topFunDoc("round") ?: "Round the number to the nearest integer. Decimal is handled directly and stays Decimal.", params = listOf(ParamDoc("x", type("lyng.Number"))))
// Hyperbolic and inverse hyperbolic // Hyperbolic and inverse hyperbolic
math1("sinh"); math1("cosh"); math1("tanh"); math1("asinh"); math1("acosh"); math1("atanh") math1("sinh"); math1("cosh"); math1("tanh"); math1("asinh"); math1("acosh"); math1("atanh")
// Exponentials and logarithms // Exponentials and logarithms
mod.funDoc(name = "exp", doc = StdlibInlineDocIndex.topFunDoc("exp") ?: "Euler's exponential e^x.", params = listOf(ParamDoc("x", type("lyng.Number")))) mod.funDoc(name = "exp", doc = StdlibInlineDocIndex.topFunDoc("exp") ?: "Euler's exponential e^x. Decimal currently uses a temporary Real bridge and will get a native decimal implementation later.", params = listOf(ParamDoc("x", type("lyng.Number"))))
mod.funDoc(name = "ln", doc = StdlibInlineDocIndex.topFunDoc("ln") ?: "Natural logarithm (base e).", params = listOf(ParamDoc("x", type("lyng.Number")))) mod.funDoc(name = "ln", doc = StdlibInlineDocIndex.topFunDoc("ln") ?: "Natural logarithm (base e). Decimal currently uses a temporary Real bridge and will get a native decimal implementation later.", params = listOf(ParamDoc("x", type("lyng.Number"))))
mod.funDoc(name = "log10", doc = StdlibInlineDocIndex.topFunDoc("log10") ?: "Logarithm base 10.", params = listOf(ParamDoc("x", type("lyng.Number")))) mod.funDoc(name = "log10", doc = StdlibInlineDocIndex.topFunDoc("log10") ?: "Logarithm base 10. Decimal currently uses a temporary Real bridge and will get a native decimal implementation later.", params = listOf(ParamDoc("x", type("lyng.Number"))))
mod.funDoc(name = "log2", doc = StdlibInlineDocIndex.topFunDoc("log2") ?: "Logarithm base 2.", params = listOf(ParamDoc("x", type("lyng.Number")))) mod.funDoc(name = "log2", doc = StdlibInlineDocIndex.topFunDoc("log2") ?: "Logarithm base 2. Decimal currently uses a temporary Real bridge and will get a native decimal implementation later.", params = listOf(ParamDoc("x", type("lyng.Number"))))
// Power/roots and absolute value // Power/roots and absolute value
mod.funDoc( mod.funDoc(
name = "pow", name = "pow",
doc = StdlibInlineDocIndex.topFunDoc("pow") ?: "Raise `x` to the power `y`.", doc = StdlibInlineDocIndex.topFunDoc("pow") ?: "Raise `x` to the power `y`. Decimal with integral `y` is handled directly; other Decimal cases currently use a temporary Real bridge.",
params = listOf(ParamDoc("x", type("lyng.Number")), ParamDoc("y", type("lyng.Number"))) params = listOf(ParamDoc("x", type("lyng.Number")), ParamDoc("y", type("lyng.Number")))
) )
mod.funDoc( mod.funDoc(
name = "sqrt", name = "sqrt",
doc = StdlibInlineDocIndex.topFunDoc("sqrt") ?: "Square root of `x`.", doc = StdlibInlineDocIndex.topFunDoc("sqrt") ?: "Square root of `x`. Decimal currently uses a temporary Real bridge and will get a native decimal implementation later.",
params = listOf(ParamDoc("x", type("lyng.Number"))) params = listOf(ParamDoc("x", type("lyng.Number")))
) )
mod.funDoc( mod.funDoc(
name = "abs", name = "abs",
doc = StdlibInlineDocIndex.topFunDoc("abs") ?: "Absolute value of a number (works for Int and Real).", doc = StdlibInlineDocIndex.topFunDoc("abs") ?: "Absolute value of a number. Int stays Int, and Decimal stays Decimal.",
params = listOf(ParamDoc("x", type("lyng.Number"))) params = listOf(ParamDoc("x", type("lyng.Number")))
) )
@@ -540,7 +540,8 @@ private fun buildStdlibDocs(): List<MiniDecl> {
// Concurrency helpers // Concurrency helpers
mod.classDoc(name = "Deferred", doc = "Represents a value that will be available in the future.", bases = listOf(type("Obj"))) { mod.classDoc(name = "Deferred", doc = "Represents a value that will be available in the future.", bases = listOf(type("Obj"))) {
method(name = "await", doc = "Suspend until the value is available and return it.") method(name = "cancel", doc = "Cancel the deferred if it is still active.")
method(name = "await", doc = "Suspend until the value is available and return it. Throws `CancellationException` if cancelled.")
} }
mod.funDoc( mod.funDoc(
name = "launch", name = "launch",
@@ -25,6 +25,8 @@ import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonNull import kotlinx.serialization.json.JsonNull
import kotlinx.serialization.serializer import kotlinx.serialization.serializer
import net.sergeych.lyng.* 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.ParamDoc
import net.sergeych.lyng.miniast.addFnDoc import net.sergeych.lyng.miniast.addFnDoc
import net.sergeych.lyng.miniast.type import net.sergeych.lyng.miniast.type
@@ -175,7 +177,8 @@ open class Obj {
if (other === this) return 0 if (other === this) return 0
if (other === ObjNull || other === ObjUnset || other === ObjVoid) return 2 if (other === ObjNull || other === ObjUnset || other === ObjVoid) return 2
return invokeInstanceMethod(scope, "compareTo", Arguments(other)) { 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() }.cast<ObjInt>(scope).toInt()
} }
@@ -284,7 +287,8 @@ open class Obj {
} }
if (self !== this) return self.plus(scope, otherValue) if (self !== this) return self.plus(scope, otherValue)
return invokeInstanceMethod(scope, "plus", Arguments(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) if (self !== this) return self.minus(scope, otherValue)
return invokeInstanceMethod(scope, "minus", Arguments(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) if (self !== this) return self.mul(scope, otherValue)
return invokeInstanceMethod(scope, "mul", Arguments(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) if (self !== this) return self.div(scope, otherValue)
return invokeInstanceMethod(scope, "div", Arguments(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) if (self !== this) return self.mod(scope, otherValue)
return invokeInstanceMethod(scope, "mod", Arguments(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) return obj.copy(value = res, type = ObjRecord.Type.Other)
} }
val value = obj.value val value = obj.value
if (value is ObjProperty || obj.type == ObjRecord.Type.Property) { if (value is ObjProperty) {
val prop = (value as? ObjProperty) val res = value.callGetter(scope, this, decl)
?: scope.raiseError("Expected ObjProperty for property member $name, got ${value::class}") return obj.copy(value = res, type = ObjRecord.Type.Other)
val res = prop.callGetter(scope, this, decl) }
return ObjRecord(res, obj.isMutable) if (obj.type == ObjRecord.Type.Property) {
// Some runtime paths cache the resolved property value back into the record.
// Treat that as an already-resolved read result instead of trying to call a getter again.
return obj.copy(type = ObjRecord.Type.Other)
} }
val caller = scope.currentClassCtx val caller = scope.currentClassCtx
// Check visibility for non-property members here if they weren't checked before // Check visibility for non-property members here if they weren't checked before
@@ -1068,6 +1079,7 @@ interface Numeric {
fun Obj.toDouble(): Double = fun Obj.toDouble(): Double =
(this as? Numeric)?.doubleValue (this as? Numeric)?.doubleValue
?: ObjDecimalSupport.toDoubleOrNull(this)
?: (this as? ObjString)?.value?.toDouble() ?: (this as? ObjString)?.value?.toDouble()
?: throw IllegalArgumentException("cannot convert to double $this") ?: throw IllegalArgumentException("cannot convert to double $this")
@@ -106,10 +106,20 @@ open class ObjClass(
vararg parents: ObjClass, vararg parents: ObjClass,
) : Obj() { ) : 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 isAnonymous: Boolean = false
var isAbstract: Boolean = false var isAbstract: Boolean = false
var isClosed: Boolean = false var isClosed: Boolean = false
var logicalPackageNameOverride: String? = null
// Stable identity and simple structural version for PICs // Stable identity and simple structural version for PICs
val classId: Long = ClassIdGen.nextId() val classId: Long = ClassIdGen.nextId()
@@ -169,6 +179,16 @@ open class ObjClass(
*/ */
var classScope: Scope? = null 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). */ /** Direct parents in declaration order (kept deterministic). */
val directParents: List<ObjClass> = parents.toList() val directParents: List<ObjClass> = parents.toList()
@@ -1160,8 +1180,11 @@ open class ObjClass(
scope: Scope, name: String, args: Arguments, scope: Scope, name: String, args: Arguments,
onNotFoundResult: (suspend () -> Obj?)? onNotFoundResult: (suspend () -> Obj?)?
): Obj { ): Obj {
getInstanceMemberOrNull(name)?.let { rec -> classScope?.objects?.get(name)?.let { rec ->
val decl = rec.declaringClass ?: findDeclaringClassOf(name) ?: this val decl = rec.declaringClass ?: this
if (!rec.visibility.isPublic) {
return super.invokeInstanceMethod(scope, name, args, onNotFoundResult)
}
if (rec.type == ObjRecord.Type.Delegated) { if (rec.type == ObjRecord.Type.Delegated) {
val del = rec.delegate ?: scope.raiseError("Internal error: delegated member $name has no delegate") val del = rec.delegate ?: scope.raiseError("Internal error: delegated member $name has no delegate")
val allArgs = (listOf(this, ObjString(name)) + args.list).toTypedArray() val allArgs = (listOf(this, ObjString(name)) + args.list).toTypedArray()
@@ -0,0 +1,125 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.obj
import net.sergeych.lyng.*
import net.sergeych.lyng.miniast.addPropertyDoc
import net.sergeych.lyng.miniast.type
import net.sergeych.lyng.requiredArg
object ObjComplexSupport {
private object BoundMarker
private val complexTypeDecl = TypeDecl.Simple("lyng.complex.Complex", false)
suspend fun bindTo(module: ModuleScope) {
val complexClass = module.requireClass("Complex")
if (complexClass.kotlinClassData === BoundMarker) return
complexClass.kotlinClassData = BoundMarker
val decimalModule = module.currentImportProvider.createModuleScope(module.pos, "lyng.decimal")
val decimalClass = decimalModule.requireClass("Decimal")
decimalClass.addPropertyDoc(
name = "re",
doc = "Convert this Decimal to a Complex with zero imaginary part.",
type = type("lyng.complex.Complex"),
moduleName = "lyng.complex",
getter = {
newComplex(
complexClass,
decimalToReal(thisObj),
0.0
)
}
)
decimalClass.members["re"] = decimalClass.members.getValue("re").copy(typeDecl = complexTypeDecl)
decimalClass.addPropertyDoc(
name = "i",
doc = "Convert this Decimal to a pure imaginary Complex after rounding to Real.",
type = type("lyng.complex.Complex"),
moduleName = "lyng.complex",
getter = {
newComplex(
complexClass,
0.0,
decimalToReal(thisObj)
)
}
)
decimalClass.members["i"] = decimalClass.members.getValue("i").copy(typeDecl = complexTypeDecl)
OperatorInteropRegistry.register(
leftClass = decimalClass,
rightClass = complexClass,
commonClass = complexClass,
operatorNames = listOf(
InteropOperator.Plus.name,
InteropOperator.Minus.name,
InteropOperator.Mul.name,
InteropOperator.Div.name
),
leftToCommon = ObjExternCallable.fromBridge {
newComplex(
complexClass,
decimalToReal(requiredArg(0)),
0.0
)
},
rightToCommon = ObjExternCallable.fromBridge {
requiredArg<Obj>(0)
}
)
}
internal suspend fun decimalBinary(scope: ScopeFacade, decimal: Obj, other: Obj, operator: InteropOperator): Obj? {
val left = ObjDecimalSupport.toDoubleOrNull(decimal) ?: return null
val complex = other as? ObjInstance ?: return null
if (complex.objClass.className != "Complex") return null
val otherReal = complex.readField(scope.requireScope(), "real").value.toDouble()
val otherImag = complex.readField(scope.requireScope(), "imag").value.toDouble()
return when (operator) {
InteropOperator.Plus -> instantiateComplex(scope, complex.objClass, left + otherReal, otherImag)
InteropOperator.Minus -> instantiateComplex(scope, complex.objClass, left - otherReal, -otherImag)
InteropOperator.Mul -> instantiateComplex(scope, complex.objClass, left * otherReal, left * otherImag)
InteropOperator.Div -> {
val denominator = otherReal * otherReal + otherImag * otherImag
instantiateComplex(scope, complex.objClass, left * otherReal / denominator, -left * otherImag / denominator)
}
else -> null
}
}
private suspend fun ScopeFacade.newComplex(complexClass: ObjClass, real: Double, imag: Double): ObjInstance =
instantiateComplex(this, complexClass, real, imag)
private suspend fun instantiateComplex(scope: ScopeFacade, complexClass: ObjClass, real: Double, imag: Double): ObjInstance {
val runtimeScope = scope.requireScope()
val instance = complexClass.createInstance(runtimeScope)
complexClass.initializeInstance(
instance,
Arguments(ObjReal.of(real), ObjReal.of(imag)),
runConstructors = false
)
return instance
}
private fun ScopeFacade.decimalToReal(value: Obj): Double =
ObjDecimalSupport.toDoubleOrNull(value)
?: raiseClassCastError("expected Decimal-compatible value, got ${value.objClass.className}")
}
@@ -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 package net.sergeych.lyng.obj
import kotlinx.coroutines.Deferred import kotlinx.coroutines.Deferred
import kotlin.coroutines.cancellation.CancellationException as KotlinCancellationException
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.miniast.addFnDoc import net.sergeych.lyng.miniast.addFnDoc
import net.sergeych.lyng.miniast.addPropertyDoc import net.sergeych.lyng.miniast.addPropertyDoc
@@ -33,12 +34,27 @@ open class ObjDeferred(val deferred: Deferred<Obj>): Obj() {
scope.raiseError("Deferred constructor is not directly callable") scope.raiseError("Deferred constructor is not directly callable")
} }
}.apply { }.apply {
addFnDoc(
name = "cancel",
doc = "Cancel this deferred if it is still active. Safe to call multiple times.",
returns = type("lyng.Void"),
moduleName = "lyng.stdlib"
) {
thisAs<ObjDeferred>().deferred.cancel()
ObjVoid
}
addFnDoc( addFnDoc(
name = "await", name = "await",
doc = "Suspend until completion and return the result value (or throw if failed).", doc = "Suspend until completion and return the result value. Throws `CancellationException` if cancelled.",
returns = type("lyng.Any"), returns = type("lyng.Any"),
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { thisAs<ObjDeferred>().deferred.await() } ) {
try {
thisAs<ObjDeferred>().deferred.await()
} catch (e: KotlinCancellationException) {
requireScope().raiseError(ObjCancellationException(requireScope(), e.message ?: "Deferred was cancelled"))
}
}
addPropertyDoc( addPropertyDoc(
name = "isCompleted", name = "isCompleted",
doc = "Whether this deferred has completed (successfully or with an error).", doc = "Whether this deferred has completed (successfully or with an error).",
@@ -66,4 +82,3 @@ open class ObjDeferred(val deferred: Deferred<Obj>): Obj() {
} }
} }
} }
@@ -129,6 +129,7 @@ open class ObjDynamic(var readCallback: Obj? = null, var writeCallback: Obj? = n
} }
val type = object : ObjClass("Delegate") {}.apply { val type = object : ObjClass("Delegate") {}.apply {
logicalPackageNameOverride = "lyng.stdlib"
addFn("getValue") { raiseError("Delegate.getValue is not implemented") } addFn("getValue") { raiseError("Delegate.getValue is not implemented") }
addFn("setValue") { raiseError("Delegate.setValue is not implemented") } addFn("setValue") { raiseError("Delegate.setValue is not implemented") }
addFn("invoke") { raiseError("Delegate.invoke is not implemented") } addFn("invoke") { raiseError("Delegate.invoke is not implemented") }
@@ -278,6 +278,7 @@ open class ObjException(
"AssertionFailedException", "AssertionFailedException",
"ClassCastException", "ClassCastException",
"IndexOutOfBoundsException", "IndexOutOfBoundsException",
"CancellationException",
"IllegalArgumentException", "IllegalArgumentException",
"IllegalStateException", "IllegalStateException",
"NoSuchElementException", "NoSuchElementException",
@@ -311,6 +312,9 @@ class ObjClassCastException(scope: Scope, message: String) : ObjException("Class
class ObjIndexOutOfBoundsException(scope: Scope, message: String = "index out of bounds") : class ObjIndexOutOfBoundsException(scope: Scope, message: String = "index out of bounds") :
ObjException("IndexOutOfBoundsException", scope, message) ObjException("IndexOutOfBoundsException", scope, message)
class ObjCancellationException(scope: Scope, message: String = "cancelled") :
ObjException("CancellationException", scope, message)
class ObjIllegalArgumentException(scope: Scope, message: String = "illegal argument") : class ObjIllegalArgumentException(scope: Scope, message: String = "illegal argument") :
ObjException("IllegalArgumentException", scope, message) ObjException("IllegalArgumentException", scope, message)
@@ -364,6 +364,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
onNotFoundResult: (suspend () -> Obj?)? onNotFoundResult: (suspend () -> Obj?)?
): Obj { ): Obj {
val caller = scope.currentClassCtx val caller = scope.currentClassCtx
val methodScope = scope.applyClosure(instanceScope)
// Fast path for public members when outside any class context // Fast path for public members when outside any class context
if (caller == null) { if (caller == null) {
@@ -373,7 +374,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
if (rec.type == ObjRecord.Type.Property) { if (rec.type == ObjRecord.Type.Property) {
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, decl) if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, decl)
} else if (rec.type == ObjRecord.Type.Fun) { } 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 (rec.type == ObjRecord.Type.Property) {
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, decl) if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, decl)
} else if (rec.type == ObjRecord.Type.Fun) { } 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 (rec.type == ObjRecord.Type.Property) {
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, decl) if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, decl)
} else if (rec.type == ObjRecord.Type.Fun) { } 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 (rec.type == ObjRecord.Type.Property) {
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, c) if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, c)
} else if (rec.type == ObjRecord.Type.Fun) { } 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 (rec.type == ObjRecord.Type.Property) {
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, c) if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, c)
} else if (rec.type == ObjRecord.Type.Fun) { } 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 (rec.type == ObjRecord.Type.Property) {
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, c) if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, c)
} else if (rec.type == ObjRecord.Type.Fun) { } 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 decl = rec.declaringClass ?: objClass.findDeclaringClassOf(name) ?: objClass
val effectiveCaller = caller ?: if (scope.thisObj === this) objClass else null val effectiveCaller = caller ?: if (scope.thisObj === this) objClass else null
if (canAccessMember(rec.visibility, decl, effectiveCaller, name)) { 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) if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, decl)
} else if (rec.type == ObjRecord.Type.Fun) { } else if (rec.type == ObjRecord.Type.Fun) {
return rec.value.invoke( return rec.value.invoke(
instanceScope, methodScope,
this, this,
args, args,
decl decl
@@ -586,8 +587,14 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
} }
override suspend fun compareTo(scope: Scope, other: Obj): Int { override suspend fun compareTo(scope: Scope, other: Obj): Int {
if (other !is ObjInstance) return -1 val explicitCompare = objClass.getInstanceMemberOrNull("compareTo", includeStatic = false)
if (other.objClass != objClass) return -1 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) { for (f in comparableVars) {
val a = f.value.value 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") 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.JsonElement
import kotlinx.serialization.json.JsonPrimitive import kotlinx.serialization.json.JsonPrimitive
import net.sergeych.lyng.InteropOperator
import net.sergeych.lyng.OperatorInteropRegistry
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.miniast.addFnDoc import net.sergeych.lyng.miniast.addFnDoc
import net.sergeych.lynon.LynonDecoder 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 { override suspend fun compareTo(scope: Scope, other: Obj): Int {
if (other !is Numeric) return -2
return if (other is ObjInt) { return if (other is ObjInt) {
value.compareTo(other.value) value.compareTo(other.value)
} else { } else {
OperatorInteropRegistry.invokeCompare(scope, this, other)?.let { return it }
if (other !is Numeric) return -2
doubleValue.compareTo(other.doubleValue) doubleValue.compareTo(other.doubleValue)
} }
} }
@@ -70,28 +73,39 @@ class ObjInt(val value: Long, override val isConst: Boolean = false) : Obj(), Nu
if (other is ObjInt) if (other is ObjInt)
of(this.value + other.value) of(this.value + other.value)
else else
OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Plus)
?:
ObjReal.of(this.doubleValue + other.toDouble()) ObjReal.of(this.doubleValue + other.toDouble())
override suspend fun minus(scope: Scope, other: Obj): Obj = override suspend fun minus(scope: Scope, other: Obj): Obj =
if (other is ObjInt) if (other is ObjInt)
of(this.value - other.value) of(this.value - other.value)
else else
OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Minus)
?:
ObjReal.of(this.doubleValue - other.toDouble()) ObjReal.of(this.doubleValue - other.toDouble())
override suspend fun mul(scope: Scope, other: Obj): Obj = override suspend fun mul(scope: Scope, other: Obj): Obj =
if (other is ObjInt) { if (other is ObjInt) {
of(this.value * other.value) 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 = override suspend fun div(scope: Scope, other: Obj): Obj =
if (other is ObjInt) if (other is ObjInt)
of(this.value / other.value) 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 = override suspend fun mod(scope: Scope, other: Obj): Obj =
if (other is ObjInt) if (other is ObjInt)
of(this.value % other.value) 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. * 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.JsonElement
import kotlinx.serialization.json.JsonPrimitive import kotlinx.serialization.json.JsonPrimitive
import net.sergeych.lyng.InteropOperator
import net.sergeych.lyng.OperatorInteropRegistry
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.miniast.addConstDoc import net.sergeych.lyng.miniast.addConstDoc
import net.sergeych.lyng.miniast.addFnDoc import net.sergeych.lyng.miniast.addFnDoc
@@ -40,6 +42,9 @@ data class ObjReal(val value: Double) : Obj(), Numeric {
override fun byValueCopy(): Obj = this override fun byValueCopy(): Obj = this
override suspend fun compareTo(scope: Scope, other: Obj): Int { override suspend fun compareTo(scope: Scope, other: Obj): Int {
if (other is ObjReal) return value.compareTo(other.value)
ObjDecimalSupport.mixedRealDecimalCompareFallback(this, other)?.let { return it }
OperatorInteropRegistry.invokeCompare(scope, this, other)?.let { return it }
if (other !is Numeric) return -2 if (other !is Numeric) return -2
return value.compareTo(other.doubleValue) return value.compareTo(other.doubleValue)
} }
@@ -63,19 +68,29 @@ data class ObjReal(val value: Double) : Obj(), Numeric {
} }
override suspend fun plus(scope: Scope, other: Obj): Obj = override suspend fun plus(scope: Scope, other: Obj): Obj =
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 = 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 = 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 = 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 = 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 * Returns unboxed Double value
@@ -140,6 +155,22 @@ data class ObjReal(val value: Double) : Obj(), Numeric {
) { ) {
ObjInt.of(thisAs<ObjReal>().value.toLong()) ObjInt.of(thisAs<ObjReal>().value.toLong())
} }
addFnDoc(
name = "isInfinite",
doc = "Return true if this real number is positive or negative infinity.",
returns = type("lyng.Bool"),
moduleName = "lyng.stdlib"
) {
ObjBool(thisAs<ObjReal>().value.isInfinite())
}
addFnDoc(
name = "isNaN",
doc = "Return true if this real number is NaN (not a number).",
returns = type("lyng.Bool"),
moduleName = "lyng.stdlib"
) {
ObjBool(thisAs<ObjReal>().value.isNaN())
}
} }
} }
} }
@@ -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 @Test
fun testMutex() = runTest { fun testMutex() = runTest {
eval( eval(
@@ -17,14 +17,15 @@
package net.sergeych.lyng package net.sergeych.lyng
import com.ionspin.kotlin.bignum.decimal.BigDecimal
import kotlinx.coroutines.test.runTest import kotlinx.coroutines.test.runTest
import net.sergeych.lyng.bridge.bindGlobalFun1 import net.sergeych.lyng.bridge.*
import net.sergeych.lyng.bridge.bindGlobalFun3 import net.sergeych.lyng.obj.ObjInstance
import net.sergeych.lyng.bridge.bindGlobalVar
import net.sergeych.lyng.bridge.globalBinder
import net.sergeych.lyng.obj.ObjInt import net.sergeych.lyng.obj.ObjInt
import net.sergeych.lyng.obj.ObjReal
import net.sergeych.lyng.obj.ObjString import net.sergeych.lyng.obj.ObjString
import kotlin.test.Test import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertTrue import kotlin.test.assertTrue
class GlobalBindingTest { class GlobalBindingTest {
@@ -136,4 +137,87 @@ class GlobalBindingTest {
assertTrue(readonlySetter) assertTrue(readonlySetter)
} }
} }
@Test
fun rawDecimalExternBindingDoesNotBreakDecimalLiteralRendering() = runTest {
val scope = Script.newScope()
var x = BigDecimal.ZERO
scope.eval(
"""
import lyng.decimal
extern var X: Decimal
""".trimIndent()
)
scope.globalBinder().bindGlobalVarRaw(
name = "X",
get = { it.newDecimal(x) },
set = { _, value ->
x = when (value) {
is ObjInt -> BigDecimal.fromLong(value.value)
is ObjReal -> BigDecimal.fromDouble(value.value)
is ObjInstance -> value.data as BigDecimal
else -> error("unexpected value: $value")
}
}
)
scope.eval(
"""
fun main() {
assertEquals("42", 42.d.toStringExpanded())
}
main()
""".trimIndent()
)
assertEquals(BigDecimal.ZERO, x)
}
@Test
fun externDecimalDeclarationAloneDoesNotBreakDecimalLiteralRendering() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.decimal
extern var X: Decimal
fun main() {
assertEquals("42", 42.d.toStringExpanded())
}
main()
""".trimIndent()
)
}
@Test
fun parserKeeps42DotDAsIntDotIdentifierAfterExternDecimalDeclaration() = runTest {
val tokens = parseLyng(
Source(
"test",
"""
import lyng.decimal
extern var X: Decimal
fun main() {
42.d.toStringExpanded()
}
""".trimIndent()
)
)
val tokenTexts = tokens.map { it.type to it.value }
val needle = listOf(
Token.Type.INT to "42",
Token.Type.DOT to ".",
Token.Type.ID to "d",
Token.Type.DOT to ".",
Token.Type.ID to "toStringExpanded",
)
val found = tokenTexts.windowed(needle.size).any { it == needle }
assertTrue(found, tokenTexts.joinToString())
}
} }
@@ -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)
}
}
@@ -114,7 +114,7 @@ class ObjectExpressionTest {
eval(""" eval("""
val x = object { } val x = object { }
val name = ((x::class as Class).className as String) val name = ((x::class as Class).className as String)
assert(name.startsWith("${'$'}Anon_")) assert(name.startsWith("\${'$'}Anon_"))
""".trimIndent()) """.trimIndent())
} }
} }
@@ -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())
}
}
+159 -20
View File
@@ -4194,26 +4194,43 @@ class ScriptTest {
// } // }
// @Ignore @Test
// @Test fun interpolationTest() = runTest {
// fun interpolationTest() = runTest { val d = '$'
// eval($$$""" eval(
// """
// val foo = "bar" val foo = "bar"
// val buzz = ["foo", "bar"] val buzz = ["foo", "bar"]
//
// // 1. simple interpolation // 1. simple interpolation
// assertEquals( "bar", "$foo" ) assertEquals("bar", "${d}foo")
// assertEquals( "bar", "${foo}" ) assertEquals("bar", "${d}{foo}")
//
// // 2. escaping the dollar sign // 2. escaping / literal dollar forms
// assertEquals( "$", "\$foo"[0] ) assertEquals("${d}${d}foo", "\${d}foo")
// assertEquals( "foo, "\$foo"[1..] ) assertEquals("${d}${d}foo", "${d}${d}foo")
// assertEquals("\\bar", "\\${d}foo")
// // 3. interpolation with expression
// assertEquals( "foo!. bar?", "${buzz[0]+"!"}. ${buzz[1]+"?"}" ) // 3. interpolation with expression
// """.trimIndent()) assertEquals("foo!. bar?", "${d}{buzz[0] + "!"}. ${d}{buzz[1] + "?"}")
// } """.trimIndent()
)
}
@Test
fun interpolationCanBeDisabledByFeatureComment() = runTest {
val d = '$'
eval(
"""
// feature: interpolation: off
val name = "lyng"
assertEquals("hello, ${d}name!", "hello, ${d}name!")
assertEquals("${d}{name}", "${d}{name}")
assertEquals("${d}${d}name", "${d}${d}name")
assertEquals("\\${d}name", "\\${d}name")
""".trimIndent()
)
}
@Test @Test
fun testInlineArrayLiteral() = runTest { fun testInlineArrayLiteral() = runTest {
@@ -5254,6 +5271,19 @@ class ScriptTest {
) )
} }
@Test
fun testRealIsInfiniteAndIsNaN() = runTest {
eval(
"""
assertEquals(false, 1.0.isInfinite())
assertEquals(true, (1.0 / 0.0).isInfinite())
assertEquals(true, (-1.0 / 0.0).isInfinite())
assertEquals(false, 1.0.isNaN())
assertEquals(true, (0.0 / 0.0).isNaN())
""".trimIndent()
)
}
@Test @Test
fun testEmptySpreadList() = runTest { fun testEmptySpreadList() = runTest {
eval( eval(
@@ -5443,4 +5473,113 @@ class ScriptTest {
""".trimIndent() """.trimIndent()
) )
} }
@Test
fun testFromCalcurus1() = runTest {
eval($$"""
/*
Рассчитывает глубину провала по времени падения камня и прихода звука.
@param T измеренное полное время (с)
@param m масса камня (кг)
@param d диаметр камня (м) (предполагается сферическая форма)
@param rho плотность воздуха (кг/м³), по умолчанию 1.2
@param c скорость звука (м/с), по умолчанию 340.0
@param g ускорение свободного падения (м/с²), по умолчанию 9.81
@param Cd коэффициент лобового сопротивления, по умолчанию 0.5
@param epsilon относительная точность (м), по умолчанию 1e-3
@param maxIter максимальное число итераций, по умолчанию 20
@return глубина h (м), или null если расчёт не сошёлся
*/
fun calculateDepth(
T: Real,
m: Real,
d: Real,
rho: Real = 1.2,
c: Real = 340.0,
g: Real = 9.81,
Cd: Real = 0.5,
epsilon: Real = 1e-3,
maxIter: Int = 20
): Real? {
// Площадь миделя
val r = d / 2.0
val A = π * r * r
// Коэффициент сопротивления
val k = 0.5 * Cd * rho * A
// Предельная скорость
val vTerm = sqrt(m * g / k)
// Функция времени падения с высоты h
fun tFall(h: Real): Real {
val arg = exp(g * h / (vTerm * vTerm))
// arcosh(x) = ln(x + sqrt(x^2 - 1))
val arcosh = ln(arg + sqrt(arg * arg - 1.0))
return vTerm / g * arcosh
}
// Производная времени падения по h
fun dtFall_dh(h: Real): Real {
val expArg = exp(2.0 * g * h / (vTerm * vTerm))
return 1.0 / (vTerm * sqrt(expArg - 1.0))
}
// Полное расчётное время T_calc(h) = tFall(h) + h/c
fun Tcalc(h: Real): Real = tFall(h) + h / c
// Производная T_calc по h
fun dTcalc_dh(h: Real): Real = dtFall_dh(h) + 1.0 / c
// Начальное приближение (без сопротивления)
val term = 1.0 + g * T / c
val sqrtTerm = sqrt(1.0 + 2.0 * g * T / c)
var h = (c * c / g) * (term - sqrtTerm)
// Проверка на валидность начального приближения
if (h.isNaN() || h <= 0.0) {
// Если формула дала некорректный результат, используем оценку по свободному падению
h = 0.5 * g * T * T // грубая оценка, всё равно будет уточняться
if (h.isNaN() || h <= 0.0) return null
}
// Итерации Ньютона
var iter = 0
while (iter < maxIter) {
val f = Tcalc(h) - T
val df = dTcalc_dh(h)
// Если производная близка к нулю, выходим
if (abs(df) < 1e-12) return null
val hNew = h - f / df
// Проверка сходимости
if (abs(hNew - h) < epsilon) {
return hNew
}
h = hNew
iter++
}
// Не сошлось за maxIter
return null
}
// Пример использования
val T = 6.0 // секунды
val m = 1.0 // кг
val d = 0.1 // м (10 см)
val depth = calculateDepth(T, m, d)
if (depth != null) {
println("Глубина: %.2f м"(depth))
} else {
println("Расчёт не сошёлся")
}
""".trimIndent())
}
} }
@@ -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) 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 @Test
fun testLazyIsDelegate() = runTest { fun testLazyIsDelegate() = runTest {
eval(""" 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())
}
}
@@ -0,0 +1,53 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.matrix
import org.jetbrains.kotlinx.multik.api.mk
import org.jetbrains.kotlinx.multik.api.ndarray
import org.jetbrains.kotlinx.multik.api.linalg.dot
import org.jetbrains.kotlinx.multik.api.linalg.inv
import org.jetbrains.kotlinx.multik.ndarray.data.get
internal actual object PlatformMatrixBackend {
actual fun multiply(left: MatrixData, right: MatrixData): MatrixData {
require(left.cols == right.rows) {
"matrix multiplication shape mismatch: ${left.rows}x${left.cols} cannot multiply ${right.rows}x${right.cols}"
}
val leftArray = mk.ndarray(left.values, left.rows, left.cols)
val rightArray = mk.ndarray(right.values, right.rows, right.cols)
val product = leftArray dot rightArray
return MatrixData(left.rows, right.cols, extract(product, left.rows, right.cols))
}
actual fun inverse(matrix: MatrixData): MatrixData {
require(matrix.isSquare) { "matrix inverse requires a square matrix, got ${matrix.rows}x${matrix.cols}" }
val source = mk.ndarray(matrix.values, matrix.rows, matrix.cols)
val inverse = mk.linalg.inv(source)
return MatrixData(matrix.rows, matrix.cols, extract(inverse, matrix.rows, matrix.cols))
}
private fun extract(array: org.jetbrains.kotlinx.multik.ndarray.data.D2Array<Double>, rows: Int, cols: Int): DoubleArray {
val out = DoubleArray(rows * cols)
for (row in 0 until rows) {
for (col in 0 until cols) {
out[row * cols + col] = array[row, col]
}
}
return out
}
}
@@ -0,0 +1,26 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.matrix
internal actual object PlatformMatrixBackend {
actual fun multiply(left: MatrixData, right: MatrixData): MatrixData =
PureMatrixAlgorithms.multiply(left, right)
actual fun inverse(matrix: MatrixData): MatrixData =
PureMatrixAlgorithms.inverse(matrix)
}
+134
View File
@@ -0,0 +1,134 @@
package lyng.complex
import lyng.operators
/*
Complex number backed by `Real` components.
This module intentionally keeps the storage model simple:
- `re`: real part
- `im`: imaginary part
The algebra is implemented in pure Lyng and interoperates with `Int` and `Real`
through `lyng.operators`, so expressions like `1 + 2.i` and `0.5 * (1 + 2.i)` work.
For transcendental functions, use the member-style API for now:
- `z.exp()`
- `z.ln()`
- `z.sin()`
- `z.cos()`
- `z.tan()`
- `z.sqrt()`
This avoids collisions with the built-in real-valued top-level math functions
such as `exp(x)` and `sin(x)`.
*/
class Complex(val real: Real, val imag: Real = 0.0) {
val re get() = real
val im get() = imag
fun plus(other: Complex): Complex = Complex(real + other.real, imag + other.imag)
fun minus(other: Complex): Complex = Complex(real - other.real, imag - other.imag)
fun mul(other: Complex): Complex =
Complex(
real * other.real - imag * other.imag,
real * other.imag + imag * other.real
)
fun div(other: Complex): Complex {
val denominator = other.real * other.real + other.imag * other.imag
Complex(
(real * other.real + imag * other.imag) / denominator,
(imag * other.real - real * other.imag) / denominator
)
}
fun negate(): Complex = Complex(-real, -imag)
val conjugate get() = Complex(real, -imag)
val magnitude2 get() = real * real + imag * imag
val magnitude get() = Math.sqrt(magnitude2)
val phase: Real
get() = if (real > 0.0) {
Math.atan(imag / real)
} else if (real < 0.0 && imag >= 0.0) {
Math.atan(imag / real) + π
} else if (real < 0.0 && imag < 0.0) {
Math.atan(imag / real) - π
} else if (real == 0.0 && imag > 0.0) {
π / 2.0
} else if (real == 0.0 && imag < 0.0) {
-π / 2.0
} else {
0.0
}
fun exp(): Complex {
val scale = Math.exp(real)
Complex(scale * Math.cos(imag), scale * Math.sin(imag))
}
fun ln(): Complex = Complex(Math.ln(magnitude), phase)
fun sin(): Complex =
Complex(
Math.sin(real) * Math.cosh(imag),
Math.cos(real) * Math.sinh(imag)
)
fun cos(): Complex =
Complex(
Math.cos(real) * Math.cosh(imag),
-Math.sin(real) * Math.sinh(imag)
)
fun tan(): Complex = sin() / cos()
fun sqrt(): Complex = if (imag == 0.0 && real >= 0.0) {
Complex(Math.sqrt(real), 0.0)
} else {
val radius = magnitude
val imagPart = Math.sqrt((radius - real) / 2.0)
Complex(Math.sqrt((radius + real) / 2.0), if (imag < 0.0) -imagPart else imagPart)
}
override fun toString() =
real.toString() +
(if (imag < 0.0) imag.toString() else "+" + imag.toString()) +
"i"
static fun fromInt(value: Int): Complex = Complex(value + 0.0, 0.0)
static fun fromReal(value: Real): Complex = Complex(value, 0.0)
static fun imaginary(value: Real): Complex = Complex(0.0, value)
static fun fromPolar(radius: Real, angle: Real): Complex =
Complex(radius * Math.cos(angle), radius * Math.sin(angle))
}
fun complex(re: Real, im: Real = 0.0): Complex = Complex(re, im)
fun cis(angle: Real): Complex = Complex.fromPolar(1.0, angle)
val Int.re: Complex get() = Complex.fromInt(this)
val Real.re: Complex get() = Complex.fromReal(this)
val Int.i: Complex get() = Complex.imaginary(this + 0.0)
val Real.i: Complex get() = Complex.imaginary(this)
OperatorInterop.register(
Int,
Complex,
Complex,
[BinaryOperator.Plus, BinaryOperator.Minus, BinaryOperator.Mul, BinaryOperator.Div],
{ x: Int -> Complex.fromInt(x) },
{ x: Complex -> x }
)
OperatorInterop.register(
Real,
Complex,
Complex,
[BinaryOperator.Plus, BinaryOperator.Minus, BinaryOperator.Mul, BinaryOperator.Div],
{ x: Real -> Complex.fromReal(x) },
{ x: Complex -> x }
)
+157
View File
@@ -0,0 +1,157 @@
package lyng.matrix
type MatrixScalar = Real | Int
/** Dense immutable vector backed by double-precision elements. */
extern class Vector() {
/** Number of elements. */
val size: Int
/** Alias to `size`. */
val length: Int
/** Convert to a plain list. */
extern fun toList(): List<Real>
/** Get one element by zero-based index. */
extern fun get(index: Int): Real
/** Element-wise addition. */
extern fun plus(other: Vector): Vector
/** Element-wise subtraction. */
extern fun minus(other: Vector): Vector
/** Scale every element. */
extern fun mul(other: MatrixScalar): Vector
/** Divide every element by a scalar. */
extern fun div(other: MatrixScalar): Vector
/** Dot product. */
extern fun dot(other: Vector): Real
/** Euclidean norm. */
extern fun norm(): Real
/** Return a unit-length vector in the same direction. */
extern fun normalize(): Vector
/** 3D cross product. Both vectors must have length 3. */
extern fun cross(other: Vector): Vector
/** Outer product, returning a matrix of shape `(this.size, other.size)`. */
extern fun outer(other: Vector): Matrix
/** Build a vector from numeric values. */
static extern fun fromList(values: List<MatrixScalar>): Vector
/** Zero-filled vector. */
static extern fun zeros(size: Int): Vector
}
/**
* Dense immutable matrix backed by double-precision elements.
*
* `Matrix` supports arbitrary rectangular geometry (`rows x cols`), matrix arithmetic,
* transpose, determinant, and inversion.
*
* Use this type for numeric linear algebra where contiguous dense storage is appropriate.
*/
extern class Matrix() {
/** Number of rows. */
val rows: Int
/** Number of columns. */
val cols: Int
/** Two-element shape `[rows, cols]`. */
val shape: List<Int>
/** Whether `rows == cols`. */
val isSquare: Bool
/** Element-wise addition. Shapes must match. */
extern fun plus(other: Matrix): Matrix
/** Element-wise subtraction. Shapes must match. */
extern fun minus(other: Matrix): Matrix
/**
* Multiply by another matrix, by a vector, or by a scalar.
*
* - `Matrix * Matrix`: matrix product (`A.cols == B.rows`)
* - `Matrix * Vector`: matrix-vector product (`A.cols == x.size`)
* - `Matrix * MatrixScalar`: scale every element
*/
extern fun mul(other: Matrix | Vector | MatrixScalar): Matrix | Vector
/** Divide every element by a scalar. */
extern fun div(other: MatrixScalar): Matrix
/** Matrix transpose. */
extern fun transpose(): Matrix
/** Sum of diagonal elements of a square matrix. */
extern fun trace(): Real
/** Row rank computed numerically via row-echelon reduction. */
extern fun rank(): Int
/**
* Determinant of a square matrix.
*
* Raises an error for non-square matrices.
*/
extern fun determinant(): Real
/**
* Inverse of a square matrix.
*
* Raises an error for non-square or singular matrices.
*/
extern fun inverse(): Matrix
/**
* Solve `A * x = rhs`.
*
* - with a `Vector` right-hand side, returns a `Vector`
* - with a `Matrix` right-hand side, returns a `Matrix`
*/
extern fun solve(rhs: Vector | Matrix): Vector | Matrix
/**
* Bracket indexing by `[row, col]`.
*
* Each selector may be an `Int` or a `Range`:
* - `m[1, 2]` returns one scalar
* - `m[0..2, 2]` returns a `3x1` matrix
* - `m[0..2, 0..2]` returns a sub-matrix
* - `m[1.., 1..]` returns the bottom-right tail
*/
override extern fun getAt(index: List<Int | Range>): Real | Matrix
/** Get one element by zero-based row and column indices. */
extern fun get(row: Int, col: Int): Real
/** Return one row as a `List<Real>`. */
extern fun row(index: Int): List<Real>
/** Return one column as a `List<Real>`. */
extern fun column(index: Int): List<Real>
/** Convert to nested row lists. */
extern fun toList(): List<List<Real>>
/** Build a matrix from nested row lists. All rows must have the same length. */
static extern fun fromRows(rows: List<List<MatrixScalar>>): Matrix
/** Create a zero-filled matrix. */
static extern fun zeros(rows: Int, cols: Int): Matrix
/** Create an identity matrix of shape `(size, size)`. */
static extern fun identity(size: Int): Matrix
}
fun vector(values: List<MatrixScalar>): Vector = Vector.fromList(values)
fun matrix(rows: List<List<MatrixScalar>>): Matrix = Matrix.fromRows(rows)
+49 -5
View File
@@ -1,11 +1,48 @@
package lyng.stdlib package lyng.stdlib
/* Launch `code` asynchronously and return its result handle. */
extern fun launch(code): Deferred
/* Yield execution so other scheduled coroutines can run. */
extern fun yield(): void
/* Build a lazy asynchronous sequence. */
extern fun flow(builder: FlowBuilder.()->void): Flow extern fun flow(builder: FlowBuilder.()->void): Flow
/* Built-in exception type. */ /* Built-in exception type. */
extern class Exception extern class Exception
extern class IllegalArgumentException extern class IllegalArgumentException
extern class NotImplementedException extern class NotImplementedException
/* Raised when an awaited asynchronous task was cancelled before producing a value. */
extern class CancellationException : Exception
/* A handle to a running asynchronous task. */
extern class Deferred {
/* Cancel the task if it is still active. Safe to call multiple times. */
fun cancel(): void
/* Suspend until the task finishes and return its value.
Throws `CancellationException` if the task was cancelled. */
fun await(): Object
/* True when the task has finished, failed, or otherwise reached a terminal state. */
val isCompleted: Bool
/* True while the task is still running and has not been cancelled. */
val isActive: Bool
/* True when the task was cancelled. */
val isCancelled: Bool
}
/* A deferred result that can be completed manually. */
extern class CompletableDeferred : Deferred {
fun complete(value: Object): void
}
/* Receiver passed into `flow { ... }` builders. */
extern class FlowBuilder {
fun emit(value: Object): void
}
/* A cold asynchronous iterable sequence. */
extern class Flow<T> : Iterable<T> {
}
extern class Delegate extern class Delegate
extern class Iterable<T> { extern class Iterable<T> {
fun iterator(): Iterator<T> fun iterator(): Iterator<T>
@@ -77,10 +114,18 @@ extern class MapEntry<K,V> : Array<Object> {
} }
// Built-in math helpers (implemented in host runtime). // Built-in math helpers (implemented in host runtime).
extern fun abs(x: Object): Real //
extern fun ln(x: Object): Real // Decimal note:
extern fun pow(x: Object, y: Object): Real // - these helpers accept `Decimal` values too
// - `abs`, `floor`, `ceil`, `round`, and `pow(x, y)` with integral `y` keep decimal arithmetic
// - the remaining decimal cases currently use a temporary bridge:
// `Decimal -> Real -> host math -> Decimal`
// - this is temporary and will be replaced with dedicated decimal implementations
extern fun abs(x: Object): Object
extern fun ln(x: Object): Object
extern fun pow(x: Object, y: Object): Object
extern fun sqrt(x: Object): Real extern fun sqrt(x: Object): Real
extern fun clamp<T>(value: T, range: Range<T>): T
class SeededRandom { class SeededRandom {
extern fun nextInt(): Int extern fun nextInt(): Int
@@ -420,7 +465,6 @@ fun with<T,R>(self: T, block: T.()->R): R {
Can only be used with 'val' properties. Can only be used with 'val' properties.
*/ */
class lazy<T,ThisRefType=Object>(creatorParam: ThisRefType.()->T) : Delegate<T,ThisRefType> { class lazy<T,ThisRefType=Object>(creatorParam: ThisRefType.()->T) : Delegate<T,ThisRefType> {
private val creator: ThisRefType.()->T = creatorParam
private var value = Unset private var value = Unset
override fun bind(name: String, access: DelegateAccess, thisRef: ThisRefType): Object { override fun bind(name: String, access: DelegateAccess, thisRef: ThisRefType): Object {
@@ -430,7 +474,7 @@ class lazy<T,ThisRefType=Object>(creatorParam: ThisRefType.()->T) : Delegate<T,T
override fun getValue(thisRef: ThisRefType, name: String): T { override fun getValue(thisRef: ThisRefType, name: String): T {
if (value == Unset) if (value == Unset)
value = with(thisRef,creator) value = with(thisRef, creatorParam)
value as T value as T
} }
} }
+2 -2
View File
@@ -1,5 +1,5 @@
/* /*
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com * Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -21,7 +21,7 @@
plugins { plugins {
alias(libs.plugins.kotlinMultiplatform) alias(libs.plugins.kotlinMultiplatform)
id("org.jetbrains.kotlin.plugin.compose") version "2.2.21" id("org.jetbrains.kotlin.plugin.compose") version "2.3.20"
id("org.jetbrains.compose") version "1.9.3" id("org.jetbrains.compose") version "1.9.3"
`maven-publish` `maven-publish`
} }
+36
View File
@@ -0,0 +1,36 @@
# Decimal Math TODO
These stdlib math helpers currently accept `Decimal`, but some still use the temporary compatibility path
`Decimal -> Real -> host math -> Decimal`
instead of a native decimal implementation.
## Still Using The Temporary Real Bridge
- `sin(x)`
- `cos(x)`
- `tan(x)`
- `asin(x)`
- `acos(x)`
- `atan(x)`
- `sinh(x)`
- `cosh(x)`
- `tanh(x)`
- `asinh(x)`
- `acosh(x)`
- `atanh(x)`
- `exp(x)`
- `ln(x)`
- `log10(x)`
- `log2(x)`
- `sqrt(x)`
- `pow(x, y)` when the decimal case is not reducible to an integral exponent
## Already Native For Decimal
- `abs(x)`
- `floor(x)`
- `ceil(x)`
- `round(x)`
- `pow(x, y)` with integral exponent `y`
@@ -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.
+46
View File
@@ -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
```
Этот код крайне эффективно реализуется на любом реальном процессоре, и хорошо оптимизируется. Исполняется он без всякого стека.
+21
View File
@@ -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, множественное наследование С++ или Линга и кошмар на улице вязов от руста, в владением ссылками).
Платформ на васме полно, и там и ловить нечего, и неинтересно. Я же предлагаю вылезти в другой класс. Навеяно реальным опоытом переносов контрактов из старого золота в мольтпей, которое получается на удивление хорошо
+21 -4
View File
@@ -1,5 +1,5 @@
/* /*
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com * Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -21,8 +21,8 @@
plugins { plugins {
alias(libs.plugins.kotlinMultiplatform) alias(libs.plugins.kotlinMultiplatform)
// Compose compiler plugin for Kotlin 2.2.21 (matches version catalog) // Compose compiler plugin aligned with the project Kotlin version.
id("org.jetbrains.kotlin.plugin.compose") version "2.2.21" id("org.jetbrains.kotlin.plugin.compose") version "2.3.20"
// Compose Multiplatform plugin for convenient dependencies (compose.html.core, etc.) // Compose Multiplatform plugin for convenient dependencies (compose.html.core, etc.)
id("org.jetbrains.compose") version "1.9.3" id("org.jetbrains.compose") version "1.9.3"
} }
@@ -117,10 +117,27 @@ val generateDocsIndex by tasks.registering {
} }
} }
val generateSiteVersion by tasks.registering(Copy::class) {
group = "documentation"
description = "Generates lyng-version.js from :lynglib version"
val outDir = layout.buildDirectory.dir("generated-resources")
val versionText = project(":lynglib").version.toString()
inputs.property("lyngVersion", versionText)
from(layout.projectDirectory.dir("src/version-template")) {
include("lyng-version.js")
filter<org.apache.tools.ant.filters.ReplaceTokens>(
"tokens" to mapOf("LYNG_VERSION" to versionText)
)
}
into(outDir)
}
// Ensure any ProcessResources task depends on docs index generation so the JSON is packaged // Ensure any ProcessResources task depends on docs index generation so the JSON is packaged
tasks.configureEach { tasks.configureEach {
if (name.endsWith("ProcessResources")) { if (name.endsWith("ProcessResources")) {
dependsOn(generateDocsIndex) dependsOn(generateDocsIndex, generateSiteVersion)
} }
} }
+2
View File
@@ -70,6 +70,7 @@ fun App() {
PageTemplate(title = when { PageTemplate(title = when {
isDocsRoute -> null isDocsRoute -> null
route.startsWith("authors") -> "Authors"
route.startsWith("reference") -> "Reference" route.startsWith("reference") -> "Reference"
route.isBlank() -> null route.isBlank() -> null
else -> null else -> null
@@ -118,6 +119,7 @@ fun App() {
Div({ classes("col-12", if (isDocsRoute) "col-lg-9" else "col-lg-12") }) { Div({ classes("col-12", if (isDocsRoute) "col-lg-9" else "col-lg-12") }) {
when { when {
route.isBlank() -> HomePage() route.isBlank() -> HomePage()
route.startsWith("authors") -> AuthorsPage()
route.startsWith("tryling") -> TryLyngPage(route) route.startsWith("tryling") -> TryLyngPage(route)
route.startsWith("search") -> SearchPage(route) route.startsWith("search") -> SearchPage(route)
!isDocsRoute -> ReferencePage() !isDocsRoute -> ReferencePage()
+63
View File
@@ -0,0 +1,63 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
import androidx.compose.runtime.Composable
import org.jetbrains.compose.web.dom.*
@Composable
fun AuthorsPage() {
Div({ classes("text-center", "mb-4") }) {
P({
classes("lead", "text-muted", "mb-0", "mx-auto")
attr("style", "max-width: 42rem;")
}) {
Text("Designed and built with care. Special thanks to everyone around Lyng who helped shape the language, the tools, and the site into what it is now.")
}
}
Div({ classes("row", "g-4", "justify-content-center") }) {
listOf(
Triple(
"Sergey Chernov",
"Initial idea and architecture, language concept, design, implementation.",
Pair("@sergeych", "https://www.gravatar.com/avatar/7e3a56ff8a090fc9ffbd1909dea94904?s=128&d=identicon")
),
Triple(
"Yulia Nezhinskaya",
"System analysis, math and feature design.",
Pair("@AlterEgoJuliaN", "https://www.gravatar.com/avatar/53a90bca30c85a81db8f0c0d8dea43a1?s=128&d=identicon")
)
).forEach { (name, bio, profile) ->
Div({ classes("col-12", "col-lg-5") }) {
Div({ classes("h-100", "p-4", "border", "rounded-4", "bg-body-tertiary", "text-center") }) {
Img(
src = profile.second,
alt = name,
attrs = {
classes("rounded-circle", "mb-3")
attr("width", "88")
attr("height", "88")
}
)
H2({ classes("h4", "mb-1") }) { Text(name) }
P({ classes("text-primary", "small", "mb-2") }) { Text(profile.first) }
P({ classes("text-muted", "mb-0") }) { Text(bio) }
}
}
}
}
}
Loaded 100 of 106 files, more files were not shown because too many files have changed in this diff. Show more