Announcing Dotty 0.23.0-RC1

We are excited to announce the 0.23.0-RC1 version of Dotty. This version brings safe initialization checks, minor syntactic changes related to the context parameters, type-level bitwise operations and more.

You can read more about the changes this version brings in the blog article:

Notable Changes



Change to (using x: T) => E for context functions #8305
Drop given parameter syntax #8270
Fix #8256: Disallow silent indent for template bodies #8264


Add bitwise Int compiletime operations #8377
Safe initialization for Scala #7789


Add scala.compiletime.summonInline #8483
Move Unliftable extractors in Unlifted #8517
Rename ValueOfExpr to Unliftable #8503
Refactor scala.quoted.matching #8479
Simplify import of qctx.tasty.rootContext #8438


Thank you to all the contributors who made this release possible :tada:

According to git shortlog -sn --no-merges 0.22.0-RC1..0.23.0-RC1 these are:

   165  Martin Odersky
   124  Nicolas Stucki
   121  Liu Fengyun
    45  Robert Stoll
    15  Guillaume Martres
    15  Anatolii
    10  gzoller
     8  Som Snytt
     8  Stéphane Micheloud
     5  Ausmarton Zarino Fernandes
     5  Oron Port
     3  Adam Fraser
     3  Gabriele Petronella
     3  Uko
     3  Anatolii Kmetiuk
     2  ybasket
     2  Dale Wijnand
     2  Dani Rey
     2  Jamie Thompson
     2  Olivier Blanvillain
     2  Tomasz Godzik
     2  Travis Brown
     2  Vlastimil Dort
     1  tanaka takaya
     1  Miles Sabin
     1  Andrew Valencik
     1  bishabosha
     1  fhackett
     1  Lionel Parreaux
     1  kenji yoshida
     1  manojo
     1  odersky
     1  Raj Parekh
     1  Sébastien Doeraene
     1  xuwei-k

Reporting Bugs

If you encounter a bug, please open an issue! :pray:

1 Like

(using ctx: Ctx) => ???

There was a quesiton on github regarding whether

(using Ctx) => ???

should work. @odersky replied to that saying it would be preferable to “have one way todo [sic] things”. Doesn’t this introduce an unnecessary difference between language features that are essentially the same (well, a very similar) thing?

I find methods, functions, lambdas essentially the same and I’d expect to be able to do the same things with them. Not saying there can’t be differences when justified, but this one I find arbitrary and unintuitive, and one that would surely frustrate me if I stumbled upon it while learning hands-on. Or now, for that matter :slight_smile:

Methods allow for anonymous givens, I find that to allow them here too reduces complexity in that similar language features would remain (more) similar, if this would be allowed here too.

What are the drawbacks? In a certain way I’d find this closer to the wish to “have one way todo [sic] things”

1 Like

Do we still call given arguments given arguments then? using's fine in code, just wondering what it should be in speech.

I propose: Context parameters and context arguments.


I like the “context foo” naming convention.

They’re already called “context bounds” in one use case, and the other non-context-bound use case where we’re passing around implicit execution contexts or implicit request context, people call them contexts as well.

In fact, I think “context” sounds better than “given”, but that horse seems well and thoroughly dead :stuck_out_tongue:

1 Like

Hmm… do we actually need both using and summon? We could simplify one of them away, one less thing to remember. They do pretty much the same thing after all.