Android 类型推断失败：信息不足，无法推断参数T Kotlin

我使用一个密封类从网络返回数据。但是当我在构建项目时，我得到了以下错误

类型推断失败：没有足够的信息来推断参数T in fun error（errorMessage:String，error:Throwable）：状态 请明确指定它

我错过了什么

这是密码

suspend fun getdataFromApi(context: Context?, token: String?): State<ScheduleReminderListResponse> =
    withContext(schedulerProvider.io)
    {

            try {
                val list = network.getScheduleReminderList(token).await()
                schedeleReminderListLocalDao.insertAll(list)
                return@withContext State.success(list)
            } catch (e: Exception) {
                return@withContext State.error( e.message ?: "Unknown Error",  e  )
            }


        }






sealed class State<T> {

class Loading<T>: State<T>()
data class Error<T>(val errorMessage: String?, val error: Throwable): State<T>()
data class Success<T>(var data: T) : State<T>()

companion object {
    fun <T> loading(): State<T> =
        Loading()

    fun <T> error(errorMessage: String, error: Throwable): State<T> =
        Error(errorMessage, error)

    fun <T> success(data: T): State<T> =
        Success(data)

   }
 }

挂起getdataFromApi（上下文：上下文？，令牌：字符串？）：状态=
withContext（schedulerProvider.io）
{
试一试{
val list=network.getScheduleMemenderList（令牌）.await（）
SchedeleMemenderListLocalDao.insertAll（列表）
return@withContext状态。成功（列表）
}捕获（e：例外）{
return@withContextState.error（e.message？：“未知错误”，e）
}
}
密封类状态{
类加载：State（）
数据类错误（val errorMessage:String？，val Error:Throwable）：状态（）
数据类成功（var数据：T）：State（）
伴星{
乐趣加载（）：状态=
加载（）
有趣的错误（errorMessage:String，error:Throwable）：状态=
错误（错误消息，错误）
有趣的成功（数据：T）：状态=
成功（数据）
}
}

在这一行

状态。错误（e.message？：“未知错误”，e）

编译器不知道

T

应该是什么。如果将其与

success

进行比较，您将看到显式提供了一个

T

参数，编译器使用该参数推断类型。 调用错误时，可以这样指定：

State.error<TYPE_OF_SCHEDULE_REMINDER_LIST>( e.message ?: "Unknown Error",  e  )

---

Error

数据类定义了

T

类型参数，但不以任何方式使用它。因此，当您创建一个

Error

实例时，编译器无法推断T应该使用什么类型

若要解决此问题，请更改

状态

和

错误

的定义，使它们没有类型参数。

如果要将类型参数保留在

状态

模型中（以便返回值美观且类型安全）您可以考虑将代码< > t>代码>作为<代码>出处<代码>，在不使用

的子类中使用<代码> < < /代码> >

sealed class State<out T> {

    object Loading: State<Nothing>()
    data class Error(val errorMessage: String?, val error: Throwable): State<Nothing>()
    data class Success<T>(var data: T): State<T>()

    companion object {
        fun <T> loading(): State<T> = Loading

        fun <T> error(errorMessage: String, error: Throwable): State<T> = Error(errorMessage, error)

        fun <T> success(data: T): State<T> = Success(data)
    }
}

密封类状态{
对象加载：状态（）
数据类错误（val errorMessage:String？，val Error:Throwable）：状态（）
数据类成功（var数据：T）：State（）
伴星{
乐趣加载（）：状态=加载
有趣的错误（errorMessage:String，error:Throwable）：状态=错误（errorMessage，error）
乐趣成功（数据：T）：状态=成功（数据）
}
}

---

这样，示例方法将保持不变，并且您不需要执行不安全的强制转换

作为一个额外的好处，您可以尝试跳过伴随对象，直接使用构造函数

sealed class State<out T> {

    object Loading: State<Nothing>()
    data class Error(val errorMessage: String?, val error: Throwable): State<Nothing>()
    data class Success<T>(var data: T): State<T>()

    companion object {
        fun <T> loading(): State<T> = Loading

        fun <T> error(errorMessage: String, error: Throwable): State<T> = Error(errorMessage, error)

        fun <T> success(data: T): State<T> = Success(data)
    }
}