Kotlin-高阶函数和类型不匹配

Question

Im just beginning to learn kotlin and am struggling to understand how the higher-order functions determine types, i am regularly seeing this kind of error

Error: Type mismatch: inferred type is KFunction2 but (String) -> Unit was expected

The above error is caused by the following

class MyClass(private val valueChangeListener: MyValueChangeListener, public val storage: MyStorage): MySuperClass {

    fun saveValue(potentialValue: String) {
        super.processValue(potentialValue, MyClass::save)
    }

    fun save(value: String){

        storage.storeValue(value)
        valueChangeListener.onValueChanged(value)
    }
}

However if i use a Lambda all is solved

class MyClass(private val valueChangeListener: MyValueChangeListener, public val storage: MyStorage): MySuperClass {

    fun saveValue(potentialValue: String) {
        super.processValue(potentialValue, super.processValue(potentialValue, { value: String ->
            save(value)
        })
    }

    fun save(value: String){

        storage.storeValue(value)
        valueChangeListener.onValueChanged(value)
    }
}

MySuperClass

open class MySuperClass {

    private fun cleanseValue(value: String) : String {
        return value.toUpperCase().replace(" ", "").replace("-", "")
    }

    protected fun processValue(potentialValue: String, saveFunction: (String) -> Unit){
        saveFunction(cleanseValue(potentialValue))
    }
}

Answer 1

MyClass::save is a KFunction2 , meaning it has two parameters. This is because this expression refers to the method of the class instead of referring to a method of the current instance that you have. This means that when you're calling it, you have to pass in a MyClass instance to call it on, as well as the String parameter. This makes it a (MyClass, String) -> Unit function, which causes the type mismatch.

For example, this is how you could call it:

class MyClass {

    fun test() {
        val s = MyClass::save
        s(this, "some value")
    }

    fun save(value: String) {
        // ...
    }

}

As for what you're looking for, Kotlin 1.1 introduced bound callable references , which you can use to refer to a function of a specific instance of a class:

class MyClass(private val valueChangeListener: MyValueChangeListener, public val storage: MyStorage): MySuperClass() {

    fun saveValue(potentialValue: String) {
        super.processValue(potentialValue, this::save) // see here
    }

    fun save(value: String){
        storage.storeValue(value)
        valueChangeListener.onValueChanged(value)
    }

}

Answer 2

In Kotlin 1.1, you can use member reference to solve this problem:

fun saveValue(potentialValue: String) {
    super.processValue(potentialValue, this::save)
}

If you use Kotlin 1.0.X, use lambda:

fun saveValue(potentialValue: String) {
    super.processValue(potentialValue, (arg) -> save(arg))
}