Kotlin: Cannot Use Nullable Value with `is`

Kotlin, known for its concise syntax and powerful features, occasionally presents challenges to developers coming from other programming languages. One such instance occurs when dealing with nullable types and the is keyword. If you've encountered the error message 'Cannot use nullable value with is,' this article is for you. We'll dive into nullable types in Kotlin and explore why this error occurs, along with how to resolve it.

Understanding Nullable Types in Kotlin

In Kotlin, nullability is explicitly handled, which significantly reduces NullPointerExceptions during runtime. By default, variables cannot hold null values, which enforces a clear distinction between nullable and non-nullable types.

// Non-nullable type
var name: String = "Kotlin" 
// Nullable type
var nullableName: String? = null

The question mark (?) indicates that nullableName is a nullable type and can hold a null value. Kotlin's type system natively supports this optionality, but it also requires developers to handle nullability either through safe calls, the Elvis operator, or explicit checks.

Using the is Keyword

The is keyword is often used in Kotlin for type checking and type casting, particularly in scenarios where you want to safely work with variables without risking a class cast exception. The problem arises when attempting to use is on a nullable type.

fun checkType(input: Any?) {
    if (input is String) {
        println("Input is a String")
    }
}

In the above example, if input is intended to be nullable, Kotlin will not allow the check without first confirming the value is non-null. Attempting to directly use is on a nullable value leads to compilation errors due to Kotlin's non-null enforcement.

Resolving 'Cannot Use Nullable Value with is'

To address this issue, you can perform a null check before using the is keyword, ensuring that the compiler recognizes the non-nullability constraint has been satisfied.

fun checkNullableType(input: Any?) {
    if (input != null && input is String) {
        println("Input is a String")
    } else {
        println("Input is null or not a String")
    }
}

This improved version first checks if input is non-null, safely utilizing the is keyword. Alternatively, Kotlin’s safe call operator (?.) and the Elvis operator (?:) can be combined to manage nullability, but these do not directly work with the is keyword for type checking.

Advanced Use Case: Safe Casting

For scenarios where a nullable variable needs to be cast with the option of a null result, Kotlin offers the as? safe casting operator, which returns null if the cast cannot be performed.

fun safeCastExample(input: Any?) {
    val result = input as? String 
    println(result ?: "Not a string")
}

This approach leverages as? to attempt casting without additional checks, preserving nullability without the risk of an exception, and allowing the logical flow to be straightforward even when the value is nullable.

Conclusion

Handling the 'Cannot use nullable value with is' compilation error generally requires ensuring non-nullability before type checking. By utilizing Kotlin's type system, you can write safe, efficient, and error-free code. Whether using a null check, a safe cast, or handling nullability in a more structured way further in the execution path, understanding these tools enables Kotlin developers to deal extensively with nullable types without encountering common run-time exceptions found in other languages.