scala3

Wasm will not influence Scala.js' semantics. Scala.js "folding back into Scala" would be a regression as far as development for JavaScript platforms goes. Scala without Scala.js means a Scala that cannot interact with its environment, which has JavaScript APIs (e.g., the DOM). I am looking forward to Wasm with GC features as a different target for Scala.js (not Scala), with the same semantics, but different trade-offs in terms of performance and compactness. Scala moving to DOT-based foundations is orthogonal to Scala.js. We'll have to rewrite parts of the compiler to adapt to dotty's internal, of course (and that is being done [1]), but at the language level, it is entirely orthogonal. Of course, we'll benefit from a better union type, which is very important for Scala.js, but it's not really a language interaction. [1] https://github.co

There is also some interesting work (for dotty only atm) on doing the type checking in two phases which would allow the second phase to be parallelized. This could be paired together with the Rsc type checker for the first pass for even bigger improvements. https://github.com/lampepfl/dotty/pull/4767

At least some of the content is appearing as Github issues: https://github.com/lampepfl/dotty/pull/4153

@darkdimius[0], the person who tweeted the referenced tweet in the article, was arguably the primary contributor to Dotty[1] behind Martin Odersky (Dotty will be Scala 3, the next major version of the language). Once he finished his doctorate at the EPFL, off to Stripe he went, bye bye Scala. Tough industry, on the one hand Scala benefits from a revolving door of high level EPFL doctoral students, and on the other the talent pool shifts around as students come and go. Money talks, companies like Stripe have a leg up in that they can fund full-time engineers to work on projects, whereas institution backed projects typically have a much smaller pool of long-term engineers to rely on (JetBrains, for example, has something like 40 full-time engineers working on Kotlin/KotlinJS/Kotlin Native). [0] https://github.com/DarkDimius [1] https://gith

Here's the current state: https://github.com/lampepfl/dotty/pull/4229

I was really hoping they implement python-ish syntax https://github.com/lampepfl/dotty/issues/2491 But no, "Implicit Function Types" instead. Ok.

> dwindling into irrelevance Scala won't be the next Java. However, _some_ Scala-like language will be the next Scala, probably EPFL Dotty [0] or Twitter Reasonable Scala [1] Short term, also Lightbend Scala is evolving (collections redesign [2], macros EOL [3]) Just upgrading existing Scala projects will keep most Scala devs employed. [0] https://github.com/lampepfl/dotty [1] https://github.com/twitter/rsc [2] https://news.ycombinator.com/item?id=16461022 [3] https://news.ycombinator.com/item?id=16519366

And Scala (via Dotty) is being re-worked to have sum types with a cleaner "enum" syntax soon too: https://github.com/lampepfl/dotty/issues/1970 (merged)

I wrote a zero-allocation `Option`-style (monadic) data structure for Scala a while ago [1]. Unlike all the previous attempts, it supports the distinction between `None`, `Some(None)`, `Some(null)`, `Some(Some(None))`, etc., which is what allows it to remain monadic. The surprise is that it does not use `null` as the `None` value. The downside is that `toString()` is altered: `Some("hello").toString()` returns `hello`, not `Some(hello)`. There was an experiment to use it as a replacement for the implementation of `scala.Option` in the dotty compiler code base [2], but it is inconclusive so far; it should be tried directly in the collections library. [1] https://github.com/sjrd/scala-unboxed-option [2] https://github.com/lampepfl/dotty/pull/3181