过滤最大值 N

Question

是否可以在 FFL 中编写 filter 的版本，在第一个否定匹配后停止过滤，即假定剩余项目为肯定匹配？更一般地说，过滤器。

示例：

removeMaxOf1([1,2,3,4], value>=2)

预期结果：

[1,3,4]

这似乎很难用纯函数式风格来写。也许递归或 let 可以实现它？

注意：这个问题的全部动机是假设微优化。所以性能非常重要。我也在寻找通常适用于任何数据类型的东西，而不仅仅是 int.

Answer 1

递归当然可以！ :D

filterMaxOf1(input, target)
where filterMaxOf1 = def
        ([int] l, function f) -> [int]
        if(size(l) = 0,
                [],
                if(not f(l[0]),
                        l[1:],
                        flatten([
                                l[0],
                                recurse(l[1:], f)
                        ])
                )
        )
where input = [
        1, 2, 3, 4, ]
where target = def
        (int i) -> bool
        i < 2

一些检查：

--> filterOfMax1([1, ]) where filterOfMax1 = [...]
[1]
--> filterOfMax1([2, ]) where filterOfMax1 = [...]
[]
--> filterOfMax1([1, 2, ]) where filterOfMax1 = [...]
[1]
--> filterOfMax1([1, 2, 3, 4, ]) where filterOfMax1 = [...]
[1, 3, 4]

这种风格失去了一些强类型安全性，但更接近于尾递归：

filterMaxOf1(input, target)
where filterMaxOf1 = def
        ([int] l, function f) -> [int]
        flatten(filterMaxOf1i(l, f))
where filterMaxOf1i = def
        ([int] l, function f) -> [any]
        if(size(l) = 0,
                [],
                if(not f(l[0]),
                        l[1:],
                        [
                                l[0],
                                recurse(l[1:], f)
                        ]
                )
        )
where input = [
        1, 2, 3, 4, ]
where target = def
        (int i) -> bool
        i < 2

Answer 2

我最近在引擎中添加了 find_index，这样可以轻松完成此操作：

if(n = -1, [], list[:n] + list[n+1:])
where n = find_index(list, value<2)
where list = [1,2,3,4]

find_index 将 return 第一个匹配项的索引，如果未找到匹配项，则为 -1。还有 find_index_or_die，其中 return 是第一个匹配项的索引，当您绝对确定列表中有一个实例时，断言是否找到了 none。

你也可以使用递归来实现这样的东西：

def filterMaxOf1(list ls, function(list)->bool pred, list result=[]) ->list
base ls = []: result
base not pred(ls[0]): result + ls[1:]
recursive: filterMaxOf1(ls[1:], pred, result + [ls[0]])

过滤最大值 N

filter max of N

recursion

filtering

purely-functional

anura

ffl