How to convert a complex Java lambda to Kotlin? - kotlin

Question

I'm trying to convert following Java code to Kotlin (interface implementations omitted for readability):
public class Test {
public static void main(String[] args) {
validate("some text", extractor -> s -> check(s, extractor));
}
private static void validate(String s, Function<Extractor, Validator> factory) {
final Extractor extractor = all -> all; // use some more meaningful extractor here
factory.apply(extractor).validate(s);
}
private static boolean check(String s, Extractor extractor) {
return s.equals(extractor.extract(s));
}
interface Extractor {
String extract(String all);
}
interface Validator {
boolean validate(String s);
}
}
This contains a very compact lambda-expression which I would like to translate to Kotlin (for a slightly more readable alternative of the Java lambda, see [1]). My current solution keeps the interfaces, but this seems to result in a rather complex call (compare validate-invocations in main):
object Test {
fun main(args: Array<String>) {
validate("test", object : Function<Extractor, Validator> {
override fun apply(extractor: Extractor): Validator {
return object : Validator {
override fun validate(s: String): Boolean {
return check(s, extractor)
}
}
}
})
}
private fun validate(s: String, factory: Function<Extractor, Validator>) {
val extractor : Extractor = object : Extractor { // use some more meaningful extractor here
override fun extract(all: String): String {
return all
}
}
factory.apply(extractor).validate(s)
}
private fun check(s: String, extractor: Extractor): Boolean {
return s == extractor.extract(s)
}
internal interface Extractor {
fun extract(all: String): String
}
internal interface Validator {
fun validate(s: String): Boolean
}
}
Question: when keeping the interfaces as is, is there some more efficient validate-call?
Follow-up question: the logic requires a configurable validation (Validator) with complex check-methods using configurable extraction (Extractor). What would be a more idiomatic design?
[1] The compact lambda corresponds to following more readable code:
public static void main(String[] args) {
validate("some text", extractor -> {
return s -> {
return check(s, extractor);
};
});
}

Answer 1

Function can already be converted to a lambda. Next, declare Extractor and Validator as fun interface. Then code can finally be rewritten as:
object Test {
fun main(args: Array<String>) {
validate("test") { extractor -> Validator { s -> check(s, extractor) } }
}
private fun validate(s: String, factory: Function<Extractor, Validator>) {
val extractor = Extractor { all -> all } // use some more meaningful extractor here
factory.apply(extractor).validate(s)
}
private fun check(s: String, extractor: Extractor): Boolean {
return s == extractor.extract(s)
}
internal fun interface Extractor {
fun extract(all: String): String
}
internal fun interface Validator {
fun validate(s: String): Boolean
}
}