Bagaimana perkembangan baru Jawa akan mempengaruhi interoperabilitasnya dengan bahasa seperti Scala dan Clojure?

Sejauh yang saya mengerti, baik Scala dan Clojure telah dirancang sebagai bahasa baru itu

1. tergantung pada JVM, dan
2. mudah diintegrasikan dengan kode Java, dalam arti bahwa mereka memungkinkan untuk menggunakan kelas Java di dalam kode Scala dan Clojure.

Dimulai dengan Java 8 (dan mungkin bahkan lebih kuat dengan versi Java berikutnya), akan ada perubahan dalam semantik bahasa Java.

Saya ingin bertanya bagaimana perubahan ini akan berdampak pada interoperabilitas antara Jawa dan Scala / Clojure dan apa konsekuensinya. Misalnya, karena lambdas di Java 8 bukan objek (lihat misalnya di sini ), Scala dan Clojure mungkin harus berurusan dengan nilai-nilai Java yang bukan objek. Apakah ini akan menjadi masalah?

Saya dapat memikirkan skenario berikut:

1. Bahasa Scala atau Clojure akan diperluas untuk beradaptasi dengan semantik Java baru (untuk menangani nilai-nilai non-objek baru) dan mendukung interoperabilitas dengan Java.
2. Bahasa Scala atau Clojure tidak akan diperpanjang. Ini hanya akan mungkin jika fitur Java baru seperti nilai fungsi dapat dipetakan ke konsep yang ada. Misalnya, dalam Scala bahkan fungsi adalah objek, jadi saya kira fungsi Java akan dibungkus lagi menjadi beberapa jenis objek ketika mereka menjadi terlihat oleh Scala.
3. Bahasa Scala atau Clojure akan terus mendukung interoperabilitas hingga Java 6 atau 7, tanpa mengikuti perkembangan Java terbaru. Ini membutuhkan versi Java yang lebih lama masih didukung (setidaknya oleh OpenJDK atau proyek lain), sehingga bahasa-bahasa ini dapat didasarkan pada cabang Jawa yang lebih konservatif / stabil.

Ringkasnya: dapatkah kita berharap bahwa perkembangan Jawa di masa depan akan berdampak pada bahasa-bahasa seperti Scala dan Clojure untuk mempertahankan interoperabilitas dengan Jawa? Apakah sudah ada (tautan ke) diskusi berkelanjutan tentang topik ini?

Catatan

Saya dapat membayangkan bahwa Scala, Clojure, dan bahasa berbasis JVM lainnya tidak akan memiliki masalah besar dalam memperbarui implementasi mereka ke versi JVM yang lebih baru (dan bahwa fitur JVM baru akan membuat implementasi ini lebih mudah). Pertanyaan saya berfokus pada fitur Java sebagai bahasa dan apakah / bagaimana bahasa JVM lain akan dapat "melihat" / menggunakan fitur-fitur baru ini, bukan pada apakah bahasa berbasis JVM akan berjalan pada JVM terbaru.

Sebenarnya Java 8 tidak memperkenalkan banyak yang akan merugikan bahasa JVM lain yang berinteraksi dengan Java. Pekerjaan yang dilakukan pada Lambdas membantu memperbaiki sejumlah masalah kecil di sekitar invokedynamic, MethodHandles, MethodReferences dll - tetapi selain itu terus berjalan seperti biasa. Yang mengatakan, ada banyak sekali API yang bahasa JVM lainnya berpotensi memanggil sekarang. Yang mana yang akan mereka gunakan secara default atau tidak, terserah mereka.

Perubahan terbesar yang mempengaruhi interop sebenarnya datang dengan Java 7 - dengan bytecode invokedynamic yang memungkinkan panggilan dinamis / lambat dalam JVM - sesuatu yang awalnya dirancang untuk bahasa lain di JVM. Sejak itu telah sangat berguna diadaptasi untuk Lamdbas, sehingga pada Java 8, Java akan benar-benar mulai memancarkan bytecode ini.

Beberapa bahasa (JRuby misalnya) sudah banyak menggunakan invokedynamic, sementara yang lain (Scala, Groovy et al) masih menyelidiki penggunaannya atau masih dalam tahap awal menambalnya. Secara teori ini membuat panggilan dinamis mereka hampir sama berkinerja seperti yang sudah ada Panggilan Java invokestatic, yang bertentangan dengan segudang solusi yang lebih lambat yang terpaksa mereka gunakan di masa lalu.

Java 9 akan membawa lebih banyak tantangan untuk bahasa JVM dengan proyek Jigsaw datang ke platform yang akan menjadi awal dari akhir untuk pemuatan kelas tradisional dan classpath untuk JVM. Orang-orang bahasa JVM cukup sadar akan hal ini dan saya mengharapkan kolaborasi yang masuk akal terjadi.

Scala akan ditinggalkan ketika Jawa menambahkan lambdas karena Java lambdas mendapatkan jenis berdasarkan konteks yang digunakan, sedangkan Scala lambdas mendapatkan jenis berdasarkan aritas, jenis parameter dan jenis kembali, jadi misalnya,

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

dari Java 8 dapat ditulis dalam Scala sebagai:

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

kecuali jika Anda menggunakan / menulis beberapa pembungkus yang mengonversi Unit Scala () => ke Runnable.