Null Safety

// JavaScript
function getLength(name) {
    return name.length;  // 💥 CRASH if name is null or undefined
}

getLength(null);  // TypeError: Cannot read properties of null

# Python
def get_length(name):
    return len(name)  # 💥 CRASH if name is None

get_length(None)  # TypeError: object of type 'NoneType' has no len()

var name: String = "Alex"
name = null           // ❌ COMPILE ERROR: Null can not be a value of a non-null type String

var nullableName: String? = "Alex"
nullableName = null   // ✅ OK — String? means "String or null"

val name: String? = null

// Without safe call — COMPILE ERROR:
// val length = name.length  // ❌ Only safe (?.) or non-null asserted (!!.) calls allowed

// With safe call:
val length: Int? = name?.length   // ✅ null — because name is null

val realName: String? = "Alex"
val realLength: Int? = realName?.length   // ✅ 4

data class Address(val city: String?)
data class Person(val address: Address?)

val person: Person? = null

// Chain of safe calls — returns null if ANY link is null
val city: String? = person?.address?.city

// Without safe calls, this would be:
// val city = if (person != null && person.address != null) person.address.city else null

val name: String? = null

// If name is null, use "Unknown" instead
val displayName = name ?: "Unknown"   // "Unknown"

// Works with any expression
val length = name?.length ?: 0        // 0

// Can throw as default too
val critical = name ?: throw IllegalArgumentException("Name required!")

// Equivalent to:
// val displayName = if (name != null) name else "Unknown"

val name: String? = null

val length = name!!.length   // 💥 NullPointerException at runtime!

// Only use !! when you are 100% sure it's not null
// Better alternatives exist almost always

val x: Any = "Hello"

val str: String? = x as? String     // "Hello"
val num: Int? = x as? Int           // null (no crash!)

// Without safe cast:
// val num = x as Int               // 💥 ClassCastException

fun describe(x: Any) = when (x) {
    is String -> "String of length ${x.length}"  // x smart-cast to String
    is Int -> "Integer: $x"                       // x smart-cast to Int
    is Double -> "Double: $x"                     // x smart-cast to Double
    else -> "Unknown type"
}

// Smart casts also work with && conditions
fun isValidString(x: Any): Boolean =
    x is String && x.length > 0  // x is smart-cast inside the condition

// Compiler tracks null checks across branches
fun greet(name: String?) {
    if (name != null) {
        println(name.uppercase())  // name is String here
    } else {
        println("No name")         // name is null here
    }
}

// Calling a Java method: public String getName()
val name: String = javaObject.getName()        // ⚠ Allowed, but risky!
val safeName: String? = javaObject.getName()  // ✅ Safer — treat as nullable

// Android example: findViewById returns a platform type
val button: Button = findViewById(R.id.btn)       // ⚠ Crashes if view missing
val safeButton: Button? = findViewById(R.id.btn)  // ✅ Safe — check before use

// Best practice: treat platform types as nullable
val text = findViewById<TextView>(R.id.tv)?.text ?: "Default"

val name: String? = "Alex"

// Only runs if name is not null
name?.let { nonNullName ->
    println("Name is $nonNullName")
    println("Length is ${nonNullName.length}")
}

// Inside let, `it` refers to the non-null value
name?.let {
    println("Hello, $it")
}

// Chaining: compute only if all values exist
val result = name?.let { it.uppercase() } ?: "EMPTY"

// API response: list might be null, items might be null
val apiResponse: List<String?>? = fetchTags()

// Safe access: only iterate if list is not null, filter out null items
val validTags = apiResponse?.filterNotNull() ?: emptyList()

// Chaining safe calls on nullable elements
val firstLength = apiResponse?.firstOrNull()?.length  // Int?

// filterNotNull() converts List<String?> to List<String>
val nullableList: List<String?> = listOf("a", null, "c")
val nonNullList: List<String> = nullableList.filterNotNull()

// Map with nullable values
val map: Map<String, String?> = mapOf("key" to null)
val value = map["key"] ?: "missing"

// also — side effects, returns the original object
val person = Person("Alex").also {
    println("Created: $it")
}

// apply — object configuration, returns the original object
val button = Button(context).apply {
    text = "OK"
    setOnClickListener { /* ... */ }
}

// run — transformation + result, needs a receiver
val greeting = person?.run {
    "$name is $age years old"
}

// let — transformation to another type, perfect with nullables
val result = email?.let { sendEmail(it) }

// with — non-null context block
with(person) {
    println(name)
    println(age)
}