Kotlin扩展函数：Any?与泛型T?的区别及适用疑问

Great question! At first glance, these two extension functions might seem identical because they both check for nullity, but there are important differences that matter once you start adding more complex logic (like your when statement branches based on type). Let’s break them down:

1. Type Information Preservation #

This is the biggest one for your use case.

• When you use fun Any?.foo(), the static type of this inside the function is Any?. Even if you call this function on a String? or Int?, inside foo(), Kotlin only knows this is some nullable Any—it doesn't retain the original concrete type.
• With fun <T> T?.foo(), the type parameter T is inferred from the caller. So if you call myString?.foo(), T becomes String, and this inside the function is String?. This means Kotlin keeps track of the original type, which is crucial for when statements or any logic that depends on the concrete type.

Example: When Statement Logic #

For the generic version:

fun <T> T?.process() {
    when (this) {
        is String -> println("String length: ${this.length}") // No cast needed—smart cast to String
        is Int -> println("Int doubled: ${this * 2}") // Smart cast to Int
        null -> println("Null value")
        else -> println("Unknown type")
    }
}

Calling "hello".process() works seamlessly, because Kotlin knows this is a String in that branch.

For the Any? version:

fun Any?.process() {
    when (this) {
        is String -> println("String length: ${this.length}") // This still works via smart cast, but...
        is Int -> println("Int doubled: ${this * 2}") // ...if you wanted to return a value of the original type, you'd hit issues
        null -> println("Null value")
        else -> println("Unknown type")
    }
}

If you tried to modify this function to return the processed value:

// Any? version returns Any?, losing type info
fun Any?.process(): Any? {
    return when (this) {
        is String -> this.uppercase()
        is Int -> this * 2
        else -> this
    }
}

// Usage:
val str: String? = "hello"
val result = str.process() // result is Any?—you can't call String methods without casting

Whereas the generic version preserves the type:

fun <T> T?.process(): T? {
    return when (this) {
        is String -> this.uppercase() as T // Cast is safe here because T is String
        is Int -> (this * 2) as T
        else -> this
    }
}

// Usage:
val str: String? = "hello"
val result = str.process() // result is String?—you can call String methods directly

2. Flexibility for Future Changes #

The generic version is more adaptable if you later need to add type constraints. For example, if you decide foo() should only work with types that implement a specific interface:

interface Printable {
    fun print()
}

// Generic version can add a constraint easily
fun <T : Printable> T?.foo() {
    this?.print() // Access Printable methods safely
}

You can't do this with the Any?.foo() version, since Any doesn't implement Printable—you'd have to add a cast or rewrite the function entirely.

3. Return Type Precision #

As shown in the earlier example, the generic function returns T?, which matches the type of the caller. The Any? version always returns Any?, forcing callers to cast if they want to work with the original type. This adds unnecessary boilerplate and can introduce casting errors.

4. Overload Resolution #

If you ever add overloaded versions of foo() for specific types, the generic version has clearer resolution behavior. For example:

fun String?.foo() = println("String-specific foo")
fun <T> T?.foo() = println("Generic foo")

"test".foo() // Calls the String-specific overload
42.foo() // Calls the generic overload

With the Any?.foo() version, the overload resolution might be less predictable, since Any? is a supertype of all nullable types—you might end up with the Any? version being called when you intended a specific overload.

For your use case where you need to handle different types in a when statement, the generic fun <T> T?.foo() version is the better choice. It preserves type information, avoids casting, and gives you more flexibility for future changes. The Any?.foo() version is only useful if you truly don't care about the original type and just need to handle nullity or operations that work on all Any instances.

内容的提问来源于stack exchange，提问作者Gioooschi