Given these 2 Apache Camel (Java) interfaces

package org.apache.camel;

public interface Predicate {
    boolean matches(Exchange exchange);
}

public interface Expression {
    <T> T evaluate(Exchange exchange, Class<T> type);
}

Kotlin accepts following property declaration

val somePredicate = Predicate { exchange -> true}

For the

Expression

interface however, Koltin does not accept a similar construct. I must explicitly declare an object and implement the interface method like this:

val someExpression   = object : Expression {
        override fun <T : Any?> evaluate(exchange: Exchange?, type: Class<T>?): T {
            TODO("Not yet implemented")
        }
    }

I fail to understand why however?

the lambda form can't be parameterized over all

<T>

if you convert

Expression

to Kotlin and try making it a functional interface you’ll get a more specific error message

Single abstract member cannot declare type parameters

Thanks for that @ephemient and @Adam S 👍

Hmm I’m not sure if there’s a specific name given https://kotlinlang.org/docs/fun-interfaces.html#sam-conversions

Would a

@FunctionalInterface

annotation on

Predicate

change anything wrt

Predicate

!=

(Exchange) -> Boolean

?

I think not, but give it a go. Explicitly typing

Predicate {}

can be skipped if it’s a function parameter https://kotlinlang.org/docs/java-interop.html#sam-conversions What you could do is write your own implementation of

Predicate

using a typealias

typealias Predicate2 = (Exchange) -> Boolean

And then write extension functions for all Apache Camel methods that accept a

Predicate

to convert from

Predicate2

to

Predicate

, but that sounds like a lot of work for not much gain…

Thanks @Adam S

it would probably be less work to write

fun someKotlinFunction(predicate: (Exchange) -> Boolean) {
    someJavaCamelFunction(..., { predicate(it) }, ...)

or a converter (doesn't save all that much here, but may be more convenient when there are more parameters)

inline fun Predicate(crossinline predicate: (Exchange) -> Boolean): Predicate = Predicate { predicate(it) }

fun someKotlinFunction(predicate: (Exchange) -> Boolean) {
    someJavaCamelFunction(Predicate(predicate))

than to wrap every function that takes a

Predicate

@ephemient apparently there was a change in 1.6.20? https://kotlinlang.org/docs/fun-interfaces.html#migration-from-an-interface-with-constructor-function-to-a-functional-interface not sure if it’s related but it looks similar?