A conversão inteligente para 'Tipo' é impossível, porque 'variável' é uma propriedade mutável que poderia ter sido alterada nesse momento

E o novato em Kotlin pergunta: "Por que o código a seguir não é compilado?":

    var left: Node? = null

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

A conversão inteligente para 'Nó' é impossível, porque 'esquerda' é uma propriedade mutável que poderia ter sido alterada nesse momento

Recebo que lefté uma variável mutável, mas estou verificando explicitamente left != nulle lefté do tipo, Nodepor que não pode ser transmitida de forma inteligente para esse tipo?

Como posso corrigir isso de forma elegante? :)

Entre execução de left != nulle queue.add(left)outro encadeamento poderia ter alterado o valor de leftpara null.

Para contornar isso, você tem várias opções. Aqui estão alguns:

1. Use uma variável local com conversão inteligente:

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

2. Use uma chamada segura , como uma das seguintes opções:

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

3. Use o operador Elvis com returnpara retornar cedo da função de fechamento:

   queue.add(left ?: return)

   Observe que breake continuepode ser usado de forma semelhante para verificações dentro de loops.

1) Também é possível usar lateinitSe você com certeza inicializar mais tarde onCreate()ou em outro lugar.

Usa isto

lateinit var left: Node

Em vez disso

var left: Node? = null

2) E existe outra maneira de usar o !!fim da variável quando você a usa assim

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

Existe uma quarta opção além das da resposta de mfulton26.

Ao usar o ?.operador, é possível chamar métodos e campos sem lidar com letou usar variáveis ​​locais.

Algum código para o contexto:

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

Funciona com métodos, campos e todas as outras coisas que tentei fazer funcionar.

Portanto, para resolver o problema, em vez de precisar usar projeções manuais ou variáveis ​​locais, você pode usar ?.para chamar os métodos.

Para referência, isso foi testado em Kotlin 1.1.4-3, mas também testado em 1.1.51e 1.1.60. Não há garantia de que funcione em outras versões; pode ser um novo recurso.

O uso do ?.operador não pode ser usado no seu caso, já que é uma variável transmitida que é o problema. O operador Elvis pode ser usado como uma alternativa e provavelmente é o que requer a menor quantidade de código. Em vez de usar continue, porém, returntambém pode ser usado.

O uso da transmissão manual também pode ser uma opção, mas isso não é seguro para nulos:

queue.add(left as Node);

Ou seja, se a esquerda foi alterada em um segmento diferente, o programa falhará.

A razão prática pela qual isso não funciona não está relacionada a threads. O ponto é que node.lefté efetivamente traduzido para node.getLeft().

Este getter de propriedade pode ser definido como:

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

Portanto, duas chamadas podem não retornar o mesmo resultado.

Mude var left: Node? = nullpara lateinit var left: Node. Problema resolvido.

Faça isso:

var left: Node? = null

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

Qual parece ser a primeira opção fornecida pela resposta aceita, mas é isso que você está procurando.

Para que haja uma conversão inteligente das propriedades, o tipo de dados da propriedade deve ser a classe que contém o método ou o comportamento que você deseja acessar e NÃO que a propriedade seja do tipo da superclasse.

por exemplo, no Android

Estar:

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

Solução:

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

Uso:

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

GL

Sua solução mais elegante deve ser:

var left: Node? = null

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

Então você não precisa definir uma variável local nova e desnecessária e não possui nenhuma nova asserção ou conversão (que não seja SECA). Outras funções de escopo também podem funcionar, então escolha o seu favorito.

Tente usar o operador de asserção não nulo ...

queue.add(left!!) 

Como eu escreveria:

var left: Node? = null

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