在Kotlin中，如何链接任意数量的函数

在Kotlin中，如何将任意数量的映射函数应用于给定的输入，并将每个映射函数的输出作为输入传递给下一个函数

e、 g

import org.junit.Test
导入org.testng.Assert
类测试{
@试验
有趣的测试（）{
//给定一个包含2项的列表，所有字段值均为零
val项目=列表（项目（0,0），项目（0,0））
//和一个递增字段1的函数
val itemProcessor1：（Item）->Item={Item->Item.copy（field1=Item.field1.inc（））}
//和一个递增字段2的函数
val itemProcessor2：（Item）->Item={Item->Item.copy（field2=Item.field2.inc（））}
//什么时候
val actual=applyProcessors（项目，列表（项目处理器1，项目处理器2））
//然后我们希望所有字段都递增
val预期=列表（项目（1，1），项目（1，1））
Assert.assertEquals（预期、实际）
}
private fun applyProcessors（项目：列表，项目处理器：列表项目>）：列表{
//？？如何组合itemProcessor功能列表，以便将每个处理过的项目传递给下一个处理器？
return items.map{it}
}
}
数据类项（val字段1:Int，val字段2:Int）

通过处理器的简单循环可以：

private fun applyProcessors(items: List<Item>, itemProcessors: List<(Item) -> Item>): List<Item> {
    return items.map {
        var value = it
        for (processor in itemProcessors) {
            value = processor.invoke(value)
        }
        value
    }
}

private-fun应用程序处理器（项目：列表，项目处理器：列表项目>）：列表{
返回items.map{
var值=它
for（项目处理器中的处理器）{
value=processor.invoke（值）
}
价值
}
}

您可以通过以下功能实现：

fun应用处理器（项目：列表，项目处理器：列表项目>）：列表{
返回items.map{
折叠（it）{acc，processor->processor（acc）}
}
}

private fun applyProcessors(items: List<Item>, itemProcessors: List<(Item) -> Item>): List<Item> {
    return items.map {
        var value = it
        for (processor in itemProcessors) {
            value = processor.invoke(value)
        }
        value
    }
}

fun applyProcessors(items: List<Item>, itemProcessors: List<(Item) -> Item>): List<Item> {
    return items.map {
        itemProcessors.fold(it) { acc, processor -> processor(acc) }
    }
}