在'惯用'Scala中表达此功能有哪些想法。或者更确切地说,有没有办法在不牺牲可读性的情况下删除本地变量?
def solve(threshold: Int)(f: Int => Int): Int = {
var sum = 0
var curr = 0
while(sum < threshold) {
sum += f(curr)
curr += 1
}
curr
}
我唯一想到的就是这个,但在我看来它更长,更不易读。
def solve2(threshold: Int)(f: Int => Int): Int = {
val resultIterator = Iterator.iterate (0, 0) { case (curr, sum) =>
(curr + 1, sum + f(curr))
}
(resultIterator find (_._2 >= threshold)).get._1
}
答案 0 :(得分:13)
def solve(threshold: Int)(f: Int => Int): Int = {
Iterator.from(0).map(f).scanLeft(0)(_ + _).indexWhere(threshold <=)
}
在我看来,循环版本更清晰。
答案 1 :(得分:10)
最直接的方法是将while循环转换为嵌套的尾递归函数。
def solve(threshold: Int)(f: Int => Int): Int = {
def solveLoop(sum: Int, curr: Int): Int = if (sum < threshold) {
solveLoop(sum + f(curr), curr + 1)
} else {
curr
}
solveLoop(0,0)
}
这是循环的标准“功能”方式。
答案 2 :(得分:7)
你可以
def solve(threshold: Int, i: Int = 0)(f: Int => Int) = {
if (threshold <= 0) i else solve(threshold - f(i), i+1)(f)
}
但我不确定这实际上更清楚。请注意,它实际上比while循环的紧凑版本更多的字符:
def solve(threshold: Int)(f: Int => Int) = {
var s,i = 0; while (s < threshold) { s += f(i); i += 1 }; i
}
具有可变变量的循环并不总是坏的,“惯用的”或不是。只需保持函数中安全包含的可变状态,所有其他人看到的都是无状态函数。
顺便说一下,虽然sum
是一个明智的变量名称,但curr
是值得怀疑的。 i
有什么问题?它被广泛用作索引变量,无论如何,变量都是一个令人讨厌的东西;关键是你采取一些东西,每次增加它,无论它是什么,然后返回它。正是这种逻辑流,而不是名称,告诉你(和其他人)它是什么。
答案 3 :(得分:4)
以下是我在Haskell中的表现:
solve threshold f = snd $ until test step (0, 0)
where test (sum, i) = sum >= threshold
step (sum, i) = (sum + f i, succ i)
这清楚地标记了test
,step
和初始值,就像命令式版本一样。我不确定scala在libs中是否有until
,但是定义它是微不足道的:
def until[A](test: A => Boolean)(f: A => A)(v: A): A = {
if (test(v)) {
v
} else {
until(test)(f)(f(v))
}
}
def solve(threshold: Int)(f: Int => Int): Int = {
def test = (sum: Int, i: Int) => sum >= threshold
def step = (sum: Int, i: Int) => (sum + f(i), i + 1)
until(test.tupled)(step.tupled)((0, 0))._2
}
答案 4 :(得分:1)
我总是想知道人们何时谈论'惯用'scala。因为在我看来,每个人都有自己对惯用语的看法。如果您正在寻找功能性解决方案,我建议您先看看“迭代器模式的本质”。实际上scala中有一个非常好的博客文章,关于此检查:http://etorreborre.blogspot.com/2011/06/essence-of-iterator-pattern.html