Cannot do a map on a Map with Scala 3, with Scala 2.13 it works ok

[DavidPerezIngeniero]

Compiler version

• Java 21
• Scala 3.3.3 (and 3.4.2)

Minimized code

This interactive scala-cli session shows the problem:

❯ scala-cli -j system --dep org.python:jython-standalone:2.7.1b3 -S 3.3.3
Welcome to Scala 3.3.3 (21.0.3, Java OpenJDK 64-Bit Server VM).
Type in expressions for evaluation. Or try :help.

cala> import org.python.core.*
                                                                                                                                          
scala> import scala.jdk.CollectionConverters.*
                                                                                                                                          
scala> val p = new PyDictionary
val p: org.python.core.PyDictionary = {}

scala> p.asScala
-- [E008] Not Found Error: -----------------------------------------------------
1 |p.asScala
  |^^^^^^^^^
  |value asScala is not a member of org.python.core.PyDictionary
1 error found

cala> (p: java.util.Map[?, ?]).asScala
val res0: scala.collection.mutable.Map[?, ?] = Map()
                                                                                                                                          
scala> (p: java.util.Map[Any, Any]).asScala.map { case (k,v) => (k, v) }
-- [E007] Type Mismatch Error: -------------------------------------------------
1 |(p: java.util.Map[Any, Any]).asScala.map { case (k,v) => (k, v) }
  | ^
  | Found:    (p : org.python.core.PyDictionary)
  | Required: java.util.Map[Any, Any]
  |
  | longer explanation available when compiling with `-explain`
1 error found

Comparison with Scala 2.13.14:

 scala-cli -j system --dep org.python:jython-standalone:2.7.1b3 -S 2.13.14
Welcome to Scala 2.13.14 (OpenJDK 64-Bit Server VM, Java 21.0.3).
Type in expressions for evaluation. Or try :help.

scala> import org.python.core._
import org.python.core._

scala> import scala.jdk.CollectionConverters._
import scala.jdk.CollectionConverters._

scala> val p = new PyDictionary
val p: org.python.core.PyDictionary = {}

scala> p.asScala
val res0: scala.collection.concurrent.Map[_, _] = Map()

scala> p.asScala.map{case(k,v) => (k,v) }
val res1: scala.collection.mutable.Map[Object,Object] = HashMap()

Output

Error compiles

Expectation

Code does compile o error message can be unsderstood.
With Scala 2.13.14 it compiles.

In addition, with Scala 2.13 I don't need a type adscription to Map.

Notes:

PyDictionary is defined like this:

public class PyDictionary extends AbstractDict implements ConcurrentMap, Traverseproc {
   ...
}

public interface ConcurrentMap<K,V> extends Map<K,V> {
   ...
}

[DavidPerezIngeniero]

A workaorund is to define an intermediate variable:

val p2 = (p: Map[?, ?]).asScala
p2.map { case (k, v) => (k, v) }

I consider a bug to behave differently just for defining an intermediate variable.

[SethTisue]

A consider a bug to behave differently just for defining an intermediate variable

That's an incorrect expectation, at least in general. It can perhaps be defended in specific cases, but it has to specifically defended, you can't just point at the general principle and be done, since the general principle does not exist. Type inference in Scala 3 processes entire expressions. It's normal that the overall result might be different if you first give the type checker only part of the expression to work with, forcing it to decide on an answer based on partial information, and then only later give it the rest.

[SethTisue]

Is the issue reproducible without involving an external dependency...?

[DavidPerezIngeniero]

Is the issue reproducible without involving an external dependency...?

I don't know, but the code I've shown it is quite simple and minimalistic.

[DavidPerezIngeniero]

A consider a bug to behave differently just for defining an intermediate variable

That's an incorrect expectation, at least in general. It can perhaps be defended in specific cases, but it has to specifically defended, you can't just point at the general principle and be done, since the general principle does not exist. Type inference in Scala 3 processes entire expressions. It's normal that the overall result might be different if you first give the type checker only part of the expression to work with, forcing it to decide on an answer based on partial information, and then only later give it the rest.

At least I don´t expect different results if I split an expression using an intermediate variable.

[SethTisue]

I don't know, but the code I've shown it is quite simple and minimalistic.

Regardless, reproducing a bug without an external dependency is considered the standard for bug reporting in this repository, for two main reasons:

1. It's what we need in order to turn the report into a test case that can be added to our test suite

(but perhaps even more importantly:)

2. it often gives considerable additional insight into the nature of the problem (including insight into whether the problem is in fact a bug in Scala itself, or somehow the external dependency's fault)