Publication de Kotlin 1.6.0

Delphine Massenhove

Read this post in other languages:

• English
,
• Deutsch
,
• 한국어
,
• Русский
,
• 简体中文

Kotlin 1.6.0 est maintenant officiellement disponible et apporte notamment la stabilisation des expressions when exhaustives, ainsi que l’ajout du plugin Kover et d’un nouveau gestionnaire de mémoire pour Kotlin/Native. D’autres fonctionnalités du langage et de la bibliothèque standard publiées dans la version 1.5.30 sont également passées au stade stable. Merci pour tous les retours que vous avez partagés avec nous. Si vous n’avez pas encore essayé ces nouvelles fonctionnalités, c’est le moment !

Cet article présente les nouveautés suivantes :

• Fonctionnalités du langage : instructions when scellées, fonctions et conversions suspensives, instanciation des classes d’annotation, amélioration de l’inférence de type standard et de l’inférence de type de générateur.
• Kotlin/JVM : propriétés déléguées optimisées et annotations reproductibles.
• Kotlin/Native : aperçu du nouveau modèle de gestion de la mémoire, prise en charge de Xcode 13, compilation croisée des cibles Windows, mise à jour de LLVM et de l’éditeur de liens, amélioration des performances et ABI des plugins du compilateur unifiée.
• Possibilité de désactiver le téléchargement de Node.js et de Yarn pour Kotlin/JS.
• L’annonce de Kover.
• Bibliothèque standard : nouvelles fonctions pour l’entrée standard, fonction typeOf() et API Duration stables, stabilisation d’autres fonctions stdlib.

Abonnez-vous à notre blog pour ne plus manquer aucune des mises à jour de Kotlin

Comment faire la mise à jour

Si vous utilisez IntelliJ IDEA ou Android Studio, vous pouvez choisir la mise à jour automatique de Kotlin.

Mise à jour vers Kotlin 1.6.0

Fonctionnalités du langage

Nous avons stabilisé les fonctionnalités de Kotlin 1.5.30 en tenant compte de vos retours d’expérience.

Déclarations when (exhaustives) scellées

Les déclarations when scellées sont une fonctionnalité très attendue qui permet au compilateur de Kotlin de vous avertir si vos instructions when ne sont pas exhaustives. Cela améliore la sécurité de votre code sans avoir à introduire vos propres fonctions. 

Kotlin a toujours été exhaustif dans la vérification des expressions when pour les enums, les types booléens et les classes scellés. Cela s’avère utile lorsque vous modélisez votre domaine avec les types de données algébriques. Vous pouvez par exemple modéliser diverses préférences de contact pour les utilisateurs de votre application sous la forme d’une hiérarchie de classe scellée :

sealed class Contact {
   data class PhoneCall(val number: String) : Contact()
   data class TextMessage(val number: String) : Contact()
   data class InstantMessage(val type: IMType, val user: String) : Contact()
}

Désormais, lorsque vous écrivez une expression qui renvoie un résultat différent en fonction des préférences de contact, le compilateur signalera une erreur si vous oubliez de gérer tous les types présents dans votre application :

fun Rates.computeMessageCost(contact: Contact): Cost =
   when (contact) { // ERROR: 'when' expression must be exhaustive
       is Contact.PhoneCall -> phoneCallCost
       is Contact.TextMessage -> textMessageCost
   }

C’est une aide précieuse, tant pour l’écriture du code que pour sa maintenance. Si vous ajoutez ultérieurement un autre type de préférence de contact, vous savez que le compilateur s’assurera que vous n’ayez pas oublié de vérifier et gérer les différents types de préférences de contact dans votre code.

A noter qu’avant Kotlin 1.6, le code qui utilisait instructions when était correctement compilé, même s’il ne gérait pas l’envoi de notifications aux utilisateurs via messages instantanés :

fun sendAnnouncement(contact: Contact, announcement: Announcement) {
   when (contact) {
       is Contact.PhoneCall -> schedulePhoneCall(contact.number, announcement)
       is Contact.TextMessage -> sendTextMessage(contact.number, announcement)
   }
}

Seule une inspection faible de l’IDE était signalée, sans aucun message du compilateur. À partir de Kotlin 1.6, l’avertissement du compilateur est le suivant :

Non-exhaustive 'when' statements on sealed class/interface will be prohibited in 1.7. Add an 'is InstantMessage' branch or 'else' branch instead.

Dand Kotlin 1.7, cela deviendra une erreur, ce qui supprimera tout risque d’oubli. Veuillez consulter le document KT-47709 pour plus de détails sur ce changement et ses effets. 

Fonctions suspensives en tant que supertypes

Kotlin 1.6 stabilise la prise en charge de l’implémentation de types fonctionnels suspend en tant que super interfaces. C’était l’une des pièces manquantes dans les coroutines de Kotlin. 

Lorsque vous concevez des API Kotlin, les types fonctionnels sont généralement utilisés lorsque vous devez personnaliser le comportement de plusieurs fonctions de la bibliothèque. Par exemple, l’API kotlinx.coroutines a une fonction membre dans son interface Job qui ressemble à ceci :

fun invokeOnCompletion(handler: () -> Unit)

Vous pouvez facilement utiliser cette fonction avec des lambdas comme invokeOnCompletion { doSomething() }. Si vous avez une classe avec laquelle vous voulez gérer la complétion, vous pouvez simplifier et optimiser votre code en implémentant le type fonctionnel () -> Unit directement dans votre classe sans créer de lambda supplémentaire :

class MyCompletionHandler : () -> Unit {
   override fun invoke() { doSomething() }
}

À partir de Kotlin 1.6, cette optimisation est possible avec les fonctions suspensives. Si vos API acceptent les types fonctionnels suspensifs, comme par exemple :

public fun launchOnClick(action: suspend () -> Unit) {}

… alors vous n’avez plus de restrictions sur l’utilisation des lambdas et des fonctions d’arrêt dans votre code. Vous pouvez aussi implémenter les types fonctionnels suspensifs correspondants dans une classe :

class MyClickAction : suspend () -> Unit {
   override suspend fun invoke() { doSomething() }
}

Conversions suspensives

Kotlin 1.6 stabilise les conversions des types de fonctions standard en fonctions suspensives. Vous pouvez maintenant utiliser les types de fonctions standard appropriés lorsqu’un paramètre de type suspensif est attendu. Le compilateur effectuera automatiquement la conversion.

Cela corrige une petite (mais pénible) incohérence dans l’interaction entre les fonctions standard et les fonctions suspensives en Kotlin. Si vous avez une fonction d’ordre supérieur qui accepte une fonction suspensive, comme un appel collect sur un flux Kotlin, au lieu d’utiliser une lambda pour l’appeler, comme ceci :

flow.collect { processItem(it) }

fun processItem(item: Item) { /* ... */ }

… vous pouvez passer une référence à la fonction processItem dans l’appel collect pour obtenir le même résultat :

flow.collect(::processItem)

Dans ce cas, vous devriez ensuite extraire une référence à votre fonction de traitement dans une variable afin de personnaliser son comportement dans votre code. Cette technique ne fonctionnait pas dans les versions antérieures à Kotlin 1.6 car il s’agit d’une fonction standard qui est passée en tant que paramètre d’un type suspensif :

val processingFunction = ::processItem
flow.collect(processingFunction) // ERROR: Type mismatch

Avec Kotlin 1.6, le code ci-dessus se compile et fonctionne.

Inférence de type améliorée pour les types génériques récursifs

Avec la version 1.6.0, le compilateur Kotlin peut déduire un argument de type en se basant uniquement sur les limites supérieures du paramètre de type correspondant s’il s’agit d’un générique récursif par défaut. Cela permet de créer divers modèles avec des types génériques récursifs qui sont souvent utilisés en Java pour réaliser des API de constructeur.

// Avant 1.5.30
val containerA = PostgreSQLContainer<nothing>(DockerImageName.parse("postgres:13-alpine")).apply {
    withDatabaseName("db")
    withUsername("user")
    withPassword("password")
    withInitScript("sql/schema.sql")
}

// Avec l'option du compilateur dans la version 1.5.30 ou par défaut à partir de la version 1.6.0
val containerB = PostgreSQLContainer(DockerImageName.parse("postgres:13-alpine"))
    .withDatabaseName("db")
    .withUsername("user")
    .withPassword("password")
    .withInitScript("sql/schema.sql")

Amélioration de l’inférence de constructeur

La version 1.5.30 de Kotlin a inauguré l’option de compilation -Xunrestricted-builder-inference, qui permet d’obtenir des informations sur le type d’un appel au constructeur à l’intérieur des lambdas du constructeur. Cela permet notamment d’effectuer des appels qui renvoient une instance d’un type pas encore déduit, comme get() dans une lambda buildList().

À partir de la version 1.6.0, vous n’avez plus besoin de spécifier -Xunrestricted-builder-inference pour effectuer des appels précédemment interdits. Avec l’option de compilation -Xenable-builder-inference, vous pouvez désormais écrire vos propres constructeurs génériques sans appliquer l’annotation @BuilderInference et activer automatiquement l’inférence de constructeur si l’inférence de type ordinaire ne peut pas résoudre les informations de type.

Prolongement de la prise en charge des versions d’API

Avec Kotlin 1.6.0, vous pouvez développer en utilisant trois versions précédentes de l’API (en plus de la version stable actuelle) au lieu de deux. Actuellement, cela inclut donc les versions 1.3, 1.4, 1.5 et 1.6 de l’API.

Kotlin/JVM

Annotations reproductibles avec rétention RUNTIME Kotlin, comme Java 8, dispose d’annotations reproductibles. Avec Kotlin 1.6, la fonctionnalité est compatible avec Java et @kotlin.annotation.Repeatable accepte désormais toute rétention et rend l’annotation reproductible en Kotlin et en Java. Les annotations répétables Java sont désormais également prises en charge côté Kotlin.

Kotlin/Native

Vous pouvez maintenant essayer la version expérimentale du nouveau gestionnaire de mémoire Kotlin/Native. Grâce à cette fonctionnalité, nous pouvons offrir une expérience de développement plus cohérente pour les projets multiplateforme. Le nouveau gestionnaire de mémoire lève les restrictions sur le partage d’objets entre les threads et fournit des primitives de programmation concurrentes totalement exemptes de fuites, sûres et ne nécessitant aucune gestion ou annotation spéciales de la part des développeurs.

Vous pouvez librement mettre à jour votre Xcode et continuer à travailler sur vos projets Kotlin car Kotlin/Native prend désormais en charge Xcode 13. 

Compilation de cibles Windows sur n’importe quel hôte. Vous pouvez compiler les cibles Windows mingwX64 et mingwX86 sur tout hôte prenant en charge Kotlin/Native.

Nous avons remanié la dépendance LLVM que Kotlin/Native utilise en interne. Cela apporte plusieurs avantages, comme la mise à jour de la version 11.1.0 de LLVM et la diminution de la taille des dépendances.

ABI du plugin du compilateur unifiée avec les backends JVM et JS IR. Le plugin Kotlin Multiplatform Gradle est désormais en mesure d’utiliser le compilateur jar intégrable (celui utilisé pour les backends JVM et JS IR) pour Kotlin/Native. Vous pouvez utiliser les mêmes artefacts de plugin de compilation pour Native et les autres plateformes prises en charge.

Kotlin/JS

Pour créer sur un serveur sans connexion Internet, vous pouvez désormais désactiver le téléchargement de Node.js et de Yarn pour les projets Kotlin/JS et utiliser les instances déjà installées sur l’hôte.

Kover

Depuis la première version, la mesure précise de la couverture du code a été un défi. D’excellents outils comme JaCoCo fonctionnent avec du code Kotlin mais ne sont pas totalement intégrés à notre chaîne d’outils Gradle et aux projets multiplateforme. Dans cette version de Kotlin, nous avons commencé à corriger ce problème. Découvrez Kover, notre nouveau plugin Gradle qui mesure la couverture du code Kotlin généré avec le compilateur Kotlin/JVM. Nous ne sommes qu’au début de sa phase de développement et il reste expérimental. N’hésitez pas à nous faire part de vos retours le concernant sur GitHub.

Regardez la vidéo sur Kover pour en savoir plus.

Bibliothèque standard

Kotlin 1.6.0 coche trois éléments de la feuille de route stdlib en supprimant !! après readLine(), en stabilisant typeOf() et en fournissant une API Duration stable. Il amène également les fonctions stdlib suivantes à l’état stable :

• Constructeurs de collections
• Opérations de rotation par bits sur des entiers
• Fonction Regex pour diviser une chaîne de caractères en séquence

Nous avons également ajouté la possibilité d’appeler compareTo en notation infixe et offrons une expérience cohérente pour les fonctions replace() dans JVM et JS.

Nouvelles fonctions pour l’entrée standard

Avec Kotlin 1.6.0, nous avons supprimé la nécessité d’utiliser l’opérateur d’assertion not-null !! après avoir lu une ligne de l’entrée standard, afin d’améliorer l’expérience des novices et de simplifier l’enseignement de Kotlin.

Nous fournissons de nouvelles fonctions pour la lecture à partir de la console avec l’expérience suivante :

• readln() lève une exception lorsque la fin du fichier (EOF) a été atteinte. Utilisez cette fonction au lieu de vérifier si le résultat de readLine() est null avec l’opérateur !!.
• La nouvelle fonction readlnOrNull() est une alternative à un retour null. Elle se comporte de la même manière que l’ancienne readLine(), mais porte un nom plus représentatif.

Ces fonctions sont maintenant disponibles pour JVM et Native. La convention de nommage de ces fonctions est désormais cohérente avec leur contrepartie println(), un point particulièrement important pour les novices.

fun main() {
    println("Input two integer numbers each on a separate line")
    val num1 = readln().toInt()
    val num2 = readln().toInt()
    println("The sum of $num1 and $num2 is ${num1 + num2}")
}

API Duration stable

Grâce à vos retours, nous avons stabilisé l’API Duration et fermé l’élément correspondant sur la feuille de route.

En plus d’une meilleure lisibilité du résultat de Duration.toString() et des nouvelles fonctions d’analyse de durées à partir d’une chaîne de caractères, qui étaient disponibles en preview dans la version 1.5.30, l’API Duration a fait l’objet des modifications suivantes :

• Le composant days de la fonction toComponents a maintenant le type Long au lieu de Int pour éviter que les valeurs ne soient tronquées.
• L’enum DurationUnit n’est plus un alias de type. La JVM n’a pas de cas d’utilisation en tant qu’alias pour j ava.util.concurrent.TimeUnit .
• En réaction aux retours de la communauté, nous réactivons des propriétés d’extension comme Int.seconds. Pour limiter leur applicabilité, elles ne sont disponibles que dans le compagnon de la classe Duration.

import kotlin.time.Duration.Companion.seconds

fun main() {
//sampleStart
    val duration = 5000.seconds
    println("There are ${duration.inWholeMinutes} minutes in ${duration.inWholeHours} hours")
//sampleEnd
}

Fonction typeOf() stable

Kotlin 1.6.0 apporte Une fonction typeOf() stable et ferme l’élément correspondant de la feuille de route. Depuis la version 1.3.40, typeOf() est disponible sur la plateforme JVM en tant qu’API expérimentale. Vous pouvez maintenant l’utiliser sur n’importe quelle plateforme Kotlin pour obtenir une représentation KType de n’importe quel type Kotlin que le compilateur peut déduire. 

inline fun <reified T> renderType(): String {
    val type = typeOf<T>()
    return type.toString()
}

fun main() {
    val fromExplicitType = typeOf<Int>()
    val fromReifiedType = renderType<List<Int>>()
}

Constructeurs de collections stables

Kotlin 1.6.0 passe les fonctions de construction de collection (buildMap(), buildList() et buildSet()) au stade stable. Les collections retournées par les constructeurs sont maintenant sérialisables en lecture seule.

Opérations de rotation par bits stables pour les entiers

Avec Kotlin 1.6.0, les fonctions rotateLeft() et rotateRight(), qui font pivoter la représentation binaire du nombre vers la gauche ou la droite d’un nombre de bits spécifié, sont devenues stables.

fun main() {
//sampleStart
    val number: Short = 0b10001
    println(number.rotateRight(2).toString(radix = 2)) // 100000000000100
    println(number.rotateLeft(2).toString(radix = 2))  // 1000100
//sampleEnd
}

Fonction Regex stable pour diviser une chaîne de caractères en séquence

Kotlin 1.6.0 stabilise également splitToSequence(), une fonction pour les expressions régulières qui divise une chaîne de caractères en séquence.

fun main(){
//sampleStart
    val colorsText = "green, red , brown&blue, orange, pink&green"
    val regex = "[,\\s]+".toRegex()
    val mixedColor = regex.splitToSequence(colorsText)
        .onEach { println(it) }
        .firstOrNull { it.contains('&') }
    println(mixedColor) // "brown&blue"
//sampleEnd
}

compareTo en notation infixe

Nous avons ajouté la possibilité d’appeler la fonction Comparable.compareTo en notation infixe pour comparer l’ordre de deux objets : 

class WrappedText(val text: String) : Comparable<WrappedText> {
    override fun compareTo(other: WrappedText): Int =
        this.text compareTo other.text
}

Cohérence de replace() et replaceFirst() sur JVM et JS

Avant Kotlin 1.6.0, les fonctions replace() et replaceFirst() se comportaient différemment sur JVM et JS lorsque la chaîne de remplacement contenait une référence à un groupe. Le comportement sur Kotlin/JS est maintenant le même que sur JVM.

​​Compatibilité

Comme lors de chaque mise à jour de fonctionnalités, certains cycles d’obsolescence de changements annoncés précédemment arrivent à leur terme avec Kotlin 1.6.0. Tous ces cas ont été soigneusement examinés par le comité du langage et sont répertoriés dans le Guide de compatibilité pour Kotlin 1.6. Vous pouvez également consulter ces changements sur YouTrack.

Comment installer Kotlin 1.6.0

Si vous utilisez IntelliJ IDEA ou Android Studio, votre IDE vous proposera de mettre à jour Kotlin vers la version 1.6.0 automatiquement. Vous pouvez également lancer une mise à jour manuellement en suivant ces instructions.

Vous pouvez télécharger les dernières versions des IDE suivants pour bénéficier d’une prise en charge étendue pour Kotlin :

• IntelliJ IDEA – pour développer des applications Kotlin pour différentes plateformes.
• Android Studio – pour développer des applications mobiles Android et multiplateforme.

Assurez-vous également de mettre à jour les bibliothèques kotlinx vers des versions compatibles et de spécifier la version Kotlin 1.6.0 dans les scripts de build de vos projets existants.

Si vous avez besoin du compilateur en ligne de commande, téléchargez-le depuis la page Github de la version.

En cas de problème

• Trouvez de l’aide sur Slack (recevoir une invitation).
• Signalez-le dans notre outil de suivi de tickets, YouTrack.

Autres lectures et vidéos

• Feuille de route de Kotlin
• Kover – Le plugin de couverture de code
• Nouveautés de Kotlin 1.6.0 dans la documentation
• Nouveautés de Kotlin 1.6.0 sur YouTube
• Guide de compatibilité pour Kotlin 1.6
• Kotlin 1.5.30 est disponible !

Principaux auteurs de tickets sur YouTrack

Ryan Nett (48 tickets), Zac Sweers (22 tickets), Tianyu Geng (18 tickets), zhelenskiy (18 tickets), Thodoris Sotiropoulos (15 tickets), AndroidDeveloperLB (14 tickets), Morgan, Bartholomew (14 tickets), Mikhail Naftal (14 tickets), Louis CAD (12 tickets), Philip Wedemann (12 tickets), Victor Turansky (11 tickets), Igor Wojda (11 tickets), Martin Bonnin (11 tickets), Iaroslav Postovalov (11 tickets), Cedric (10 tickets), 凛 (9 tickets), Ben Woodworth (8 tickets), Tianyi Guan (8 tickets), Chris Povirk (8 tickets), Alon Albert (8 tickets).

Contributeurs externes

Un grand merci à l’ensemble de nos contributeurs et contributrices dont les requêtes pull ont été incluses dans cette version : Pyos, Tianyu Geng, Jinseong Jeon, Steven Schäfer, Mark Punzalan, Hung Nguyen, Mads Ager, Ting-Yuan Huang, Matthew Gharrity, Ivan Gavrilovic, Xin Wang, ov7a, Jiaxiang Chen, Yigit Boyar, Bingran, bracadabra, Steffi Stumpos, Andrey Kuleshov.

Auteur de l’article original en anglais :

Subscribe to Kotlin Blog updates

Subscribe form

By submitting this form, I agree to the JetBrains Privacy Policy Notification icon

En envoyant ce formulaire, j'accepte que JetBrains s.r.o. (« JetBrains ») utilise mon nom, mon adresse e-mail et mes données de localisation pour m'envoyer des newsletters, y compris des communications commerciales, et pour traiter mes données personnelles à cet effet. J'accepte que JetBrains puisse traiter ces données au moyen de services tiers à cette fin et conformément à la Charte de confidentialité de JetBrains. Je comprends que je peux révoquer mon consentement à tout moment dans mon profil. De plus, un lien de désabonnement est inclus dans chaque e-mail.

Submit

Merci de votre abonnement !