Kotlin: bagaimana cara meneruskan fungsi sebagai parameter ke yang lain?

Fungsi yang diberikan foo:

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

Kita bisa:

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

Sekarang, katakanlah kita memiliki fungsi berikut:

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

Apakah ada cara saya bisa meneruskan "buz" sebagai parameter ke "foo"? Sesuatu seperti:

foo("a message", buz)

Gunakan ::untuk menandakan referensi fungsi, dan kemudian:

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)
}

Karena Kotlin 1.1 Anda sekarang dapat menggunakan fungsi yang merupakan anggota kelas (" Bound Callable Referensi "), dengan mengawali awalan operator referensi fungsi dengan instance:

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

foo("hi", thatOtherThing::buz)

foo("hi", this::buz)

Tentang fungsi anggota sebagai parameter:

1. Kelas Kotlin tidak mendukung fungsi anggota statis, sehingga fungsi anggota tidak dapat dipanggil seperti: Operator :: add (5, 4)
2. Oleh karena itu, fungsi anggota tidak dapat digunakan sama dengan fungsi kelas satu.
3. Pendekatan yang berguna adalah membungkus fungsi dengan lambda. Itu tidak elegan tetapi setidaknya itu berfungsi.

kode:

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

gunakan ::untuk metode referensi.

Suka

    foo(::buz) // calling buz here

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

Cukup gunakan "::" sebelum nama metode

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

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

foo(::bar) Output :Hello World

rupanya ini belum didukung.

Info lebih lanjut:

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

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

Jika Anda ingin lulus metode setter dan pengambil .

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

Pemakaian:

private var width: Int = 1

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

Jawaban Jason Minard adalah jawaban yang bagus. Ini juga dapat dicapai dengan menggunakan a lambda.

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

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

Yang bisa disebut dengan foo("a message", buz).

Anda juga dapat membuatnya lebih KERING dengan menggunakan a typealias.

typealias qux = (m: String) -> Unit

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

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

Contoh lain:

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

Fungsi kelas satu saat ini tidak didukung di Kotlin. Ada perdebatan tentang apakah ini akan menjadi fitur yang baik untuk ditambahkan. Saya pribadi berpikir mereka harus.