Kotlin: Bir işlevi diğerine parametre olarak nasıl aktarabilirim?

Foo fonksiyonu verildiğinde:

fun foo(m: String, bar: (m: String) -> Unit) {
    bar(m)
}

Biz yapabiliriz:

foo("a message", { println("this is a message: $it") } )
//or 
foo("a message")  { println("this is a message: $it") }

Şimdi, aşağıdaki işleve sahip olduğumuzu varsayalım:

fun buz(m: String) {
   println("another message: $m")
}

"Buz" u parametre olarak "foo" olarak geçirebilmemin bir yolu var mı? Gibi bir şey:

foo("a message", buz)

::Bir işlev referansını belirtmek için kullanın ve ardından:

fun foo(m: String, bar: (m: String) -> Unit) {
    bar(m)
}

// my function to pass into the other
fun buz(m: String) {
    println("another message: $m")
}

// someone passing buz into foo
fun something() {
    foo("hi", ::buz)
}

Kotlin 1.1'den beri , artık sınıf üyesi olan işlevleri (" Bağlı Çağrılabilir Referanslar "), işlev referans operatörünün önüne örnek ekleyerek kullanabilirsiniz:

foo("hi", OtherClass()::buz)

foo("hi", thatOtherThing::buz)

foo("hi", this::buz)

Üye işlevi hakkında parametre olarak:

1. Kotlin sınıfı statik üye işlevini desteklemez, bu nedenle üye işlevi şu şekilde çağrılamaz: Operator :: add (5, 4)
2. Bu nedenle, üye işlevi Birinci sınıf işlevle aynı şekilde kullanılamaz.
3. Kullanışlı bir yaklaşım, işlevi bir lambda ile sarmalamaktır. Zarif değil ama en azından işe yarıyor.

kod:

class Operator {
    fun add(a: Int, b: Int) = a + b
    fun inc(a: Int) = a + 1
}

fun calc(a: Int, b: Int, opr: (Int, Int) -> Int) = opr(a, b)
fun calc(a: Int, opr: (Int) -> Int) = opr(a)

fun main(args: Array<String>) {
    calc(1, 2, { a, b -> Operator().add(a, b) })
    calc(1, { Operator().inc(it) })
}

Kotlin 1.1

::yöntemi referans almak için kullanın .

sevmek

    foo(::buz) // calling buz here

    fun buz() {
        println("i am called")
    }

Yöntem adından önce "::" kullanın

fun foo(function: () -> (Unit)) {
   function()
}

fun bar() {
    println("Hello World")
}

foo(::bar) Çıktı :Hello World

görünüşe göre bu henüz desteklenmiyor.

Daha fazla bilgi:

http://devnet.jetbrains.com/message/5485180#5485180

http://youtrack.jetbrains.com/issue/KT-1183

Ayarlayıcı ve alıcı yöntemlerini geçmek istiyorsanız .

private fun setData(setValue: (Int) -> Unit, getValue: () -> (Int)) {
    val oldValue = getValue()
    val newValue = oldValue * 2
    setValue(newValue)
}

Kullanımı:

private var width: Int = 1

setData({ width = it }, { width })

Jason Minard'ın cevabı iyi. Bu, bir lambda.

fun foo(m: String, bar: (m: String) -> Unit) {
    bar(m)
}

val buz = { m: String ->
    println("another message: $m")
}

Hangi ile çağrılabilir foo("a message", buz).

Ayrıca, bunu bir typealias.

typealias qux = (m: String) -> Unit

fun foo(m: String, bar: qux) {
    bar(m)
}

val buz: qux = { m ->
    println("another message: $m")
}

Başka bir örnek:

 fun foo(x:Int, Multiply: (Int) -> (Int)) {
    println(Multiply(x))
 }
 fun bar(x:Int):Int{
    return  x * x
 }
 foo(10, ::bar)

Birinci sınıf işlevler şu anda Kotlin'de desteklenmemektedir. Bunun eklenecek iyi bir özellik olup olmayacağı konusunda tartışmalar var. Şahsen yapmaları gerektiğini düşünüyorum.