Quais são os perigos ao passar uma lambda de Java…

Ao passar uma lambda do Java para um método em Kotlin:

Conversão SAM: A lambda em Java deve corresponder a uma interface funcional (interface com um único método abstrato) para que a conversão automática para um tipo funcional em Kotlin ocorra. Se a lambda não corresponder a essa interface, a conversão automática não acontecerá, sendo necessário um ajuste manual ou um wrapper.
Tipo Nullable: O tipo funcional em Kotlin obtido a partir do Java, por padrão, não é nullable (() -> Unit). Se o método em Kotlin espera um tipo nullable (() -> Unit)?), pode ser necessário especificar explicitamente o tipo nullable ao chamar a partir do Java.
Exceções: As exceções que podem ser lançadas pelo código dentro da lambda em Java não são tratadas automaticamente em Kotlin. O código em Kotlin deve tratar explicitamente essas exceções usando try-catch.
Desempenho: Embora a conversão SAM seja geralmente eficiente, em alguns casos a criação excessiva de objetos envoltórios para lambdas pode afetar levemente o desempenho.
Compatibilidade de versões: As características de interação entre Kotlin e Java podem mudar entre versões dos compiladores, podendo requerer atenção ao atualizar.

Exemplo:

// Código Java
interface MyFunctionalInterface {
    void doSomething();
}

class JavaConsumer {
    public void consume(MyFunctionalInterface callback) {
        callback.doSomething();
    }
}

// Código Kotlin
class KotlinUser {
    fun useConsumer(consumer: JavaConsumer) {
        // Conversão automática de SAM da lambda Java para tipo funcional em Kotlin
        consumer.consume { println("Fazendo algo do Kotlin") }

        // Exemplo onde um tipo nullable pode ser necessário na função Kotlin,
        // se o método Java puder aceitar null
        // fun consumeNullable(callback: (() -> Unit)?) { ... }
    }
}

Quais são os perigos ao passar uma lambda de Java para um método em Kotlin?