Can Scala class implement Java interface with automatic type conversion

This Java interface is defined in a library:

public interface Interface<T> {
  List<T> makeList();
}

I'd like to have a Scala class that implements it, but returns a Scala list instead of java.util.List. This is the best I could think of but it's not working:

import scala.jdk.CollectionConverters._
class Implementation[T] extends Interface[T] {
  implicit def s2j[V](list: List[V]): java.util.List[V] = list.asJava // This doesn't seem to do anything
  override def makeList(): List[T] = ???
}

error overriding method makeList in trait Interface of type (): java.util.List[T]; method makeList of type (): List[T] has incompatible type. Clearly, I can make each user of Implementation do its own conversion, but I was hoping for something neater.

EDIT: From the responses, it appears that this is not possible.

You can create a "proxy layer" with an abstract class:

import scala.jdk.CollectionConverters._

abstract class ScalaInterface[T] extends Interface[T] {
  def makeScalaList(): List[T]
  override def makeList(): java.util.List[T] = makeScalaList().asJava
}

class Implementation[T] extends ScalaInterface[T] {
  override def makeScalaList(): List[T] = ???
}

Instead of implementing Interface, you implement ScalaInterface.

You don't need an implicit conversion to do this. In fact implicit conversions are generally regarded as a bad thing now.

Just create your Scala list and convert it explicitly when required by the interface.

import scala.jdk.CollectionConverters._
class Implementation[T] extends Interface[T] {
  def makeScalaList(): List[T]
  override def makeList(): java.util.List[T] = makeScalaList().asJava
}

@Igor asked:

> Thanks. I understand I can do that. The point is to make it seemless to the users of the Scala implementation, yet make the scala implementation work where the java type Interface is expected.

This will not wont work automatically. To understand Java/Scala interop (and binary compatibility) it is important to understand how Scala maps syntactic sugar like implicit conversions or named parameters to jvm bytecode. The jvm is designed to run Java so lacks these Scala concepts. To get around this Scala injects code at the call site not the definition site.

When you write the following Scala.

implicit def s2j[V](list: List[V]): java.util.List[V] = list.asJava
val list: List[String] = ...
val javaSubList = list.subList(0, 3)

The Scala compiler notices that subList is not a member of scala.collection.List. Then it looks for conversions to convert it to a type where the method is defined then chains to two method calls together at the call site. The Java would look like:

public <V> java.util.List<V> s2j(list: scala.collection.List[V]) {
    new scala.jdk.CollectionConverter.SeqHasJava(list).asJava()
}

scala.collection.List<String> list = ...
java.util.List<String> javaSubList = s2j(list).subList(0, 3)

So while it feels like implicit conversions are adding extra functionality to a type, really the compiler is inserting code every time the caller requires it. Since Java and the JVM do not support these features, the only way this would work is if the Scala compiler injected the code into the definition site. Since it does not you must create the code in the definition site yourself which is what the proxy/bridge in @Gaël's answer does.

If you look closely you will see that all it does is put half of my code into an abstract class to separate the interop code from the Scala code.