Wie wird die neue Entwicklung von Java die Interoperabilität mit Sprachen wie Scala und Clojure beeinflussen?

Soweit ich weiß, wurden sowohl Scala als auch Clojure als neue Sprachen konzipiert

1. abhängig von der JVM und
2. Einfache Integration in Java-Code in dem Sinne, dass Java-Klassen in Scala- und Clojure-Code verwendet werden können.

Ab Java 8 (und möglicherweise noch stärker mit nachfolgenden Versionen von Java) wird sich die Semantik der Java-Sprache ändern.

Ich wollte fragen, wie sich diese Änderungen auf die Interoperabilität zwischen Java und Scala / Clojure auswirken und welche Konsequenzen dies haben wird. Da Lambdas in Java 8 beispielsweise keine Objekte sind (siehe z. B. hier ), müssen sich Scala und Clojure möglicherweise mit Java-Werten befassen, die keine Objekte sind. Wäre das ein Problem?

Ich kann mir folgende Szenarien vorstellen:

1. Die Scala- oder Clojure-Sprache wird erweitert, um sich an die neue Java-Semantik anzupassen (um die neuen Nicht-Objektwerte zu verarbeiten) und die Interoperabilität mit Java zu unterstützen.
2. Die Scala- oder Clojure-Sprache wird nicht erweitert. Dies wäre nur möglich, wenn die neuen Java-Funktionen wie Funktionswerte vorhandenen Konzepten zugeordnet werden können. In Scala ist beispielsweise sogar eine Funktion ein Objekt. Ich denke, Java-Funktionen würden wieder in eine Art Objekt eingeschlossen, wenn sie für Scala sichtbar werden.
3. Die Scala- oder Clojure-Sprache unterstützt weiterhin die Interoperabilität bis Java 6 oder 7, ohne die neueste Java-Entwicklung zu verfolgen. Dies würde erfordern, dass ältere Versionen von Java weiterhin unterstützt werden (zumindest von OpenJDK oder einem anderen Projekt), damit diese Sprachen auf einem konservativeren / stabileren Zweig von Java basieren können.

Zusammenfassend: Können wir erwarten, dass sich die zukünftige Entwicklung von Java auf Sprachen wie Scala und Clojure auswirkt, um die Interoperabilität mit Java aufrechtzuerhalten? Gibt es bereits eine (Link zu) laufende Diskussion zu diesem Thema?

Hinweis

Ich kann mir vorstellen, dass Scala, Clojure und andere JVM-basierte Sprachen keine größeren Probleme haben werden, ihre Implementierung auf neuere Versionen der JVM zu aktualisieren (und dass neue JVM-Funktionen diese Implementierung noch einfacher machen werden). Meine Frage konzentriert sich auf Funktionen von Java als Sprache und darauf, ob / wie andere JVM-Sprachen diese neuen Funktionen "sehen" / verwenden können, und nicht darauf, ob JVM-basierte Sprachen auf den neuesten JVMs ausgeführt werden.

Tatsächlich führt Java 8 nicht viel ein, was sich nachteilig auf andere JVM-Sprachen auswirkt, die mit Java zusammenarbeiten. Die Arbeit an Lambdas hat dazu beigetragen, eine Reihe kleiner Probleme im Zusammenhang mit invokedynamic, MethodHandles, MethodReferences usw. zu beheben - aber ansonsten geht es normal weiter. Das heißt, es gibt eine ganze Reihe neuer APIs, auf die die anderen JVM-Sprachen möglicherweise jetzt zugreifen könnten. Welche sie standardmäßig verwenden oder nicht, liegt bei ihnen.

Die größte Änderung, die sich auf Interop auswirkt, kam tatsächlich mit Java 7 - mit dem aufgerufenen dynamischen Bytecode, der dynamische / späte Bindungsaufrufe innerhalb der JVM ermöglicht - etwas, das ursprünglich für die anderen Sprachen in der JVM entwickelt wurde. Es wurde seitdem sehr nützlich für Lamdbas angepasst, sodass Java ab Java 8 tatsächlich diese Bytecodes ausgibt.

Einige Sprachen (z. B. JRuby) verwenden bereits stark invokedynamic, während andere (Scala, Groovy et al.) Die Verwendung noch untersuchen oder sich in einem frühen Stadium des Patchen befinden. Theoretisch sind ihre dynamischen Aufrufe fast so performant wie vorhanden Java invokestatische Aufrufe im Gegensatz zu den unzähligen langsameren Problemumgehungen, die sie in der Vergangenheit verwenden mussten.

Java 9 wird JVM-Sprachen vor weitere Herausforderungen stellen, da das Projekt Jigsaw auf die Plattform kommt, das der Anfang vom Ende für das traditionelle Laden von Klassen und Klassenpfade für die JVM sein wird. Die Leute in der JVM-Sprache sind sich dessen ziemlich bewusst und ich erwarte eine vernünftige Zusammenarbeit.

Scala wird gleich zurückgelassen, wenn Java Lambdas hinzufügt, da Java-Lambdas einen Typ entsprechend dem Kontext zugewiesen bekommen, in dem sie verwendet werden, während Scala-Lambdas einen Typ zugewiesen bekommen, der auf ihren Aritäten, Parametertypen und Rückgabetypen basiert, z.

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

aus Java 8 kann in Scala geschrieben werden als:

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

es sei denn, Sie verwenden / schreiben einige Wrapper, die Scalas () => Unit in Runnable konvertieren.