Effective Kotlin

Limiting mutability

1. Immutability makes it easier to parallelize the program

2. References to immutable objects can be cached as they not going to change

Read-inly properties

class BlaBla {
    val oneTime = calculate() // once during class instantiation calculate() is executed
    val eachTime: Int
        get() = calculate() // !!each time calculate() executes for eachTime access

    val name: String? = "Alex"
    val secondName: String = "Mart"

    val fullName: String?
        get() = name?.let {"$it $secondName"}

    val fullName2 = name?.let {"$it $secondName"}

    fun calculate(): Int {
        println("Calculating...")
        return 42
    }
}

fun main() {
    val instance = BlaBla()

    if (instance.fullName != null) {
        println(instance.fullName?.length) // smartcast doesn't work here as
    }                                      // fullName has custom getter
        // it means compiler still assumes instance.fullName can be null 

    if (instance.fullName2 != null) { // smartcast works here
        println(instance.fullName2.length)
    }
}

Mutable and read-only collections

Down-casting read-only collections to mutable should never take place

Instead do this

val list = listOf(1,2,3)
val mutableList = list.toMutableList()
mutableList.add(4)

Copy in data classes

class User(
    val name: String,
    val surname: String
) {
    fun withSurname(surname: String) = User(name, surname) // each time new object is cretaed
// but this is immutale, which is good
// on the other hand it is too much to create such function for each class field    
}

data class User(
    val name: String,
    val surname: String
)
var user = User("Alex", "Mart")
user = user.copy(surname = "other")

// copy function which comes out of the box for data classes is recommended way to
// keep objects immutable, instead of making fields var