Scala 2.13 error: overloaded method w with alternatives

I migrate some code to scala 2.13 from 2.12 and I have the following code

def w(value : java.util.Map[String, java.util.List[String]]) : ParamPair[Map[String, (String, String)]] = {
    val scalaMap = value.asScala.toMap

    val newMap = scalaMap.mapValues[(String, String)]( (l : java.util.List[String]) => {
      if(l.size() != 2)
        throw new IllegalArgumentException("A tuple map should contain exactly 2 elements ")
      val lScala = l.asScala.toArray
      (lScala(0), lScala(1))
    })

    w(newMap)
  }

that at the last line i get the error

 error: overloaded method w with alternatives:
[ERROR]   (value: java.util.Map[String,java.util.List[String]])org.apache.spark.ml.param.ParamPair[Map[String,(String, String)]] <and>
[ERROR]   (value: Map[String,(String, String)])org.apache.spark.ml.param.ParamPair[Map[String,(String, String)]]
[ERROR]  cannot be applied to (scala.collection.MapView[String,(String, String)])
[ERROR]     w(newMap)
[ERROR]     ^

can you explain what is the problem?

There were some breaking changes for collections introduced in scala 2.13. Here you have the migration guide for collections in scala 2.13

> #### What are the breaking changes?
>
> - collection.JavaConversions. Use scala.jdk.CollectionConverters instead. Previous advice was to use collection.JavaConverters which is now deprecated
>
> | Description | Old Code | New Code | Automatic Migration Rule |
> |-------------|----------|----------|--------------------------|
> | mapValues and filterKeys now return a MapView instead of a Map| kvs.mapValues(f) | kvs.mapValues(f).toMap | RoughlyMapValues |

First you have to replace the import for the collection converters. Then, you have the following old code

   val newMap = scalaMap.mapValues[(String, String)]( (l : java.util.List[String]) => {
      if(l.size() != 2)
        throw new IllegalArgumentException("A tuple map should contain exactly 2 elements ")
      val lScala = l.asScala.toArray
      (lScala(0), lScala(1))
    })

In scala 2.12, Map.mapValues returns a Map.

> scala
> def mapValues[W](f: (V) ⇒ W): Map[K, W]
>
> Transforms this map by applying a function to every retrieved value.

Scala 2.13 Map.mapValues returns a MapView.

> scala
> def mapValues[W](f: (V) => W): MapView[K, W]
>
> Transforms this map by applying a function to every retrieved value.
> Deprecated (Since version 2.13.0) Use .view.mapValues(f). A future version will include a strict version of this method (for now, .view.mapValues(f).toMap).

This means that the signature of the method have been changed and also the method is deprecated. As it is detailed in the migration guide and in the scaladoc of the method, you should use map.view.mapValues(transformation).toMap. In your code should be something like

   val newMap = scalaMap.view.mapValues[(String, String)]( (l : java.util.List[String]) => {
      if(l.size() != 2)
        throw new IllegalArgumentException("A tuple map should contain exactly 2 elements ")
      val lScala = l.asScala.toArray
      (lScala(0), lScala(1))
    }).toMap

The last line (lScala(0), lScala(1)) is a Tuple2[String,String], making newMap of type Map[String, (String, String)]. In the next line you are calling w function which expects a java.util.Map[String, java.util.List[String]]. Doing newMap.asJava will return a util.Map[String, (String, String)].

You have the Views for further reading

> Collections have quite a few methods that construct new collections. Examples are map, filter or ++. We call such methods transformers because they take at least one collection as their receiver object and produce another collection as their result.
>
> There are two principal ways to implement transformers. One is strict, that is a new collection with all its elements is constructed as a result of the transformer. The other is non-strict or lazy, that is one constructs only a proxy for the result collection, and its elements get constructed only as one demands them.