返回另一个函数的scala递归函数
Scala是一种多范式编程语言，它结合了面向对象编程和函数式编程的特性。在Scala中，递归函数是一种常见的编程技术，它允许函数调用自身来解决问题。返回另一个函数的Scala递归函数是指一个递归函数在执行过程中返回另一个函数作为结果。
下面是一个示例代码，展示了一个返回另一个函数的Scala递归函数：
def recursiveFunction(n: Int): Int => Int = {
if (n <= 0) {
(x: Int) => x
} else {
(x: Int) => recursiveFunction(n - 1)(x + 1)
}
}
val resultFunction = recursiveFunction(3)
val result = resultFunction(0)
println(result) // 输出3在上述示例中，recursiveFunction是一个递归函数，它接受一个整数参数n并返回一个函数类型Int => Int。当n小于等于0时，返回一个匿名函数(x: Int) => x，该函数会原样返回输入的整数。当n大于0时，返回一个匿名函数(x: Int) => recursiveFunction(n - 1)(x + 1)，该函数会将输入的整数加1，并将n减1后传递给递归调用的recursiveFunction函数。
在上述示例中，我们通过调用recursiveFunction(3)得到一个返回函数resultFunction，然后通过调用resultFunction(0)得到最终的结果3。
递归函数在编程中有许多应用场景，例如树的遍历、数学运算、解决复杂问题等。通过使用递归函数，我们可以简洁地表达复杂的逻辑，并且可以处理具有任意深度的问题。
腾讯云提供了丰富的云计算产品和服务，其中与Scala递归函数相关的产品包括云函数（SCF）和云原生应用平台（TKE）。云函数是一种无服务器计算服务，可以让您以函数的方式编写和运行代码，非常适合处理事件驱动的任务。云原生应用平台是一种容器化的应用管理平台，可以帮助您轻松部署和管理容器化的应用程序。
您可以通过以下链接了解更多关于腾讯云函数和云原生应用平台的信息：
请注意，以上答案仅供参考，具体的产品选择和推荐应根据实际需求和情况进行评估。
相关·内容
我想了解，如何在幕后执行这些类型的尾递归，我最近在用scala编写的一个大数据分配中看到了这种情况。我还提供了另外两个版本的实现，我宁愿编写这段代码--其中一个也是尾递归的，另一个不是；但是，我想了解第一个实现是如何提供相同结果的。
因此，这里是(目的是在list (Ls)中查找特定名称(标记)的索引)：
def firstLangInTag(tag: Option[String], ls: List[String]): Option[Int] = {
if (tag.isEmpty) None
else if (ls.isEmpty) None
else if (tag.get == ls.
浏览 4提问于2017-08-22得票数 0
2回答
我正在读M. Odersky的Scala编程，他说
像“近似”这样的函数称为“尾递归”，称自己为它们的最后一个动作。
所以，我试过这个
object Main extends App {
implicit val mc = new MyClass(8)
val ti = new TestImplct
ti.test
}
class TestImplct {
def test(implicit mc : MyClass): Unit = {
println(mc.i)
mc.i -= 1
if(mc.i < 0){
浏览 2提问于2016-08-30得票数 4
回答已采纳
def toJson[T](obj: T) = {
gson.toJson(obj)
}
def toJson[T](list: Seq[T]) = {
toJson(seqAsJavaList(list))
}
这不能编译。这被记录为一个特性()：
当方法重载时，其中一个方法调用另一个方法。调用方法需要一个返回类型注释。
问题是:为什么？
从上面的链接+同事的一些其他想法来看，以下是可能的原因：
scala还使用返回类型来确定重载的方法。是这样的，为什么要嵌套呢？(例如，Java不使用返回类型)
部分函数--如果其中一个方法没有参数，
浏览 4提问于2014-03-06得票数 3
4回答
作为一名Scala新手，我正在阅读书籍、文档，并试图解决在上发现的问题。似乎正确的Scala代码基于不可变值(val)和递归，而不是循环和变量，以使并行更安全，并避免需要使用锁。
例如，exercise P22 ( )的一个可能的解决方案是：
// Recursive.
def rangeRecursive(start: Int, end: Int): List[Int] =
if (end < start) Nil
else start :: rangeRecursive(start + 1, end)
当然，这段代码是紧凑的，看起来很聪明，但是，当然，如果递归次数很多，您将面临St
浏览 0提问于2012-07-27得票数 11
回答已采纳
我是scala新手，目前正在练习工作表。虽然我添加了导入，但我注意到@tailrec在工作表中不起作用
import scala.annotation.tailrec
这是我正在使用的scala版本
Scala code runner version 2.10.2 -- Copyright 2002-2013, LAMP/EPFL
有办法让它起作用吗？谢谢
浏览 1提问于2013-09-21得票数 6
回答已采纳
我最近开始学习用Scala编程，到目前为止一直很有趣。我真的很喜欢在另一个函数中声明函数的能力，这似乎是直觉所要做的事情。
我对Scala的一个恼怒是，Scala在其函数中需要显式的返回类型。我觉得这阻碍了语言的表达。而且，很难用这个需求来编程。也许是因为我来自Javascript和Ruby舒适区。但是对于像Scala这样的语言，它将在一个应用程序中包含大量的连接函数，我无法想象我如何在头脑中头脑风暴，我所编写的特定函数应该在递归之后返回什么类型的递归。
这种对函数的显式返回类型声明的要求，不需要像Java和C++这样的语言来困扰我。Java和C++中的递归，当它们确实发生时，通常最多处理2到
浏览 0提问于2012-10-03得票数 12
回答已采纳
我倾向于使用Scala编程，并遇到了这样的问题: Scala代码抛出StackOverflowErorr，而类似的Java实现在抛出相同的错误之前可以做得更多。
def recursiveSum(args: Int*): Int = {
if (args.length == 0) 0
else
args.head + recursiveSum(args.tail: _*)
}
recursiveSum(5000 to 15000: _*)
我得到的错误是
浏览 0提问于2014-05-23得票数 5
回答已采纳
我正在使用Functional Programming in Scala书学习Scala。它的Github同伴注释说，a || go(x)仍然是尾部调用优化的递归，而1 + go(x)不是。计算有什么不同?为什么编译器可以优化其中一个而不能优化另一个？
浏览 41提问于2021-09-17得票数 1
回答已采纳
假设我有这个命令式代码：
List<Function<T, T>> functions = ...
T value = ...
for (Function<T, T> function : functions) {
value = function.apply(value);
}
如何用函数式(如Scala中的折叠)来编写？
浏览 7提问于2017-06-13得票数 12
回答已采纳
在函数式编程课程的工作表中，我被要求用Scala编写一个函数(尽管我认为这个函数指的是方法)，它递归地在新行的列表中打印元素，其结果如下：
scala> printCounter (List ("the", "rain", "in", "spain"))
[001] the
[002] rain
[003] in
[004] spain
工作表上提供的解决方案如下所示：
def printCounterAux [X] (xs:List[X], count:Int) : Unit = {
xs match {
浏览 3提问于2020-05-27得票数 3
回答已采纳
4回答
在我的Scala应用程序中，我有一个函数，它调用一个返回FutureT类型结果的函数。我需要在我的递归函数调用中传递映射结果。我希望这是尾递归的，但是map (或flatMap)破坏了这样做的能力。我收到一个错误"Recursive call not in tail position“。
下面是此场景的一个简单示例。如何修改这一点以使调用是尾递归的(而不破坏带有Await.result()的Futures的好处)？
import scala.annotation.tailrec
import scala.concurrent.{Await, Future}
import scala.c
浏览 4提问于2013-06-07得票数 24
回答已采纳
1回答
我试图将一些用户输入的String添加到带有尾递归的不可变List中，然后将这个不可变的List添加到定义的MutableList中。不知怎么的，这个不变的List并没有被添加到我的MutableList中。为什么是这样？
编辑:更新了代码。现在起作用了！
val list = scala.collection.mutable.MutableList[String]()
def exerciseSelector() {
val user = scala.io.StdIn.readLine("go:")
user match {
case
浏览 1提问于2015-09-19得票数 0
回答已采纳
如果我定义了一个简单的stringToInt函数并将其存储为一个val，那么一切都会像预期的那样工作。
scala> def stringToInt1: (String => Int) = _.toInt
stringToInt1: String => Int
scala> stringToInt1("1")
res0: Int = 1
但是，如果然后进行隐式处理，则会导致堆栈溢出：
scala> implicit def stringToInt2: (String => Int) = _.toInt
stringToInt2: Strin
浏览 2提问于2013-12-12得票数 5
回答已采纳
3回答
这是Scala中Y-组合器的一个实现：
scala> def Y[T](func: (T => T) => (T => T)): (T => T) = func(Y(func))(_:T)
Y: [T](func: (T => T) => (T => T))T => T
scala> def fact = Y {
| f: (Int => Int) =>
| n: Int =>
| if(n <= 0) 1
浏览 4提问于2016-01-13得票数 9
回答已采纳
阅读由专家编写的Scala文档可以得到这样的印象:尾递归比while循环更好，即使后者更简洁、更清晰。这就是一个例子
object Helpers {
implicit class IntWithTimes(val pip:Int) {
// Recursive
def times(f: => Unit):Unit = {
@tailrec
def loop(counter:Int):Unit = {
if (counter >0) { f; loop(c
浏览 2提问于2013-09-07得票数 19
在第17.1节( Scala中的编程集合) (Martin Odersky)中，有一行内容如下：
使用ListBuffer而不是List的另一个原因是防止堆栈溢出的可能性。
如何使用ListBuffer防止堆栈溢出的可能性？...No双关语是有意的；)
浏览 4提问于2016-06-30得票数 1
我正在自己从scala编译器源代码构建scala编译器。在编译器的源代码中，有许多尾递归函数/方法.从源代码构建scala编译器还需要编译编译器本身的源代码。如果在编译源代码期间添加选项-g:notailcalls来关闭尾递归优化，则在运行构建的编译器时会出现statck溢出错误。
总之，在一个具有许多递归调用的大型复杂scala程序中，在编译时省略尾递归优化会在运行时导致堆栈溢出错误吗？
浏览 2提问于2015-09-04得票数 1
回答已采纳
有没有办法在CPS内有一个尾递归函数而不抛出StackOverflow？
import scala.util.continuations._
object CPSStackOverflow {
def main(args: Array[String]) = {
reset {
def recurse(i: Int): Unit @suspendable = {
println(i)
shift { k: (Unit => Unit) =>
k( () ) // just continue
}
浏览 0提问于2010-05-11得票数 4
回答已采纳
10回答
我正在学习“Scala编程”，并编写了一个选择排序算法的快速实现。但是，由于我在函数式编程方面还是个新手，我在转换为更具Scala风格的应用程序时遇到了麻烦。对于Scala程序员来说，我该如何使用列表和函数来完成这项工作，而不是退回到命令式的方式？
浏览 0提问于2009-11-04得票数 8
回答已采纳
3回答
我在下面的F#定义中看到了一个连续传递风格的斐波纳契函数，我一直认为它是尾递归的：
let fib k =
let rec fib' k cont =
match k with
| 0 | 1 -> cont 1
| k -> fib' (k-1) (fun a -> fib' (k-2) (fun b -> cont (a+b)))
fib' k id
在Scala中尝试等效代码时，我使用了现有的@ tail are，当Scala编译器通知我递归调用不处于尾位置时，我感到措手不及：
def fib(k
浏览 5提问于2015-06-23得票数 3
回答已采纳
您是否可以检查scala中的方法/函数引用是否等于另一个方法/函数引用？例如，编写如下所示的函数并使其变为真？
scala> def m = 1
m: Int
scala> def check(p: () => Int): Boolean = p == m _
check: (p: () => Int)Boolean
scala> check(m _)
res0: Boolean = false
浏览 6提问于2015-08-27得票数 2
回答已采纳
2回答
下面的Scala代码在1.5分钟内完成，而GO中的等效代码在2.5分钟内完成。
直到谎言(40)都需要2秒。间隙出现在fib(50)中。
我的印象是，作为本地的GO，应该比Scala更快。
Scala
def fib(n:Int):Long = {
n match {
case 0 => 0
case 1 => 1
case _ => fib(n-1) + fib(n-2)
}
}
去
func fib(n int) (ret int) {
if n > 1 {
return fib
浏览 0提问于2014-07-17得票数 1
2回答
我在Scala中看到了以下功能：
def sqrtIter(guess: Double, x: Double): Double =
if (isGoodEnough(guess, x)) guess
else sqrtIter(improve(guess, x), x)
并解释如下：
注意，sqrtIter是递归的，它的右侧调用它自己。
有人能解释一下“右手边”是什么意思吗？
浏览 2提问于2014-01-09得票数 1
回答已采纳
1回答
我通过尝试在List[T]上实现这些操作来教自己Scala。我刚刚实现了dropWhile，这让我想知道在不同情况下出现递归调用时尾递归优化是如何工作的。
def dropWhile[T](list: List[T])(predicate: T => Boolean): List[T] = list match {
case head :: tail if predicate(head) => dropWhile(tail)(predicate)
case _ => list
}
递归调用出现在第一种情况下重要吗？
浏览 1提问于2014-07-30得票数 3
回答已采纳
我正在尝试使用Scala，试图掌握它的诀窍，因此本文的代码示例只是理论上的。
我试图将一个可变列表传递给一个函数，让该函数对其执行工作，然后在函数调用之后，我可以使用更新后的列表。
var data: List[Int] = List()
// Call to function to fill a list
data = initList(data)
// Output only 0-100
data.foreach( num => if (num < 100) { println(num) })
def initList(var data: List[Int]) : Lis
浏览 5提问于2012-01-21得票数 0
回答已采纳
1回答
我试图解决这个epfl课程的作业，他们让我写一个列表的总和。如果我使用return语句或者如果使用match语句，我可以这样做，但是我不明白为什么如果没有返回语句，它就不能使用if/else。
def sum(xs: List[Int]): Int = xs {
if (xs.isEmpty) {
0
} else {
xs.head + sum(xs.tail)
}
}
运行sum(列表(1，3，2))时得到的运行时错误是
java.lang.IndexOutOfBoundsException: 0
at scala.collection.LinearSeqO
浏览 3提问于2019-10-03得票数 0
回答已采纳
3回答
好的，我知道所有的递归更实用，因为你不会在迭代中改变任何对象的状态。但是，没有什么可以阻止您在scala中这样做。
var magoo = 7;
def mergeSort(xs: List[Int]): List[Int] = {
...
magoo = magoo + 1
mergeSort(xs1, xs2);
}
实际上，您可以像在Java中一样，在Scala中使递归变得没有副作用。那么，通过使用模式匹配，Scala只是让编写简洁的递归变得更容易，这样说公平吗？就像没有什么能阻止我用Java编写任何可以用Scala编写的无状态递归代码？
关键在
浏览 1提问于2013-05-18得票数 3
回答已采纳
3回答
Scala新手，正在尝试解决递归问题。
在我的会话中有休眠的定义：
def inc(n: Int) = n + 1
def dec(n: Int) = n – 1
我如何重新定义下面的函数来使用递归inc和dec？
add(n: Int, m: Int) = n + m
我对学习常规递归和尾递归都很感兴趣。
谢谢
浏览 1提问于2016-10-13得票数 0
->如何write a scala method返回类型为Nothing的类型？
-> Do we ever need to write such methods？有没有useful scenarios
浏览 0提问于2016-06-10得票数 4
2回答
我正在尝试在scala REPL 2.11.8中定义一个包含1000个字段的case类。case类定义如下：
case class Step2_Class(
`Response` : String,
`D1` : String,
`D2` : String,
`D3` : String,
`D4` : String,
//......,
`D999` : String,
`D1000` : String)
而REPL正在等待回应。大约1小时后，抛出以下堆栈溢出异常。
java.lang.StackOverflowError
at sca
浏览 1提问于2016-12-12得票数 5
我是scala和函数式编程的初学者，并试图学习基础知识。为了达到这个目的，我开始读“”一书。为了从一组练习开始，他们定义了一个列表类(如下所示)
sealed trait List[+A]
case object Nil extends List[Nothing]
case class Cons[+A](x: A, xs: List[A]) extends List[A]
object List {
def sum(ints: List[Int]) = ints match {
case Nil => 0
case Cons(x, xs) => x + s
浏览 3提问于2015-02-24得票数 1
回答已采纳
2回答
目前使用的是Scala类，我以前从未用过，所以它的语法和本身都是新的。
我正在处理一个简单的除法函数，但遇到了一些错误。
首先，我使用var sub=m是正确的吗？在我的代码中，我只是想做m= m-n，但你不能改变变量，我不确定最好的替代方案是什么。然后我唯一的另一个问题就是编译器对我的打印行的要求..
<console>:14: error: reassignment to val
m = m-n
///////////////////////////////////////////////////////////////////////////////
<
浏览 1提问于2011-09-13得票数 4
回答已采纳
我在scala中有一个函数返回一个tuple：
private def someFunction(from: List[Any], to: List[Any]): (List[Any], List[Any]) = {
// Do some stuff
(modifiedFrom, modifiedTo)
}
我想对这个元组进行分解，并将值作为参数传递给另一个函数：
@tailrec
someOtherFunction(first: List[Any], second: List[Any], third: List[Any]): Unit = {
// Some more st
浏览 4提问于2017-06-16得票数 2
回答已采纳
1回答
清理阶段后的Scala编译器输出
、、、、
我想开发一个工具，一旦scala编译器完成了所有的任务，就会对Scala程序进行后置处理。根据我对scala编译器不同阶段的理解，它在语法糖和高级特性(如lambdas、闭包、模式匹配等)方面逐步简化了程序。然而，我注意到所谓的清理阶段--这是代码生成之前的最后一个阶段--看起来像Scala，但实际上不是scala。
是否有人亲自知道，或能向我指出一个资源，可以帮助我理解清理阶段的语言？
举个例子，在清理阶段的输出中，我看到了如下内容：
case <synthetic> val x1: Foo$Bar = l;
case9(){
if (...some conditio
浏览 0提问于2017-11-30得票数 3
回答已采纳
3回答
我在看scala中的currying技术的例子，我不明白当一个函数是递归的时，一个函数如何返回另一个函数。 例如，我理解以下代码 def addOne(x: Int): Int = x => x + 1
def repeater(myFunc: Int => Int, n: Int, x:Int): Int =
if(n<=0) x
else repeater(myFunc, n-1, myFunc(x)) 如果我说repeater(addOne，10，1)返回11，那么上面的一个对我来说是可以的。直到n等于0，我将n减去1，然后递归堆栈开始从下到上工作。
浏览 26提问于2019-04-10得票数 0
回答已采纳
1回答
我有这样的合并排序实现：
import scala.annotation.tailrec
object MergeSort {
def sortBy[T]: ((T, T) => Int) => Seq[T] => Seq[T] = comparator => seqToSort => {
@tailrec
def merge(xs : Seq[T], ys : Seq[T], accum : Seq[T] = Seq()) : Seq[T] = (xs, ys) match {
case (Seq(), _) => ys
浏览 0提问于2016-12-27得票数 0
回答已采纳
1回答
尾递归阶乘
、、
这段代码有什么可以改进的地方吗？
def factorial(n: Int, offset: Int = 1): Int = {
if(n == 0) offset else factorial(n - 1, (offset * n))
}
其思想是在Scala中使用阶乘的尾递归版本，而不需要定义内部函数或别名。
这个可以这样调用：
factorial(4)
最后的解决方案如下所示：
import scala.annotation._
@tailrec
def factorial(n: Int, accumulator: Long = 1): Long = {
if(n =
浏览 0提问于2012-10-18得票数 5
回答已采纳
1回答
我有一个ListAny队列，但由于某种原因，dequeue没有返回正确的结果，也没有从队列中删除该项。知道为什么会这样吗？
下面是一个示例：
scala> val a = scala.collection.immutable.Queue(List(1, "A", "B", 987), List(2, "C", "D", 456), List(3, "E", "F", 123))
a: scala.collection.immutable.Queue[List[Any]] = Queue(Lis
浏览 3提问于2017-11-03得票数 2
回答已采纳
假设我在Scala中定义了一个函数变量如下：
var _f = (input:Any) => {0}
println(_f('a'));
println(_f('b'));
这个操作很好，并返回两个零。我继续更新_f如下：
_f= (input: Any) => { if (input!='c') _f(input) else 5 }
println(_f('a'));
(见问题末尾的问题更新部分)，但我没有！相反，我得出了以下错误：
Exception in thread "main" ja
浏览 1提问于2015-06-12得票数 0
回答已采纳
是否有任何方法可以将每个n th element从Scala List中删除？
我希望我们可以在filter方法中这样做，并通过编写一个逻辑返回另一个列表。但这样做有效吗？
浏览 1提问于2016-08-23得票数 1
回答已采纳
下面的代码炸毁了堆栈：
val fibs: Stream[BigInt] = BigInt(0) #:: BigInt(1) #:: fibs.zip(fibs.tail).map { n => n._1 + n._2 }.takeWhile(x => x < 4000000).filter(x => x % 2 == 0)
scala> fibs foreach println
0
1
java.lang.StackOverflowError
如果我取出过滤器，并将其应用于另一个表达式中的流，如下所示，它是好的：
scala> val fibs: Str
浏览 1提问于2015-08-05得票数 1
在查看英特尔的BigDL 时，我偶然发现了这样的方法：
private def recursiveListFiles(f: java.io.File, r: Regex): Array[File] = {
val these = f.listFiles()
val good = these.filter(f => r.findFirstIn(f.getName).isDefined)
good ++ these.filter(_.isDirectory).flatMap(recursiveListFiles(_, r))
}
我注意到它不是尾递归，所以决定编写一个尾递归版本：
浏览 3提问于2017-03-20得票数 3
回答已采纳
在此代码中，我试图将两棵树合并如下：
class NonEmpty(elem: Tweet, left: TweetSet, right: TweetSet) extends TweetSet {
def union(that: TweetSet): TweetSet =
{
def unionRec(set:TweetSet,acc:TweetSet): TweetSet =
{
if (set.isEmpty)
return acc
else
return unionRec(r
浏览 3提问于2016-11-25得票数 0
回答已采纳
我正在考古瑟拉的scala课程，我正在尝试在那里教的东西。所以现在我遇到了这个名单，他们称之为"ConsList“？我正在尝试给它一个尾递归toString()方法。我想我必须保留一些类似累加器的东西，但我也不知道该如何做。任何帮助都将不胜感激。
以下是我所尝试的：
/** a non-empty element/node of the list */
class Cons[T](val head: T, val tail: List[T]) extends List[T] {
def isEmpty = false;
override def toString() =
浏览 0提问于2013-10-21得票数 0
回答已采纳
我将scala类定义如下：
scala> class test2(private var a:Int) {
| var t1 = new test2(10)
| println(t1.a)
| }
defined class test2
现在，当我尝试创建这个类的对象时，我会得到堆栈溢出错误(参见下面)。
scala> var t2 = new test2(5)
java.lang.StackOverflowError
... 1024 elided
有人能解释一下为什么会出现这个错误吗？
这不是重复的。链接中发布的问题与java有关。我的问题与
浏览 0提问于2018-04-22得票数 1
回答已采纳
Scala谈到了不变性，在列表上执行的所有操作都创建了另一个集合。但是当执行List方法的内部实现时，它们中的许多都使用可变变量，即var来执行操作。
例如，列表的反向函数
override def reverse: List[A] = {
var result: List[A] = Nil
var these = this
while (!these.isEmpty) {
result = these.head :: result
these = these.tail
}
result
}
或者甚至是foldLeft函数
浏览 5提问于2018-07-26得票数 2
我是Scala的新手，有更好的方法可以用最基本的知识来表达这一点吗？
def findMax(xs: List[Int]): Int = {
xs match {
case x :: tail => (if (tail.length==0) x else (if(x>findMax(tail)) x else (findMax(tail))))
}
}
浏览 8提问于2016-06-26得票数 1
回答已采纳
2回答
我想写一个函数，它可以用这个语法获得无限的参数
myfunc arg1 arg2 arg3 ....我尝试过使用curring，但是没有什么帮助，我试着让它递归，但是scala编译器说："scala递归方法需要结果类型“recursive：
def func(x:Int) = {
doSomething(x); myVal:Int=>func(myVal)
}
感谢你的帮助
浏览 0提问于2013-03-29得票数 2
Java开发人员在迁移到Scala时最常犯的错误是什么？
我所说的错误是指编写不符合Scala精神的代码，例如，在类似map的函数更合适的情况下使用循环，过度使用异常等。
编辑:另一个是使用自己的getters/setter，而不是Scala友好地生成的方法
浏览 2提问于2011-03-03得票数 13
回答已采纳
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频
腾讯云开发者
