Smart casts, is checks and safe casts

A booking request arrives as JSON and is read into a Map<String, Any?>. The seats field should be an Int and the PNR a String, but every value has the type Any?, and the compiler will not even add 1 to an Any?. An is check asks what a value really is while the program runs, and after it the compiler treats the value as that type, with no cast written.

You will check types with is and !is and rely on the smart casts that follow. You will convert values with as?, which gives null where a plain cast would throw, and see where the compiler refuses a smart cast and why it is right to.

An is check tells the compiler the type, and the cast is done for you

value is Int is true when the value is an Int while the program runs, and value !is Int is its opposite. null is not an instance of any class, so a check against a non-null type such as is Int is false for it, while a nullable type such as String? includes it, as the last line of the program below shows. Beyond answering a question, is checks change what the compiler knows. In the code that runs only when a check was true, the compiler treats the value as the checked type: a smart castsmart cast: The compiler's own cast: after a check such as x != null or x is String, it treats x as the checked type wherever the check still holds, with no cast written.. Smart casts are why the branches below read value + 1 and value.length without a cast:

// A booking request read from JSON: every field arrives as Any?, whatever it holds.
fun describe(value: Any?): String = when (value) {
    null -> "missing"
    is Int -> "an Int; plus one is ${value + 1}"
    is String -> "a String of ${value.length} characters"
    is List<*> -> "a list of ${value.size} items"
    else -> "a ${value::class.simpleName}, not handled"
}

fun main() {
    val request: Map<String, Any?> = mapOf(
        "seats" to 2,
        "pnr" to "8240117365",
        "legs" to listOf("NDLS-AGC", "AGC-BPL"),
        "fare" to 1250.5,
        "coupon" to null,
    )
    for ((field, value) in request) {
        println("$field: ${describe(value)}")
    }
    // null is no instance of a class, but a nullable type includes it.
    val coupon = request["coupon"]
    println("coupon is String: ${coupon is String}, coupon is String?: ${coupon is String?}")
}

seats: an Int; plus one is 3
pnr: a String of 10 characters
legs: a list of 2 items
fare: a Double, not handled
coupon: missing
coupon is String: false, coupon is String?: true

Each branch of the when sees value as the type it checked: an Int to add to, a String with a length, a list with a size. List<*> checks only that the value is a list, because the types of its items are not kept while the program runs, so a check cannot ask for a list of strings. In the else branch value is an Any, since null was handled first.

The same works after an early return and on the right of &&. Step through farePaise for three of the values the program below passes it, and watch what the compiler knows after each check:

// The type the compiler knows for value changes after each check.
fun farePaise(value: Any?): Long {
    if (value == null) return 0
    // From here on, value is an Any: null has been ruled out.
    if (value is String) return value.toLong() * 100
    if (value !is Int) return -1
    // From here on, value is an Int.
    return value * 100L
}

// On the right of &&, the check on its left still holds.
fun isPnr(value: Any?): Boolean = value is String && value.length == 10 && value.all { it.isDigit() }

fun main() {
    for (value in listOf(null, "450", 300, 4.5)) {
        val type = value?.let { it::class.simpleName } ?: "null"
        println("$value ($type) -> ${farePaise(value)} paise")
    }
    for (value in listOf<Any>("8240117365", 8240117365L, "82401")) {
        println("isPnr(${value::class.simpleName} $value) = ${isPnr(value)}")
    }
}

null (null) -> 0 paise
450 (String) -> 45000 paise
300 (Int) -> 30000 paise
4.5 (Double) -> -1 paise
isPnr(String 8240117365) = true
isPnr(Long 8240117365) = false
isPnr(String 82401) = false

After if (value !is Int) return -1, the rest of the function can only run with an Int, so value * 100L needs no cast. In isPnr, the right side of && runs only when value is String was true, so value.length compiles there.

as? converts a value or gives null, and as throws

A cast states the type a value should have. value as Int gives the value as an Int or throws a ClassCastException, while value as? Int is a safe castsafe cast: A cast written with as?: x as? T gives x as a T when it is one, and null otherwise, instead of throwing a ClassCastException., which gives null instead of throwing. Safe casts pair naturally with the Elvis operator:

// as? converts a value to a type or gives null; as converts it or throws.
fun main() {
    val request: Map<String, Any?> = mapOf("seats" to "2", "pnr" to "8240117365", "coupon" to null)

    // "2" is a String, not an Int, so as? gives null and the Elvis operator supplies 1.
    val seats = request["seats"] as? Int ?: 1
    println("seats: $seats")

    val pnr = request["pnr"] as? String
    println("pnr: $pnr, ${pnr?.length} characters")

    println("coupon: ${request["coupon"] as? String}")

    try {
        val strict = request["seats"] as Int
        println("strict seats: $strict")
    } catch (e: ClassCastException) {
        println("as Int threw ${e::class.simpleName}: ${e.message}")
    }
}

seats: 1
pnr: 8240117365, 10 characters
coupon: null
as Int threw ClassCastException: class java.lang.String cannot be cast to class java.lang.Integer (java.lang.String and java.lang.Integer are in module java.base of loader 'bootstrap')

The seats field holds the text “2”, not the number 2, so as? Int gives null and the fallback, 1, is used: a cast checks the type and never parses text, which is the job of toIntOrNull(). The last line shows what as does with the same field. It throws, and its message names both classes but not the field.

Use is checks in a when when each type needs its own handling, as in describe, and safe casts with ?: when one type is expected and anything else gets a fallback. Keep as for places where another type can only be a bug. require and check stop a function with an exception when a condition fails, and the compiler smart-casts after them; error throws every time it runs, for a branch that should never run.

When the compiler refuses a smart cast, reproduced and fixed Pro: opens with a Pro, Premium or Ultimate pass

Failing fast with as, require, check and error, measured Pro: opens with a Pro, Premium or Ultimate pass

Practise: describe any value

This program checks a function that describes a value of any type. As given, three of its six checks fail:

// Practice: fix describe so that all six checks pass. Use a when with is checks; anything else is "unknown".
fun describe(value: Any?): String = when (value) {
    is Int -> "Int $value"
    is String -> "String of length ${value.length}"
    else -> "unknown"
}

fun main() {
    val checks = listOf(
        Triple("7", 7, "Int 7"),
        Triple("7L", 7L, "Long 7"),
        Triple("\"abc\"", "abc", "String of length 3"),
        Triple("listOf(1, 2)", listOf(1, 2), "List of size 2"),
        Triple("null", null, "null"),
        Triple("4.5", 4.5, "unknown"),
    )
    var passed = 0
    for ((shown, value, want) in checks) {
        val got = describe(value)
        val ok = got == want
        if (ok) passed++
        println("${if (ok) "ok  " else "FAIL"} describe($shown) = $got, want $want")
    }
    println("$passed of ${checks.size} checks pass")
    if (passed < checks.size) kotlin.system.exitProcess(1)
}

ok   describe(7) = Int 7, want Int 7
FAIL describe(7L) = unknown, want Long 7
ok   describe("abc") = String of length 3, want String of length 3
FAIL describe(listOf(1, 2)) = unknown, want List of size 2
FAIL describe(null) = unknown, want null
ok   describe(4.5) = unknown, want unknown
3 of 6 checks pass

Copy it, add the branches that describe is missing, and run it with kotlinc Describe.kt -include-runtime -d describe.jar && java -jar describe.jar until all six checks pass. First hint: a Long is not an Int, a list is matched by is List<*>, and null can be a branch of its own.

The questions below cover the two ideas of the first two sections, the one you know least first:

Interview questions

Key takeaways

• value is T checks the type while the program runs and !is is its opposite; for null, a check against a non-null type is false.
• After a check that was true, the compiler smart-casts the value to the checked type in the branch, after an early return and on the right of &&.
• value as? T gives null for any other type and pairs with ?:, while value as T throws a ClassCastException; neither one parses text.