如何将复杂的 Java lambda 转换为 Kotlin？答案

【问题标题】：How to convert a complex Java lambda to Kotlin?如何将复杂的 Java lambda 转换为 Kotlin？
【发布时间】：2023-02-10 06:57:46
【问题描述】：

我正在尝试将以下 Java 代码转换为 Kotlin（为了便于阅读，省略了接口实现）：

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

这包含一个非常紧凑的 lambda 表达式，我想将其转换为 Kotlin（有关 Java lambda 的可读性更高的替代方案，请参阅 [1]）。我当前的解决方案保留了interfaces，但这似乎导致了一个相当复杂的调用（比较validate-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
    }
}

问题: 当保持 interfaces 不变时，是否有一些更有效的 validate-call？

跟进问题：逻辑需要使用可配置提取（Extractor）的复杂check方法进行可配置验证（Validator）。什么是更惯用的设计？

[1] 紧凑的 lambda 对应于以下更具可读性的代码：

    public static void main(String[] args) {
        validate("some text", extractor -> {
            return s -> {
                return check(s, extractor);
            };
        });
    }

【问题讨论】：

标签： kotlin lambda

【解决方案1】：

Function 已经可以转换为 lambda。接下来，将Extractor 和Validator 声明为fun interface。那么代码最终可以重写为：

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

【讨论】：