Kotlin 函数编程递归实现的列表过滤器函数

任务是关于Kotlin中的函数编程，给出了一个密封列表类，我们的任务是递归地实现map、fold、replaceif、filter和any。到目前为止，我已经实现了除过滤器之外的每一个函数，但是我非常接近，我只是缺少了一些东西

给定列表类：

   sealed class List<T> {

    class Node<T>(val head: T, val tail: List<T>) : List<T>() {
        override fun toString() =
            "${head.toString()} , ${tail.toString()}"
    }

    object Nil : List<Nothing>() {
        override fun toString() = "NIL"
    }

    companion object {
        operator
        fun <T> invoke(vararg values: T): List<T> {
            val empty = Nil as List<T>
            val res = values.foldRight(empty, { v, l -> l.addFirst(v) })
            return res
        }
    }

    fun addFirst(head: T): List<T> = Node(head, this)

    fun removeFirst(): List<T> = when (this) {
        is Nil -> throw IllegalStateException()
        is Node<T> -> this.tail
    }
}

密封类列表{
类节点（val head:T，val tail:List）：List（）{
重写funtostring（）=
${head.toString（）}，${tail.toString（）}
}
对象Nil:List（）{
重写fun toString（）=“NIL”
}
伴星{
操作人员
乐趣调用（vararg值：T）：列表{
val empty=Nil as List
val res=values.foldRight（空，{v，l->l.addFirst（v）}）
返回res
}
}
fun addFirst（head:T）：List=Node（head，this）
fun removeFirst（）：List=when（此）{
是Nil->throw非法状态异常（）
是Node->this.tail吗
}
}

我的map和replaceif实现：

fun <T, R> map(list: List<T>, f: (T) -> R): List<R> = when (list) {
    is List.Nil -> List.Nil as List<R>
    is List.Node -> List.Node(f(list.head), map(list.tail, f))
}

fun <T> replaceIf (list : List<T> , f : (T)-> T , p : (T)-> Boolean ):List<T> = when (list) {
    is List.Nil -> List()
    is List.Node -> List.Node(if(p(list.head)) f(list.head) else list.head, replaceIf(list.tail, f, p))
}

funmap（list:list，f：（T）->R）：list=when（list）{
is List.Nil->List.Nil as List
is List.Node->List.Node（f（List.head），map（List.tail，f））
}
fun replaceIf（list:list，f：（T）->T，p：（T）->Boolean）：list=when（list）{
is List.Nil->List（）
is List.Node->List.Node（if（p（List.head））f（List.head）else List.head，replaceIf（List.tail，f，p））
}

最后一个不完全正确的过滤器：

fun <T> filter(list: List<T>, p: (T) -> Boolean): List<T> = when (list) {
    is List.Nil -> List()
    is List.Node -> {
        val it = if(p(list.head)) 'something' else 'something'
        List.Node(it,filter(list.tail, p))
    }
}

fun过滤器（list:list，p：（T）->Boolean）：list=when（list）{
is List.Nil->List（）
是列表。节点->{
val it=if（p（list.head））'something'其他'something'
List.Node（it，filter（List.tail，p））
}
}

---

我基本上想递归地测试每个元素的p是否为真如果为真，它应该过滤掉该元素，否则让它进入新列表。因此，我需要更改if/else的“某物”，使其工作

好的，那么，过滤列表的算法是什么呢

如果为零，则为零

如果是节点和谓词（head），则返回带有筛选尾部的相同列表

如果节点和！谓词（head）然后仅返回过滤后的尾部

因此，实施将是：

fun filter(predicate: (T) -> Boolean): FList<T> = when (this) {
    is Nil -> this
    is Node<T> -> if (predicate(head)) Node(head, tail.filter(predicate)) else tail.filter(predicate)
}

FList(0, 1, 2, 3, 4, 5, 6, 7, 8)
    .filter { it % 3 == 0 }
    .map { it * 2 }
    .foreach { println(it) }