Kotlin: ¿cómo pasar una función como parámetro a otra?

Dada la función foo:

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

Podemos hacer:

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

Ahora, digamos que tenemos la siguiente función:

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

¿Hay alguna manera de pasar "buz" como parámetro a "foo"? Algo como:

foo("a message", buz)

Use ::para significar una referencia de función, y luego:

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

Desde Kotlin 1.1 ahora puede usar funciones que son miembros de la clase (" Referencias invocables enlazadas "), al prefijar el operador de referencia de función con la instancia:

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

foo("hi", thatOtherThing::buz)

foo("hi", this::buz)

Sobre la función miembro como parámetro:

1. La clase Kotlin no admite la función miembro estática, por lo que la función miembro no se puede invocar como: Operator :: add (5, 4)
2. Por lo tanto, la función miembro no se puede usar igual que la función de Primera clase.
3. Un enfoque útil es envolver la función con una lambda. No es elegante, pero al menos está funcionando.

código:

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

utilizar ::como método de referencia.

me gusta

    foo(::buz) // calling buz here

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

Simplemente use "::" antes del nombre del método

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

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

foo(::bar) Salida :Hello World

aparentemente esto aún no es compatible.

más información:

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

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

Si desea pasar los métodos setter y getter .

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

Uso:

private var width: Int = 1

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

La respuesta de Jason Minard es buena. Esto también podría lograrse usando a lambda.

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

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

Que se puede llamar con foo("a message", buz).

También puedes hacer esto un poco más SECO usando a typealias.

typealias qux = (m: String) -> Unit

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

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

Otro ejemplo:

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

Las funciones de primera clase actualmente no son compatibles con Kotlin. Se ha debatido si esta sería una buena característica para agregar. Personalmente creo que deberían hacerlo.