Kotlin 将类型强制转换为其各自的不可为null的类型

我有一个类似这样的扩展函数：

inline fun <A, B, C> Pair<A, B>.notNull(code: (A, B) -> C) {
    if (this.first != null && this.second != null) {
        code(this.first, this.second)
    }
}

问题是，user和password类型仍然是可为null的形式，因此我仍然需要使用

？。

调用user和pass，即使user和pass不是null

如何将其转换为各自的不可为null的类型

可能是这样的，但对于通用：

inline fun <C> Pair<Editable?, Editable?>.notNull(code: (Editable, Editable) -> C) {
    if (this.first != null && this.second != null) {
        code(this.first!!, this.second!!)
    }
}

inline fun Pair.notNull（代码：（可编辑，可编辑）->C）{
if（this.first！=null&&this.second！=null）{
代码（this.first！！，this.second！！）
}
}

我认为这会奏效

inline fun <A: Any, B: Any, C> Pair<A?, B?>.notNull(code: (A, B) -> C) {
    if (this.first != null && this.second != null) {
        code(this.first!!, this.second!!)
    }
}

---

inline fun
我认为这会奏效

inline fun <A: Any, B: Any, C> Pair<A?, B?>.notNull(code: (A, B) -> C) {
    if (this.first != null && this.second != null) {
        code(this.first!!, this.second!!)
    }
}

inline fun
一般答案：

如果声明泛型类或函数，则它们可以在替换其类型参数时包含nullable：

例如：

class Help<T>{
 fun printHelp(message :T){
     message?.render();
 }
}

类帮助{
趣味打印帮助（消息：T）{
消息？.render（）；
}
}

所以在这种情况下，尽管T没有标记为T，消息还是可以为空的？
因此，为了避免传递可为null的参数类型，并确保始终替换非null类型，您可以将其更改为：

class Help<T : Any>{
 fun printHelp(message :T){
     message.render();
 }
}

类帮助{
趣味打印帮助（消息：T）{
message.render（）；
}
}
一般回答：

如果声明泛型类或函数，则它们可以在替换其类型参数时包含nullable：

例如：

class Help<T>{
 fun printHelp(message :T){
     message?.render();
 }
}

类帮助{
趣味打印帮助（消息：T）{
消息？.render（）；
}
}

所以在这种情况下，尽管T没有标记为T，消息还是可以为空的？
因此，为了避免传递可为null的参数类型，并确保始终替换非null类型，您可以将其更改为：

class Help<T : Any>{
 fun printHelp(message :T){
     message.render();
 }
}

类帮助{
趣味打印帮助（消息：T）{
message.render（）；
}
}
在这种情况下，智能转换不起作用，因为您正在访问另一个模块中声明的类的属性。如果您将属性值存储在局部变量中，则它将起作用：

inline fun <A : Any, B : Any, C> Pair<A?, B?>.notNull(code: (A, B) -> C) {
    val first = this.first
    val second = this.second
    if (first != null && second != null) {
        code(first, second)
    }
}

inline fun Pair.notNull（代码：（A，B）->C）{
val first=这个
val second=this.second
if（第一个！=null&&second！=null）{
代码（第一，第二）
}
}
在这种情况下，智能转换不起作用，因为您正在访问另一个模块中声明的类的属性。如果您将属性值存储在局部变量中，则它将起作用：

inline fun <A : Any, B : Any, C> Pair<A?, B?>.notNull(code: (A, B) -> C) {
    val first = this.first
    val second = this.second
    if (first != null && second != null) {
        code(first, second)
    }
}

inline fun Pair.notNull（代码：（A，B）->C）{
val first=这个
val second=this.second
if（第一个！=null&&second！=null）{
代码（第一，第二）
}
}
这确实有效，但这与OP的原始示例没有什么不同，因为它使用了！！应该尽可能避免，而且在这种情况下绝对可以避免使用它。这确实有效，但这与OP的原始示例没有什么不同，因为它使用了！！应该尽可能避免，在这种情况下绝对可以避免使用它。