CollectionConverters conflicts with FunctionConverters for Seq's

[joshlemer]

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

scala> import scala.jdk.FunctionConverters.Ops._
import scala.jdk.FunctionConverters.Ops._

scala> List(1,2,3).asJava
           ^
       error: type mismatch;
        found   : List[Int]
        required: ?{def asJava: ?}
       Note that implicit conversions are not applicable because they are ambiguous:
        both method SeqHasAsJava in trait AsJavaExtensions of type [A](s: scala.collection.Seq[A])jdk.CollectionConverters.Ops.SeqHasAsJava[A]
        and method enrichAsJavaIntUnaryOperator in trait Priority0FunctionExtensions of type [A0](sf: A0 => Int)(implicit evA0: A0 =:= Int)scala.jdk.FunctionWrappers.RichFunction1AsIntUnaryOperator
        are possible conversion functions from List[Int] to ?{def asJava: ?}
                   ^
       error: value asJava is not a member of List[Int]

[lrytz]

I don't have a good idea how to get around this... I don't see how we could make the collections asJava higher priority, as the two conversions are defined in separate objects.

If we had a combined scala.jdk.Converters for everything we could define priorities. It would get a little complex to think of all the combinations though.

So my recommendation would be to scope the imports, or use the explicit conversion methods when hitting an ambiguity.

[dwijnand]

Perhaps the same setup that simulacrum uses to for extension methods of Semigroup/Monoid could work for Int => A/List[A]? https://github.com/mpilquist/simulacrum/blob/master/README.md

[mslinn]

This is a serious Java/Scala interop problem. Here is how to create the bug:

import scala.jdk.CollectionConverters._
import scala.jdk.FunctionConverters._

List(1, 2, 3).asJava

Error:(62, 7) type mismatch;
 found   : List[Int]
 required: ?{def asJava: ?}
Note that implicit conversions are not applicable because they are ambiguous:
 both method SeqHasAsJava in trait AsJavaExtensions of type [A](s: scala.collection.Seq[A])jdk.CollectionConverters.SeqHasAsJava[A]
 and method enrichAsJavaIntUnaryOperator in trait Priority0FunctionExtensions of type [A0](sf: A0 => Int)(implicit evA0: A0 =:= Int)scala.jdk.FunctionWrappers.RichFunction1AsIntUnaryOperator
 are possible conversion functions from List[Int] to ?{def asJava: ?}
  List(1, 2, 3).asJava

This bug manifests when attempting to create a Java interface for a Scala library, because both a Scala function and Scala data types need to be converted to Java, which means both imports are required. For example:

import java.util.{function, List => JList}
import scala.collection._
import scala.jdk.CollectionConverters._
import scala.jdk.FunctionConverters._

val intoEvenOdd: JList[Int] => (JList[Int], JList[Int]) = { javaList: JList[Int] =>
  javaList.asScala.partition(_ % 2 == 0) match {
    case (even: mutable.Buffer[Int], odd: mutable.Buffer[Int]) => (even.asJava, odd.asJava)
  }
}.asJava

Error:(66, 72) type mismatch;
 found   : even.type (with underlying type scala.collection.mutable.Buffer[Int])
 required: ?{def asJava: ?}
Note that implicit conversions are not applicable because they are ambiguous:
 both method BufferHasAsJava in trait AsJavaExtensions of type [A](b: scala.collection.mutable.Buffer[A])jdk.CollectionConverters.BufferHasAsJava[A]
 and method enrichAsJavaIntUnaryOperator in trait Priority0FunctionExtensions of type [A0](sf: A0 => Int)(implicit evA0: A0 =:= Int)scala.jdk.FunctionWrappers.RichFunction1AsIntUnaryOperator
 are possible conversion functions from even.type to ?{def asJava: ?}
        case (even: mutable.Buffer[Int], odd: mutable.Buffer[Int]) => (even.asJava, odd.asJava)
Error:(66, 77) value asJava is not a member of scala.collection.mutable.Buffer[Int]
        case (even: mutable.Buffer[Int], odd: mutable.Buffer[Int]) => (even.asJava, odd.asJava)
Error:(66, 85) type mismatch;
 found   : odd.type (with underlying type scala.collection.mutable.Buffer[Int])
 required: ?{def asJava: ?}
Note that implicit conversions are not applicable because they are ambiguous:
 both method BufferHasAsJava in trait AsJavaExtensions of type [A](b: scala.collection.mutable.Buffer[A])jdk.CollectionConverters.BufferHasAsJava[A]
 and method enrichAsJavaIntUnaryOperator in trait Priority0FunctionExtensions of type [A0](sf: A0 => Int)(implicit evA0: A0 =:= Int)scala.jdk.FunctionWrappers.RichFunction1AsIntUnaryOperator
 are possible conversion functions from odd.type to ?{def asJava: ?}
        case (even: mutable.Buffer[Int], odd: mutable.Buffer[Int]) => (even.asJava, odd.asJava)
Error:(66, 89) value asJava is not a member of scala.collection.mutable.Buffer[Int]
        case (even: mutable.Buffer[Int], odd: mutable.Buffer[Int]) => (even.asJava, odd.asJava)
Error:(64, 84) type mismatch;
 found   : java.util.List[Int] => <error>
 required: ?{def asJava: ?}
Note that implicit conversions are not applicable because they are ambiguous:
 both method enrichAsJavaConsumer in trait Priority1FunctionExtensions of type [T](sf: T => Unit)scala.jdk.FunctionWrappers.RichFunction1AsConsumer[T]
 and method enrichAsJavaPredicate in trait Priority1FunctionExtensions of type [T](sf: T => Boolean)scala.jdk.FunctionWrappers.RichFunction1AsPredicate[T]
 are possible conversion functions from java.util.List[Int] => <error> to ?{def asJava: ?}
  val intoEvenOdd: JList[Int] => (JList[Int], JList[Int]) = { javaList: JList[Int] =>

I am able to make things work by restricting the scope of the imports, but this requires splitting the implementation up or writing horrible code to restrict import scope:

import java.util.{function, List => JList}
import scala.collection._

val intoEvenOdd: JList[Int] => (JList[Int], JList[Int]) = {
  import scala.jdk.CollectionConverters._
  javaList: JList[Int] =>
    javaList.asScala.partition(_ % 2 == 0) match {
      case (even: mutable.Buffer[Int], odd: mutable.Buffer[Int]) =>
        (even.asJava, odd.asJava)
    }
}

val intoEvenOddForJava: function.Function[JList[Int], (JList[Int], JList[Int])] = {
  import scala.jdk.FunctionConverters._
  intoEvenOdd.asJava
}

Is there a better workaround?

[lrytz]

It would work if the expected type was taken into account.

scala> implicit class si(s: String) { def x = 0 }
defined class si

scala> implicit class sl(s: String) { def x = List(0) }
defined class sl

scala> "".x : Int
       ^
       error: type mismatch;
        found   : String("")
        required: ?{def x: ?}
       Note that implicit conversions are not applicable because they are ambiguous:
        both method si of type (s: String)si
        and method sl of type (s: String)sl
        are possible conversion functions from String("") to ?{def x: ?}
          ^
       error: value x is not a member of String

Note that the compiler is looking for a method def x: ?. Maybe we can narrow that down to searching for a conversion that gives a def x: Int.

[mslinn]

@lrytz Do you mean this:

scala> val x: java.util.List[Int] = List(1, 2, 3).asJava

       error: type mismatch;
        found   : List[Int]
        required: ?{def asJava: ?}
       Note that implicit conversions are not applicable because they are ambiguous:
        both method SeqHasAsJava in trait AsJavaExtensions of type [A](s: scala.collection.Seq[A])jdk.CollectionConverters.SeqHasAsJava[A]
        and method enrichAsJavaIntUnaryOperator in trait Priority0FunctionExtensions of type [A0](sf: A0 => Int)(implicit evA0: A0 =:= Int)scala.jdk.FunctionWrappers.RichFunction1AsIntUnaryOperator
        are possible conversion functions from List[Int] to ?{def asJava: ?}
                                                  ^
       error: value asJava is not a member of List[Int]

I also tried this:

scala> val x: java.util.List[java.lang.Integer] = List(1, 2, 3).asJava

       error: type mismatch;
        found   : List[Int]
        required: ?{def asJava: ?}
       Note that implicit conversions are not applicable because they are ambiguous:
        both method SeqHasAsJava in trait AsJavaExtensions of type [A](s: scala.collection.Seq[A])jdk.CollectionConverters.SeqHasAsJava[A]
        and method enrichAsJavaIntUnaryOperator in trait Priority0FunctionExtensions of type [A0](sf: A0 => Int)(implicit evA0: A0 =:= Int)scala.jdk.FunctionWrappers.RichFunction1AsIntUnaryOperator
        are possible conversion functions from List[Int] to ?{def asJava: ?}
                                                                ^
       error: value asJava is not a member of List[Int]

You also said "use the explicit conversion methods when hitting an ambiguity". Which of those might be applicable here?