Recursion 如何在Kotlin中递归使用foldRight实现dropWhile

我一直在使用

.foldRight（）

递归地实现高阶函数，比如

any

，

all

，以及

takeWhile

作为实践，但是

dropWhile

一直是难以捉摸的

\u Collections.kt

具有命令式方式，但我无法将其转换为递归结构

作为参考，这是

takeWhile

fun takeWhile(list:List<Int>, func:(Int) -> Boolean):List<Int> = list.foldRight(emptyList(),
    { next:Int, acc:List<Int> -> if (func(next)) acc.plus(next) else emptyList() })

fun takeWhile（list:list，func：（Int）->Boolean）：list=list.foldRight（emptyList（），
{next:Int，acc:List->if（func（next））acc.plus（next）else emptyList（）}）

首先，让我们概括一下解决方案的想法

使用

foldRight

，您只能从右向左逐个处理项目，并保持累加器

问题是，对于位于位置

i

的项目，

dropWhile

逻辑根据位置

j是否存在项目来决定是否将该项目包括在结果中
... (some unknown items) ... ... ... ... a b c d <--- (right-to-left)
                   predicate satisfied:  T T F T

          (the sequence start) y z a b c d <--- (right-to-left)
         predicate satisfied:  T T T T F T
                               -------
                                 drop

... (some unknown items)  ...  w z a b c d <--- (right-to-left)
         predicate satisfied:  F T T T F T
                               -------
                               include

fun <T> List<T>.myDropWhile(predicate: (T) -> Boolean) =
    foldRight(Pair(emptyList<T>(), emptyList<T>())) { item, (certain, uncertain) ->
        if (predicate(item))
            Pair(certain, uncertain + item) else
            Pair(certain + uncertain + item, emptyList())
    }.first.reversed()

val ints = listOf(0, 0, 0, 1, 0, 2, 3, 0, 0, 4)
println(ints.myDropWhile { it == 0 }) // [1, 0, 2, 3, 0, 0, 4]