¿Cómo influirá el nuevo desarrollo de Java en su interoperabilidad con lenguajes como Scala y Clojure?

Por lo que yo entiendo, tanto Scala como Clojure han sido diseñados como nuevos lenguajes que

1. dependerá de la JVM, y
2. se integran fácilmente con el código Java, en el sentido de que permiten usar clases Java dentro del código Scala y Clojure.

Comenzando con Java 8 (y tal vez aún más fuerte con versiones posteriores de Java), habrá cambios en la semántica del lenguaje Java.

Quería preguntar cómo estos cambios afectarán la interoperabilidad entre Java y Scala / Clojure y cuáles serán las consecuencias. Por ejemplo, dado que las lambdas en Java 8 no son objetos (ver, por ejemplo, aquí ), Scala y Clojure podrían tener que lidiar con valores de Java que no son objetos. ¿Sería esto un problema?

Puedo pensar en los siguientes escenarios:

1. El lenguaje Scala o Clojure se extenderá para adaptarse a la nueva semántica de Java (para manejar los nuevos valores no objeto) y admitir la interoperabilidad con Java.
2. El lenguaje Scala o Clojure no se extenderá. Esto solo sería posible si las nuevas características de Java, como los valores de función, pueden asignarse a conceptos existentes. Por ejemplo, en Scala, incluso una función es un objeto, así que supongo que las funciones de Java volverían a estar envueltas en algún tipo de objetos cuando sean visibles para Scala.
3. El lenguaje Scala o Clojure continuará admitiendo la interoperabilidad hasta Java 6 o 7, sin seguir el último desarrollo de Java. Esto requeriría que las versiones anteriores de Java aún sean compatibles (al menos con OpenJDK u otro proyecto), de modo que estos lenguajes puedan basarse en una rama más conservadora / estable de Java.

Resumiendo: ¿podemos esperar que el desarrollo futuro de Java tenga un impacto en lenguajes como Scala y Clojure para mantener la interoperabilidad con Java? ¿Hay alguna (enlace a) discusión en curso sobre este tema?

Nota

Me imagino que Scala, Clojure y otros lenguajes basados ​​en JVM no tendrán problemas importantes para actualizar su implementación a versiones más recientes de JVM (y que las nuevas características de JVM harán que esta implementación sea aún más fácil). Mi pregunta se centra en las características de Java como lenguaje y si / cómo otro lenguaje JVM podrá "ver" / usar estas nuevas características, no si los lenguajes basados ​​en JVM se ejecutarán en los últimos JVM.

En realidad, Java 8 no introduce mucho que vaya en detrimento de otros lenguajes JVM que interaccionan con Java. El trabajo realizado en Lambdas ayudó a solucionar una serie de pequeños problemas relacionados con invocados dinámicos, MethodHandles, MethodReferences, etc., pero aparte de eso, continúa de manera normal. Dicho esto, hay un nuevo grupo de API que los otros lenguajes de JVM podrían llamar ahora. Los que usarán por defecto o no dependerán de ellos.

El cambio más grande que afecta la interoperabilidad en realidad se produjo con Java 7, con el código de byte dinámico invocado que permite llamadas de enlace dinámico / tardío dentro de la JVM, algo que inicialmente se diseñó para los otros idiomas en la JVM. Desde entonces, se ha adaptado muy útilmente para Lamdbas, por lo que a partir de Java 8, Java comenzará a emitir estos códigos de bytes.

Algunos lenguajes (JRuby, por ejemplo) ya utilizan mucho la invocabilidad dinámica, mientras que otros (Scala, Groovy et al.) Todavía están investigando su uso o están en las primeras etapas de su aplicación. En teoría, hace que sus llamadas dinámicas sean casi tan efectivas como las existentes. Llamadas invocaticas de Java, a diferencia de la miríada de soluciones lentas que se vieron obligadas a usar en el pasado.

Java 9 traerá más desafíos para los lenguajes JVM con el proyecto Jigsaw que entrará en la plataforma, que será el principio del fin para la carga de clases y los classpaths tradicionalmente para JVM. La gente del lenguaje JVM es muy consciente de esto y espero que tenga lugar una colaboración sensata.

Scala está a punto de quedarse atrás cuando Java agrega lambdas porque a las lambdas de Java se les asigna un tipo de acuerdo con el contexto en el que se usan, mientras que a las lambdas de Scala se les asigna un tipo en función de sus aridades, tipos de parámetros y tipos de retorno, por ejemplo,

executor.execute(() -> { System.out.println("hello world"); });

de Java 8 se puede escribir en Scala como:

executor execute new Runnable {
    override def run() { println("hello world") }
}

a menos que use / escriba algunos contenedores que conviertan Scala's () => Unit a Runnable.