Type inference issue with generic method

[gaeljw]

Using Scala version 3.0.0-M1

Minimized code

def nullToNone[K, V](tuple: (K, V)): (K, Option[V]) = {                                                                                                                                                                                
    val (k, v) = tuple
    (k, Option(v))
}

val scalaMap: Map[String, String] = Map()

val m2: Map[String, Option[String]] = scalaMap.map(nullToNone).toMap

// For troubleshooting, does not work in Scala 2.x neither
val m3: Map[String, Option[String]] = scalaMap.map(nullToNone)

Output

1 |val m2: Map[String, Option[String]] = scalaMap.map(nullToNone).toMap
  |                                                                    ^
  |         Cannot prove that (Any, Option[Any]) <:< (String, V2)
  |
  |         where:    V2 is a type variable with constraint <: Option[String]
  |         .

1 |val m3: Map[String, Option[String]] = scalaMap.map(nullToNone)
  |                                                   ^^^^^^^^^^
  |                  Found:    ((Any, Any)) => (Any, Option[Any])
  |                  Required: ((String, String)) => (String, Option[String])

Expectation

I'm quite new to Scala 3 but there shouldn't be any need for more explicit types, isn't it?

val m2 should compile without error.

Notes

This is actually part of existing code: https://github.com/cucumber/cucumber-jvm-scala/blob/main/cucumber-scala/src/main/scala/io/cucumber/scala/Implicits.scala#L35

[smarter]

This is likely because map is overloaded in various collection types like Map since 2.13, so infering the types of the lambda arguments gets harder, there were quite a few tweaks to inference in 2.13 to make this sort of things work, in particular scala/scala#6871 is probably relevant here.

[smarter]

It does work when eta-expanding by hand:

val scalaMap: Map[String, String] = Map()
val z = scalaMap.map(nullToNone(_))

[gaeljw]

Thanks for the quick feedback @smarter. I'll go with the eta-expanding for now then.