Returning typed collection from Scala 2.13 method to Java 8 caller

Mike Slinn :

I want to return java.util.List<Integer>s to the Java 8 code below instead of the java.util.List<Object>s that are returned from the following Scala 2.13.0 code. Both the Java and the Scala code could be modified to suit. I don't want to force any type conversions, for example no (java.util.List<Integer>) or .asInstanceOf[java.util.List[Int]] casts.

collections.FunctionConverterFromJava.scala

trait FunctionConverterFromScala {
  import java.util.{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)
    }
  }
}

object FunctionConverterFromJava extends FunctionConverterFromScala {
  import java.util.{function, List => JList}

  def reverse(string: String): String = string.reverse

  def zipChars(string: String): IndexedSeq[(Char, Int)] = string.zipWithIndex

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

object FunctionConverterFun extends App with FunctionConverterFromScala {
  val jList: java.util.List[Int] = {
    import scala.jdk.CollectionConverters._
    (1 to 10).asJava
  }
  println(intoEvenOdd(jList))
}

Java program

import collections.FunctionConverterFromJava$;
import scala.Tuple2;
import scala.collection.immutable.IndexedSeq;
import java.util.Arrays;
import java.util.List;

public class FunctionConverterFun {
    public static void main(String[] args) {
        String string = "Hello!";
        String reversed = FunctionConverterFromJava$.MODULE$.reverse(string);
        System.out.println("reversed = " + reversed);

        IndexedSeq<Tuple2<Object, Object>> zippedChars = FunctionConverterFromJava$.MODULE$.zipChars(string);
        System.out.println("zippedChars = " + zippedChars);

        List<Object> list1 = Arrays.asList(1, 2);
        Tuple2<List<Object>, List<Object>> list2 = FunctionConverterFromJava$.MODULE$.intoEvenOddForJava().apply(list1);
        System.out.println("list2 = " + list2);

        java.util.function.Function<List<Object>, Tuple2<List<Object>, List<Object>>> f = FunctionConverterFromJava$.MODULE$.intoEvenOddForJava();
        Tuple2<List<Object>, List<Object>> list3 = f.apply(list1);
        System.out.println("list3 = " + list3);
    }
}

Mario Galic :

The issue is type erasure turns java.util.List[scala.Int] into java.util.List<java.lang.Object>. For example, javap output for intoEvenOddForJava is

public scala.Function1<java.util.List<java.lang.Object>, scala.Tuple2<java.util.List<java.lang.Object>, java.util.List<java.lang.Object>>> intoEvenOddForJava();

However, if we were to change from scala.Int to java.lang.Integer like so

object FunctionConverterFromJava extends FunctionConverterFromScala {
  ...
  val intoEvenOddForJava: function.Function[JList[java.lang.Integer], (JList[java.lang.Integer], JList[java.lang.Integer])] = {
    intoEvenOdd.asJava.asInstanceOf[function.Function[JList[java.lang.Integer], (JList[java.lang.Integer], JList[java.lang.Integer])]]
  }
}

then we avoid type erasure according to javap output

public java.util.function.Function<java.util.List<java.lang.Integer>, scala.Tuple2<java.util.List<java.lang.Integer>, java.util.List<java.lang.Integer>>> intoEvenOddForJava();

Now from Java we can call as required

java.util.function.Function<List<Integer>, Tuple2<List<Integer>, List<Integer>>> f = FunctionConverterFromJava$.MODULE$.intoEvenOddForJava();
Tuple2<List<Integer>, List<Integer>> list3 = f.apply(list1);
System.out.println("list3 = " + list3);

which outputs

list3 = ([2],[1])

Now I understand that you wish to avoid asInstanceOf, however notice it would be hidden in the library FunctionConverterFromJava, that is, call-site would be clear of asInstanceOf. If you still wish to avoid asInstanceOf completely, then consider adding the following to FunctionConverterFromScala

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

and then call intoEvenOddAsJava.asJava in FunctionConverterFromJava.intoEvenOddForJava.

That asInstanceOf hidden in library might be acceptable because

...the underlying representation of Int is Integer you can cast directly to java.util.List[java.lang.Integer]

---

Addressing the comment, Eugene's answer explains

...how does it know about Integer (via that checkcast) if generics are erased? The answer is the optional Signature that is generated when A is compiled, or in your cases:

()Lscala/collection/immutable/List<Ljava/lang/Object;>; //fooInt ()Lscala/collection/immutable/List<Ljava/lang/Integer;>; // fooInteger

This Signature information is what is used by the compiler to enforce type safety at callsites, via runtime checks; if this field would not be present - that would have been impossible.