Como o novo desenvolvimento do Java influenciará sua interoperabilidade com linguagens como Scala e Clojure?

Tanto quanto eu entendo, Scala e Clojure foram projetados como novos idiomas que

1. dependem da JVM e
2. integram-se facilmente ao código Java, no sentido em que permitem o uso de classes Java no código Scala e Clojure.

Começando com o Java 8 (e talvez ainda mais fortemente com as versões subseqüentes do Java), haverá mudanças na semântica da linguagem Java.

Eu queria perguntar como essas mudanças afetarão a interoperabilidade entre Java e Scala / Clojure e quais serão as consequências. Por exemplo, como os lambdas no Java 8 não são objetos (veja, por exemplo, aqui ), Scala e Clojure podem precisar lidar com valores Java que não são objetos. Isso seria um problema?

Eu posso pensar nos seguintes cenários:

1. A linguagem Scala ou Clojure será estendida para se adaptar à nova semântica Java (para manipular os novos valores não-objeto) e oferecer suporte à interoperabilidade com Java.
2. O idioma Scala ou Clojure não será estendido. Isso só seria possível se os novos recursos Java, como valores de função, pudessem ser mapeados para conceitos existentes. Por exemplo, no Scala, mesmo uma função é um objeto, então acho que as funções Java seriam novamente envolvidas em algum tipo de objeto quando elas se tornassem visíveis ao Scala.
3. A linguagem Scala ou Clojure continuará a suportar interoperabilidade até Java 6 ou 7, sem seguir o desenvolvimento mais recente do Java. Isso exigiria que versões mais antigas do Java ainda sejam suportadas (pelo menos pelo OpenJDK ou outro projeto), para que essas linguagens possam se basear em um ramo mais conservador / estável do Java.

Resumindo: podemos esperar que o desenvolvimento futuro de Java tenha impacto em linguagens como Scala e Clojure para manter a interoperabilidade com Java? Já existe alguma (link para) discussão em andamento sobre esse tópico?

Nota

Posso imaginar que Scala, Clojure e outras linguagens baseadas em JVM não terão grandes problemas ao atualizar sua implementação para versões mais recentes da JVM (e que os novos recursos da JVM tornarão essa implementação ainda mais fácil). Minha pergunta se concentra nos recursos do Java como uma linguagem e se / como outra linguagem da JVM poderá "ver" / usar esses novos recursos, não se as linguagens baseadas na JVM serão executadas nas mais recentes JVMs.

Na verdade, o Java 8 não introduz muita coisa que será prejudicial para outras linguagens da JVM que interoperam com o Java. O trabalho realizado no Lambdas ajudou a corrigir uma série de pequenos problemas em torno de invokedynamic, MethodHandles, MethodReferences etc. - mas, além disso, ele continua normalmente. Dito isso, há um monte de APIs totalmente novas que as outras linguagens da JVM poderiam potencialmente chamar agora. Quais eles usarão por padrão ou não, depende deles.

A maior interoperabilidade que impactou as mudanças ocorreu com o Java 7 - com o bytecode invocado dinâmico que permite chamadas de ligação dinâmica / tardia na JVM - algo que foi projetado inicialmente para os outros idiomas da JVM. Desde então, foi muito útil para o Lamdbas; assim, a partir do Java 8, o Java começará a emitir esses bytecodes.

Algumas linguagens (JRuby, por exemplo) já usam muito o invokedynamic, enquanto outras (Scala, Groovy et al) ainda estão investigando seu uso ou estão nos estágios iniciais de aplicação. Em teoria, as chamadas dinâmicas são quase tão eficazes quanto as existentes. Chamadas invocadas por Java, em oposição à miríade de soluções mais lentas que elas foram forçadas a usar no passado.

O Java 9 trará mais desafios para as linguagens da JVM, com o projeto Jigsaw chegando à plataforma, que será o começo do fim dos tradicionais carregamentos de classe e caminhos de classe para a JVM. O pessoal da linguagem JVM está bem ciente disso e espero que ocorra alguma colaboração sensata.

O Scala está prestes a ser deixado para trás quando o Java adiciona lambdas porque o Java lambdas recebe um tipo de acordo com o contexto em que é usado, enquanto o Scala lambdas recebe um tipo com base em suas áreas, tipos de parâmetros e tipos de retorno, por exemplo,

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

do Java 8 pode ser escrito em Scala como:

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

a menos que você use / grave alguns wrappers convertendo Scala's () => Unit em Runnable.