Kotlin: Используйте лямбда вместо функционального интерфейса?

В Java мы можем это сделать Events.handler(Handshake.class, hs -> out.println(hs));

В Kotlin однако я пытаюсь воспроизвести поведение, чтобы заменить это:

Events.handler(Handshake::class, object : EventHandler<Handshake> {
    override fun handle(event: Handshake) {
        println(event.sent)
    }
})

С более удобным:

Events.handler(Handshake::class, EventHandler<Handshake> { println(it.sent) })

По какой-то причине в отношении EventHandler:

Более предпочтительно, однако, я хотел бы использовать что-то еще более короткое: Events.handler(Handshake::class, { println(it.sent) })

Или используйте рекламируемую функцию, чтобы использовать метод следующим образом: Events.handler(Handshake::class) { println(it.sent) }

Это мой объект Events:

import java.util.*
import kotlin.reflect.KClass

object Events {

    private val map = HashMap<Class<*>, Set<EventHandler<*>>>()

    fun <T : Any> handler(eventType: KClass<T>, handler: EventHandler<T>) {
        handler(eventType.java, handler)
    }

    fun <T> handler(eventType: Class<T>, handler: EventHandler<T>) = handlers(eventType).add(handler)

    fun post(event: Any) = handlers(event.javaClass).forEach { it.handle(event) }

    operator fun plus(event: Any) = post(event)

    private fun <T> handlers(eventType: Class<T>): HashSet<EventHandler<T>> {
        var set = map[eventType]
        if (set == null) {
            set = HashSet<EventHandler<*>>()
            map.put(eventType, set)
        }
        return set as HashSet<EventHandler<T>>
    }

}

И мой интерфейс EventHandler:

@FunctionalInterface
interface EventHandler<T> {

    fun handle(event: T)

}

Ответ 1

Предполагая, что вам действительно нужно EventHandler как отдельный интерфейс (например, для взаимодействия с Java). Если вы этого не сделаете, вы можете просто использовать псевдоним типа (начиная с Kotlin 1.1):

typealias EventHandler<T> = (T) -> Unit

В этом случае простая лямбда будет работать сразу.

Но если вы не хотите использовать псевдоним типа, проблема все же остается. Это то, что Kotlin только SAM-преобразование для функций, определенных в Java. Поскольку Events.handler определяется в Kotlin, SAM-преобразования не применяются к нему.

Чтобы поддержать этот синтаксис:

Events.handler(Handshake::class, EventHandler<Handshake> { println(it.sent) })

Вы можете определить функцию с именем EventHandler:

fun <T> EventHandler(handler: (T) -> Unit): EventHandler<T> 
    = object : EventHandler<T> { 
        override fun handle(event: T) = handler(event) 
    }

Чтобы поддержать этот синтаксис:

Events.handler(Handshake::class, { println(it.sent) })

или это:

Events.handler(Handshake::class) { println(it.sent) }

Вам нужно перегрузить функцию handler, чтобы взять функцию вместо EventHandler:

fun <T> Events.handler(eventType: Class<T>, handler: (T) -> Unit) = EventHandler(handler)

ПРИМЕЧАНИЕ. Если в будущей версии Kotlin есть псевдонимы типов, интерфейс EventHandler не понадобится, потому что он будет заменен именованным псевдонимом на тип (T) -> Unit