After upgrading to Scala 3.2, I get warnings like this one:
warn] -- Warning: /home/informarte/Workspaces/yuck/src/main/yuck/flatzinc/compiler/NeighbourhoodFactory.scala:78:30
[warn] 78 | (for ((objective, Some(neighbourhood)) <- buf) yield (objective, neighbourhood)).unzip
[warn] | ^^^^^^^^^^^^^^^^^^^
[warn] |pattern's type Some[yuck.core.Neighbourhood] is more specialized than the right hand side expression's type Option[yuck.core.Neighbourhood]
[warn] |
[warn] |If the narrowing is intentional, this can be communicated by adding the `case` keyword before the full pattern,
[warn] |which will result in a filtering for expression (using `withFilter`).
[warn] |This patch can be rewritten automatically under -rewrite -source 3.2-migration.
I don’t understand this warning.
The line is intended to loop those pairs where the second value is defined. It has always worked, it still works according to the unit test results, and the behavior is as described in the Scala book which states that
for (pat <- expr 1 ) yield expr 2
translates to
expr 1 filter {
case pat => true
case _ => false
} map {
case pat => expr 2
}
This version is a bug-fixing release focusing mainly but not exclusively on solving rare issues with code not compiling after upgrading the language version to 3.2.0.
This change is described on this page. The plan seems to be to disable filtering for comprehensions without case in 3.3, so in 3.2 you only get the warning and the chance to migrate.
The code you gave with casedoes compile for me, so I’m not sure what the problem is there.
It doesn’t really seem to be explained on the doc page, but I think the reason for this change is that in the future you should be able to use destructuring expressions in for comprehensions without withFilter as long as they can’t fail.
val list = List(1 -> 2, 2 -> 3, 3 -> 4)
for (a, b) <- list yield a + b
// in scala <=3.2:
list.withFilter {
case (a, b) => true
case _ => false
}
.map{ case (a, b) => a + b }
// in scala >=3.3:
list.map{ case (a, b) => a + b }
Context that may not be obvious to folks who haven’t been bitten by this: this sort of filtering is a common source of mystifying bugs, with data being silently thrown away by accident.
I assume that that’s the reason for this change – it tells you if you’re potentially going to do something dangerous, and requires you to make explicit that you intend to do that.
Two things tnat I find confusing: First, the warning itself:
It sounds like there will no filtering without case. While this seems to be the intended behavior for future Scala versions, Scala 3.2.1 filters even without case.
Second, the documentation of pattern bindings does not talk about the way forward. Will it be possible to destructure expressions in for comprehensions even when they could fail? (That would actually be a new and very useful feature.) If yes, would there be a warning? And if so, would there be a way to suppress it, say with @unchecked?
It seems that, in some contexts, the Scala plugin of IDEA has a problem with case in for comprehensions (resulting in wrong highlighting) although the code compiles.
It seems that mill does not restart its compilation server upon change of the Scala version. (The next day, after restarting my computer, the command-line build worked.)