v1.5.5 release

docs/Iterable.md

@@ -55,6 +55,23 @@ Here is the sample:
     assertEquals( (1..3).joinToString { it * 10 }, "10 20 30")
     >>> void
 
+## joinAll
+
+`joinAll()` is an `Iterable<Deferred>` helper that awaits every deferred in iteration order and returns a `List`
+with the collected results.
+
+    val jobs = (1..4).map { n ->
+        launch { n * n }
+    }
+    assertEquals([1, 4, 9, 16], jobs.joinAll())
+    >>> void
+
+Notes:
+
+- it does not start any task by itself; it only awaits the deferreds already present in the iterable.
+- awaiting happens in iteration order, so the result list keeps the same order as the input iterable.
+- if any deferred fails or was cancelled, that `await()` error is propagated from `joinAll()`.
+
 ## `sum` and `sumOf`
 
 These, again, does the thing:
@@ -184,6 +201,7 @@ Search for the first element that satisfies the given predicate:
 | sortedWith(comparator) | sort using a comparator that compares elements (1)                              |
 | sortedBy(predicate)    | sort by comparing results of the predicate function                             |
 | joinToString(s,t)      | convert iterable to string, see (2)                                             |
+| joinAll()              | for `Iterable<Deferred>`, await all items in order and collect results to [List] |
 | reversed()             | create a list containing items from this in reverse order                       |
 | shuffled()             | create a list of shuffled elements                                              |
 

docs/LaunchPool.md

@@ -73,13 +73,13 @@ pool.closeAndJoin()
 
 ## Collecting all results
 
-`launch` returns a `Deferred`, so you can collect results via `map`:
+`launch` returns a `Deferred`, so you can collect results with `joinAll()`:
 
 ```lyng
 val pool = LaunchPool(4)
 val jobs = (1..10).map { n -> pool.launch { n * n } }
 pool.closeAndJoin()
-val results = jobs.map { (it as Deferred).await() }
+val results = jobs.joinAll()
 // results == [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
 ```
 

docs/ai_stdlib_reference.md

@@ -18,6 +18,7 @@ Sources: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt`, `lynglib/s
 - Async/concurrency: `launch`, `yield`, `flow`, `delay`.
   - `Deferred.cancel()` cancels an active task.
   - `Deferred.await()` throws `CancellationException` if that task was cancelled.
+  - `Iterable<Deferred>.joinAll()` awaits every deferred in iteration order and returns a `List` of results.
 - 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.

docs/parallelism.md

@@ -36,6 +36,17 @@ This example shows how to launch a coroutine with `launch` which returns [Deferr
 
 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.
 
+When you have an iterable of deferreds, use `joinAll()` to await all of them and collect results in input order:
+
+    val jobs = (1..4).map { n ->
+        launch {
+            delay(1)
+            n * 10
+        }
+    }
+    assertEquals([10, 20, 30, 40], jobs.joinAll())
+    >>> void
+
 If you no longer need the result, cancel the deferred. Awaiting a cancelled deferred throws `CancellationException`:
 
     var reached = false
@@ -269,7 +280,7 @@ val jobs = (1..20).map { n ->
 }
 pool.closeAndJoin()               // wait for all tasks to complete
 
-val results = jobs.map { (it as Deferred).await() }
+val results = jobs.joinAll()
 ```
 
 Exceptions thrown inside a submitted lambda are captured in the returned `Deferred` and do not crash the pool, so other tasks continue running normally.

docs/whats_new.md

@@ -1,26 +1,29 @@
 # What's New in Lyng
 
-This document highlights the current Lyng release, **1.5.4**, and the broader additions from the 1.5 cycle.
+This document highlights the current Lyng release, **1.5.5**, and the broader additions from the 1.5 cycle.
 It is intentionally user-facing: new language features, new modules, new tools, and the practical things you can build with them.
 For a programmer-focused migration summary across 1.5.x, see `docs/whats_new_1_5.md`.
 
-## Release 1.5.4 Highlights
+## Release 1.5.5 Highlights
 
-- `1.5.4` is the stabilization release for the 1.5 feature set.
+- `1.5.5` extends the 1.5 line with practical database APIs, first-class calendar dates, and better coroutine building blocks.
 - The 1.5 line now brings together richer ranges and loops, interpolation, math modules, immutable and observable collections, richer `lyngio`, and much better CLI/IDE support.
-- `1.5.4` specifically fixes user-visible issues around decimal arithmetic, mixed numeric flows, list behavior, and observable list hooks.
-- `1.5.4` also fixes extension-member registration for named singleton `object` declarations, so `fun X.foo()` and `val X.bar` now work as expected.
-- `1.5.4` also lets named singleton `object` declarations use scoped indexer extensions with bracket syntax, so patterns like `Storage["name"]` can be implemented with `override fun Storage.getAt(...)` / `putAt(...)`.
+- `1.5.5` adds `Channel`, `LaunchPool`, and `joinAll()` so coroutine-heavy scripts can coordinate work more directly.
+- `1.5.5` adds `Date`, the portable `lyng.io.db` layer, SQLite/JDBC providers, and a compatibility `lyng.legacy_digest` module.
+- `1.5.5` also continues runtime/compiler hardening with better import dispatch, faster exact lambda calls, and correct `val +=`/`-=` behavior for mutating types versus real reassignment.
 - The docs, homepage samples, and release metadata now point at the current stable version.
 
 ## User Highlights Across 1.5.x
 
 - Descending ranges and loops with `downTo` / `downUntil`
 - String interpolation with `$name` and `${expr}`
+- Backtick string literals for raw-ish string text
 - Decimal arithmetic, matrices/vectors, and complex numbers
 - Calendar `Date` support in `lyng.time`
+- `Channel`, `LaunchPool`, and `joinAll()` for coroutine workflows
 - Immutable collections and opt-in `ObservableList`
-- Rich `lyngio` modules for SQLite databases, console, HTTP, WebSocket, TCP, and UDP
+- Rich `lyngio` modules for SQLite/JDBC databases, console, HTTP, WebSocket, TCP, and UDP
+- Legacy SHA-1 compatibility helpers in `lyng.legacy_digest`
 - CLI improvements including the built-in formatter `lyng fmt`
 - Better IDE support and stronger docs around the released feature set
 
@@ -324,7 +327,7 @@ Singleton objects are declared using the `object` keyword. They provide a conven
 
 ```lyng
 object Config {
-    val version = "1.5.4"
+    val version = "1.5.5"
     fun show() = println("Config version: " + version)
 }