Kotlin 1.1 apporte les Coroutines, les Alias de Type, une Prise en Charge améliorée de JavaScript

La nouvelle version de Kotlin introduit un certain nombre de nouvelles fonctionnalités du langage - en particulier les coroutines - et une prise en charge améliorée de sa cible JavaScript, d'après Roman Belov, responsable marketing de Kotlin.

Bien qu'elle soit encore considérée comme expérimentale, l'une des principales nouveautés de Kotlin 1.1 est les coroutines, qui sont disponibles grâce à l'utilisation de trois constructions de niveau supérieur : async , await et yield. C'est ainsi, par exemple, comment l'on peut utiliser async et await pour gérer les opérations asynchrones :

// runs the code in the background thread pool
fun asyncOverlay() = async(CommonPool) {
    // start two async operations
    val original = asyncLoadImage("original")
    val overlay = asyncLoadImage("overlay")
    // and then apply overlay to both results
    applyOverlay(original.await(), overlay.await())
}

// launches new coroutine in UI context
launch(UI) {
    // wait for async overlay to complete
    val image = asyncOverlay().await()
    // and then show it in UI
    showImage(image)
}

Notez l'utilisation de launch pour démarrer une coroutine. En fait, await peut seulement être utilisé depuis une coroutine ou d'une fonction qui est déclarée avec le mot-clé suspend, ce qui permet au compilateur de générer le code approprié pour exécuter cette fonction dans une coroutine :

suspend fun workload(n: Int): Int {
    delay(1000)
    return n
}

Dans l'exemple ci-dessus, delay suspend la coroutine sans bloquer son thread associé.

Les coroutines peuvent également être utilisées pour générer à la demande des séquences en utilisant yield :

// inferred type is Sequence<Int>
val fibonacci = buildSequence {
    yield(1) // first Fibonacci number
    var cur = 1
    var next = 1
    while (true) {
        yield(next) // next Fibonacci number
        val tmp = cur + next
        cur = next
        next = tmp
    }
}

println(fibonacci.take(10).joinToString())

Étant expérimentales, les coroutines sont seulement opt-in et leur API peut changer dans des versions ultérieures.

D'autres fonctionnalités importantes ajoutées dans la version 1.1 de Kotlin comprennent :

• Les alias de type, qui vous permettent de définir un autre nom pour un type.
• L'opérateur :: pour obtenir une référence de membre à partir d'une méthode d'un objet spécifique.
• Les classes de données peuvent maintenant être étendues.
• Le support de la déstructuration dans les lambdas.

En ce qui concerne la prise en charge de JavaScript, l'effort principal de la version 1.1 a été de prendre en charge JavaScript à un niveau équivalent à celui de la JVM. Cela signifie que toutes les fonctionnalités du langage sont disponibles pour les deux cibles, à l'exception de la réflexion, actuellement indisponible en JavaScript. En particulier :

• De larges pans de la librairie standard Kotlin peuvent maintenant être utilisés en JavaScript.
• Le code généré est plus convivial avec les outils JavaScript tels que les minifieurs, les optimiseurs, etc.
• Le modificateur external peut être utilisé pour déclarer les classes Kotlin qui sont implémentées en JavaScript.

Kotlin peut être essayé en utilisant son REPL en ligne ou installé d'un certain nombre de manières différentes.