具有高阶函数的静态编程语言契约

Question

我有静态编程语言为空的问题，我想知道我是否能够解决它与合同

fun <T, R> Action<T>.map(mapper:(R)->T): Action<R> {
   return Action{ execute(mapper(it)) }
}

和

fun <T> Action<T>.ifNotNull(): Action<T> {
  return Action { if(it != null) execute(it) }
} 

还有一个具有可为空数据的通用模型：

class Model<T>(val data: T?)

现在我创建了一个函数，它以Action接口作为参数。案例是仅当param！=空，因此如下所示：

fun <T> callback(model: Model<T>, action: Action<T>){
    action
    .map{ it.getData() } //compilation error: getData return T? when action require T
    .ifNotNull() //execute only when data!=null
    .execute(model)
}

那么现在，有没有任何选项可以使用Kotlin契约来确保编译器不使用null参数执行操作？

Answer 1

我创建了专门用于此用途的操作接口实现，如下所示：

class ModelAction<T>(val action: Action<T>) : Action<T?> {
    override fun execute(param: T?) {
        param?.let {
            action.execute(it)
        }
    }
}

fun callback<T>(model: Model<T>, action: Action<T>){
    ModelAction(action)
    .map{ it.getData() } 
    .execute(model)
}

这个想法可能会帮助有类似问题的人，但它不符合我的期望，我仍然依赖于基于高阶函数的解决方案。

Answer 2

默认情况下，如果未绑定，则所有类型参数都可以为null（换句话说，它们是从Any？派生的）。解决这个问题的简单方法就是在类型参数上指定非空绑定：

Answer 3

ModelAction在您自己的答案中，只需为ifNotNull（）提供正确的签名：

fun <T> Action<T>.ifNotNull(): Action<T?> {
    return Action { if(it != null) execute(it) }
} 

那么你的操作顺序就错了：

fun <T> callback(model: Model<T>, action: Action<T>){
    action
    .ifNotNull() // Action<T?>
    .map { model: Model<T> -> model.data } // Action<Model<T>>
    .execute(model)
}

请注意，编译器将无法推断此map用法的R。你也可以把它写成

fun <T> modelAction(action: Action<T>): Action<Model<T>> {
    return action
    .ifNotNull()
    .map { it.data }
}

顺便说一下，这个参数是map的错误方法；这样的函数通常被称为矛盾图。