La conversion intelligente en «Type» est impossible, car «variable» est une propriété modifiable qui aurait pu être modifiée à ce moment

Et le débutant de Kotlin demande: "Pourquoi le code suivant ne compilera-t-il pas?":

    var left: Node? = null

    fun show() {
         if (left != null) {
             queue.add(left) // ERROR HERE
         }
    }

La conversion intelligente vers 'Node' est impossible, car 'left' est une propriété modifiable qui aurait pu être modifiée à ce moment

J'obtiens que leftc'est une variable mutable, mais je vérifie explicitement left != nullet leftest de type Nodealors pourquoi ne peut-il pas être casté intelligemment dans ce type?

Comment puis-je résoudre ce problème avec élégance? :)

Entre l'exécution de left != nullet queue.add(left)un autre thread aurait pu changer la valeur de leften null.

Pour contourner cela, vous avez plusieurs options. Voilà quelque:

1. Utilisez une variable locale avec une conversion intelligente:

   val node = left
   if (node != null) {
       queue.add(node)
   }

2. Utilisez un appel sécurisé tel que l'un des suivants:

   left?.let { node -> queue.add(node) }
   left?.let { queue.add(it) }
   left?.let(queue::add)

3. Utilisez l' opérateur Elvis avec returnpour revenir tôt de la fonction englobante:

   queue.add(left ?: return)

   Notez que breaket continuepeut être utilisé de manière similaire pour les vérifications dans les boucles.

1) Vous pouvez également utiliser lateinitSi vous vous faites votre initialisation plus tard onCreate()ou ailleurs.

Utilisez ceci

lateinit var left: Node

Au lieu de cela

var left: Node? = null

2) Et il y a une autre façon d'utiliser la !!fin de variable lorsque vous l'utilisez comme ceci

queue.add(left!!) // add !!

Il y a une quatrième option en plus de celles de la réponse de mfulton26.

En utilisant l' ?.opérateur, il est possible d'appeler des méthodes ainsi que des champs sans traiter letou utiliser des variables locales.

Du code pour le contexte:

var factory: ServerSocketFactory = SSLServerSocketFactory.getDefault();
socket = factory.createServerSocket(port)
socket.close()//smartcast impossible
socket?.close()//Smartcast possible. And works when called

Il fonctionne avec des méthodes, des champs et toutes les autres choses que j'ai essayé de faire fonctionner.

Ainsi, afin de résoudre le problème, au lieu d'avoir à utiliser des transtypages manuels ou à l'aide de variables locales, vous pouvez utiliser ?.pour appeler les méthodes.

Pour référence, cela a été testé dans Kotlin 1.1.4-3, mais également testé dans 1.1.51et 1.1.60. Il n'y a aucune garantie que cela fonctionne sur d'autres versions, cela pourrait être une nouvelle fonctionnalité.

L'utilisation de l' ?.opérateur ne peut pas être utilisée dans votre cas car c'est une variable transmise qui est le problème. L'opérateur Elvis peut être utilisé comme alternative, et c'est probablement celui qui nécessite le moins de code. Au lieu d'utiliser continuecependant, returnpourrait également être utilisé.

L'utilisation de la coulée manuelle peut également être une option, mais ce n'est pas sans danger:

queue.add(left as Node);

Ce qui signifie que si la gauche a changé sur un autre thread, le programme plantera.

La raison pratique pour laquelle cela ne fonctionne pas n'est pas liée aux threads. Le fait est que cela node.leftest effectivement traduit en node.getLeft().

Cet getter de propriété peut être défini comme suit:

val left get() = if (Math.random() < 0.5) null else leftPtr

Par conséquent, deux appels peuvent ne pas retourner le même résultat.

Remplacez var left: Node? = nullpar lateinit var left: Node. Problème résolu.

Faites ceci:

var left: Node? = null

fun show() {
     val left = left
     if (left != null) {
         queue.add(left) // safe cast succeeds
     }
}

Ce qui semble être la première option fournie par la réponse acceptée, mais c'est ce que vous recherchez.

Pour qu'il y ait une conversion intelligente des propriétés, le type de données de la propriété doit être la classe qui contient la méthode ou le comportement auquel vous souhaitez accéder et NON que la propriété soit du type de la super classe.

par exemple sur Android

Être:

class MyVM : ViewModel() {
    fun onClick() {}
}

Solution:

From: private lateinit var viewModel: ViewModel
To: private lateinit var viewModel: MyVM

Usage:

viewModel = ViewModelProvider(this)[MyVM::class.java]
viewModel.onClick {}

GL

Votre solution la plus élégante doit être:

var left: Node? = null

fun show() {
    left?.also {
        queue.add( it )
    }
}

Ensuite, vous n'avez pas à définir de variable locale nouvelle et inutile, et vous n'avez pas de nouvelles assertions ou transtypages (qui ne sont pas DRY). D'autres fonctions de portée peuvent également fonctionner, alors choisissez votre préférée.

Essayez d'utiliser l'opérateur d'assertion non nul ...

queue.add(left!!) 

Comment je l'écrirais:

var left: Node? = null

fun show() {
     val left = left ?: return
     queue.add(left) // no error because we return if it is null
}