在 Kotlin 中链接对象的更简单或更实用的方法

Question

我创建了一个辅助方法buildChain，它本质上创建了一个 对象链，因为它们实现了接口IChain<T> 并设置合约next成员

守则

interface Chain<T> {
    var next: T?

    operator fun plus(next: T): T?
}

fun <T : Chain<T>> buildChain(first: T, vararg members: T): T {
    var next: T? = null
    members.forEachIndexed { i, t ->
        if (i == 0) {
            next = first + t
        } else {
            next = next?.run { this + t }
        }
    }
    return first
}

实现示例

data class Person(val name: String) : Chain<Person> {
    override var next: Person? = null

    override fun plus(next: Person): Person? {
        this.next = next
        return next
    }
}

fun createPersonChain()
        = buildChain(Person("Bob"), Person("Bitzy"), Person("Blitzy"))

实现输出示例

@JvmStatic fun main(args: Array<String>) {
    var first = createPersonChain()
    // first.name = "Bob"
    // first.next.name = "Bitzy"
    // first.next.next.name = "Blitzy"
 }

是否有functional 或simpler 方式来实现上述code 并保持实现使用相同？

Answer 1

函数idiom fold 非常适合您的需求：它接受一个初始项目，然后迭代其他项目，保持一个累积值，该值会在使用您提供的函数处理的每个项目上更新。

在 Kotlin 中，Iterable、Sequence 或 Array 是 fold extension function。

您可以通过以下方式使用它：

fun <T : Chain<T>> buildChain(first: T, vararg members: T): T {
    members.fold(first as T?) { acc, i -> acc?.let { it + i } }
    return first
}

这里需要first as T? 强制转换才能将累加器类型推断为可空T?，因为plus 中的Chain<T> 返回可空值（顺便说一句，有必要吗？）。

你也可以使用foldRight，它只是以相反的顺序迭代：

fun <T : Chain<T>> buildChain(first: T, vararg members: T): T? =
        (listOf(first) + members)
            .foldRight(null as T?) { i, acc -> acc?.let { i + acc }; i }

还有 reduce 和 reduceRight 语义相似，但分别使用第一项和最后一项作为累加器的初始值。这是reduceRight 的示例：

fun <T : Chain<T>> buildChain(first: T, vararg members: T): T? =
        (listOf(first) + members).reduceRight { i, acc -> i.apply { plus(acc) } }

Answer 2

试试apply{}。在{} 块中传递你的方法，用';'分隔

Object().apply{ method1(); signUp(user) }