val-mutável versus var-imutável em Scala

Há alguma orientação no Scala sobre quando usar val com uma coleção mutável versus usar var com uma coleção imutável? Ou você realmente deveria ter como objetivo val com uma coleção imutável?

O fato de haver os dois tipos de coleção me dá muitas opções e, muitas vezes, não sei como fazer essa escolha.

Pergunta bastante comum, esta. O difícil é encontrar as duplicatas.

Você deve se esforçar para obter transparência referencial . O que isso significa é que, se eu tiver uma expressão "e", posso fazer um val x = ee substituir epor x. Essa é a propriedade que a mutabilidade quebra. Sempre que você precisar tomar uma decisão de design, maximize para transparência referencial.

Na prática, um método-local varé o mais seguro varque existe, pois não foge ao método. Se o método for curto, melhor ainda. Se não estiver, tente reduzi-lo extraindo outros métodos.

Por outro lado, uma coleção mutável tem o potencial de escapar, mesmo que não. Ao alterar o código, você pode querer passá-lo para outros métodos ou retorná-lo. Esse é o tipo de coisa que quebra a transparência referencial.

Em um objeto (um campo), praticamente a mesma coisa acontece, mas com consequências mais terríveis. De qualquer forma, o objeto terá estado e, portanto, quebrará a transparência referencial. Mas ter uma coleção mutável significa que até o próprio objeto pode perder o controle de quem o está alterando.

Se você trabalha com coleções imutáveis ​​e precisa "modificá-las", por exemplo, adicionar elementos a elas em um loop, você deve usar vars porque precisa armazenar a coleção resultante em algum lugar. Se você ler apenas coleções imutáveis, use vals.

Em geral, certifique-se de não confundir referências e objetos. vals são referências imutáveis ​​(ponteiros constantes em C). Ou seja, ao usar val x = new MutableFoo(), você poderá alterar o objeto para o qual xaponta, mas não poderá alterar para qual objeto x aponta. O oposto é válido se você usar var x = new ImmutableFoo(). Pegando meu conselho inicial: se você não precisa mudar para qual objeto um ponto de referência, use vals.

A melhor maneira de responder é com um exemplo. Suponha que temos algum processo simplesmente coletando números por algum motivo. Desejamos registrar esses números e enviaremos a coleção para outro processo para fazer isso.

Claro, ainda estamos coletando números depois de enviarmos a coleção para o logger. E digamos que haja alguma sobrecarga no processo de registro que atrasa o registro real. Espero que você possa ver onde isso vai dar.

Se armazenarmos esta coleção em um mutável val, (mutável porque estamos continuamente adicionando a ele), isso significa que o processo que faz o registro estará olhando para o mesmo objeto que ainda está sendo atualizado pelo nosso processo de coleção. Essa coleção pode ser atualizada a qualquer momento e, portanto, quando for hora de registrar, podemos não estar realmente registrando a coleção que enviamos.

Se usarmos um imutável var, enviaremos uma estrutura de dados imutável para o logger. Quando adicionarmos mais números à nossa coleção, estaremos substituindo o nosso varpor uma nova estrutura de dados imutável . Isso não significa que a coleção enviada ao logger seja substituída! Ainda faz referência à coleção que foi enviada. Portanto, nosso logger irá de fato registrar a coleção que recebeu.

Acho que os exemplos nesta postagem do blog vão esclarecer melhor, pois a questão de qual combo usar se torna ainda mais importante em cenários de simultaneidade: a importância da imutabilidade para a simultaneidade . E já que estamos nisso, observe o uso preferencial de synchronized vs @volatile vs algo como AtomicReference: três ferramentas

var immutable vs. val mutable

Além de muitas respostas excelentes para essa pergunta. Aqui está um exemplo simples, que ilustra os perigos potenciais de val mutable:

Objetos mutáveis ​​podem ser modificados dentro de métodos, que os tomam como parâmetros, enquanto a reatribuição não é permitida.

import scala.collection.mutable.ArrayBuffer

object MyObject {
    def main(args: Array[String]) {

        val a = ArrayBuffer(1,2,3,4)
        silly(a)
        println(a) // a has been modified here
    }

    def silly(a: ArrayBuffer[Int]): Unit = {
        a += 10
        println(s"length: ${a.length}")
    }
}

Resultado:

length: 5
ArrayBuffer(1, 2, 3, 4, 10)

Algo assim não pode acontecer com var immutable, porque a reatribuição não é permitida:

object MyObject {
    def main(args: Array[String]) {
        var v = Vector(1,2,3,4)
        silly(v)
        println(v)
    }

    def silly(v: Vector[Int]): Unit = {
        v = v :+ 10 // This line is not valid
        println(s"length of v: ${v.length}")
    }
}

Resulta em:

error: reassignment to val

Uma vez que os parâmetros de função são tratados como valessa reatribuição não é permitida.