具有未来结果的scala递归循环
Scala是一种多范式编程语言，结合了面向对象编程和函数式编程的特性。它运行在Java虚拟机上，并且可以与Java代码无缝互操作。Scala递归循环是指在Scala语言中使用递归方式实现循环的一种技术。
递归是一种通过调用自身的方式来解决问题的方法。在Scala中，递归循环可以通过定义一个递归函数来实现。递归函数在执行时会调用自身，直到满足某个终止条件才停止递归。
具有未来结果的Scala递归循环是指递归函数在每次调用时都返回一个Future对象，该对象表示一个异步计算的结果。Future对象可以用于处理异步任务的结果，例如等待任务完成、处理任务的返回值等。
Scala递归循环的优势在于可以简化代码逻辑，使得程序更加清晰易读。同时，通过使用Future对象，可以充分利用多核处理器的并行计算能力，提高程序的性能和响应速度。
Scala递归循环在各种场景下都有广泛的应用。例如，在处理大规模数据集时，可以使用递归循环来实现数据的分块处理和并行计算。在编写复杂的算法时，递归循环可以帮助我们更好地组织代码逻辑。此外，递归循环还可以用于解决数学问题、图形处理、自然语言处理等领域的挑战。
腾讯云提供了一系列与Scala递归循环相关的产品和服务。例如，腾讯云函数计算（SCF）是一种无服务器计算服务，可以用于执行递归函数。腾讯云容器服务（TKE）提供了容器化的运行环境，可以用于部署Scala应用程序。腾讯云云数据库（TencentDB）提供了高性能的数据库服务，可以用于存储和管理递归函数的数据。
更多关于腾讯云相关产品和服务的信息，您可以访问腾讯云官方网站：https://cloud.tencent.com/
相关·内容
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回答
清理阶段后的Scala编译器输出
、、、、
我想开发一个工具，一旦scala编译器完成了所有的任务，就会对Scala程序进行后置处理。根据我对scala编译器不同阶段的理解，它在语法糖和高级特性(如lambdas、闭包、模式匹配等)方面逐步简化了程序。然而，我注意到所谓的清理阶段--这是代码生成之前的最后一个阶段--看起来像Scala，但实际上不是scala。
是否有人亲自知道，或能向我指出一个资源，可以帮助我理解清理阶段的语言？
举个例子，在清理阶段的输出中，我看到了如下内容：
case <synthetic> val x1: Foo$Bar = l;
case9(){
if (...some conditio
浏览 0提问于2017-11-30得票数 3
回答已采纳
我目前正在构建一个Scala框架应用程序，它使用的库返回的结果为F.Promise (Java诺言)。有没有办法将F.Promises ()转换为Scala承诺，还是将包装好的Scala未来从F.Promise中剔除？
到目前为止，我看到的唯一方法是获取F.Promise，但这是一个阻塞操作，我希望继续异步工作。
第一个答案中描述的方式引导我找到了这段代码。不幸的是，我不知道如何正确定义这个F.Function。代码不编译。
答:最后，我发现F.Promise有一个名为wrapped()的方法。这个方法会给你一个Scala的未来。
浏览 3提问于2014-10-30得票数 1
回答已采纳
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
回答已采纳
在此代码中，我试图将两棵树合并如下：
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> def fact(n: Int): Double = if(n < 1) 1 else n * fact(n - 1)
fact: (n: Int)Double
scala> fact(30)
res31: Double = 2.6525285981219103E32
scala> @tailrec def fact(n: Int, acc: Double = 1): Double = if(n < 1) acc else fact(n - 1, n * acc)
f
浏览 0提问于2012-08-06得票数 8
回答已采纳
在函数式编程课程的工作表中，我被要求用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
回答已采纳
2回答
我在一台主机上启动了两个远程actors，它们只是回显发送给它们的任何内容。然后，我创建另一个参与者，它发送一定数量的消息(使用!！)发送给两个参与者，并保存保存这些参与者的回复的Future对象的列表。然后我循环遍历这个列表，获取每个Future的结果。问题是，大多数情况下，一些期货永远不会回来，即使参与者声称它已经发送了回复。这个问题是随机发生的，有时它会遍历整个列表，但大多数时候它会在某个点被卡住，并无限期地挂起。
下面是在我的机器上产生问题的一些代码：
Sink.scala：
import scala.actors.Actor
import scala.actors.Actor._
i
浏览 1提问于2010-07-29得票数 5
我在Scala中有以下函数：
object TestFutures5 extends App {
def future (i:Int) = Future { i * 10 }
var rnd = scala.util.Random
val futureResult = (1 to 10).map {
x =>
val y = rnd.nextInt(x)
(future(x),y) // <- this should return a future
// as it needs to
浏览 2提问于2017-06-19得票数 0
回答已采纳
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
回答已采纳
我需要在服务器端进行一些消耗计算(例如DB查询和数据分析)。结果需要在浏览器中打印出来。出于这些目的，我将Future result从服务器发送到客户端(以立即加载网页，并逐渐从服务器打印未来的结果)。例如，在服务器端
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
def futureResult = Future {
val cc = ConsumingCalculations();
"some result"
}
在客户端
@imp
浏览 1提问于2013-04-01得票数 0
受的启发，我认为以下是一个解决方案：
import scala.concurrent.Future
val x: Future[Option[Int]] = Future.successful { None }
val y: Future[Option[Int]] = Future.successful { Some(55) }
Future.reduce(Seq(x, y))(_ orElse _).value // expecting Some(Success(Some(55)))
令我惊讶的是，在REPL中执行此操作通常会给None提供不稳定的Some(55)
res80: Opt
浏览 2提问于2015-07-28得票数 1
回答已采纳
2回答
我参加了Martin关于Scala未来的主题演讲：
在1:01:00，一个观众问题的答案似乎说，未来的Scala将不会是图灵完成。
我理解得对吗？Scala 3将不再是图灵完成吗？如果是这样的话，这会对像我这样每天在工作中使用Scala解决实际问题的人产生什么样的实际影响？换句话说，工业Scala程序员所释放的是什么，他们通过消除图灵的完整性得到了什么呢？
浏览 2提问于2017-10-31得票数 6
回答已采纳
2回答
在Cay Horstmann针对不耐烦的Scala4.9中，有两个解决方案：“编写一个函数lteqgt( values : ArrayInt，v: Int)，它返回一个三元组，其中包含小于v、等于v和大于v的值的计数。”一个使用尾递归，另一个使用while循环。我认为两者都可以编译成类似的字节码，但是while循环比尾递归慢了近2倍，这表明我的while方法写得很糟糕。
import scala.annotation.tailrec
import scala.util.Random
object PerformanceTest {
def main(args: Array[String]
浏览 2提问于2012-02-07得票数 35
回答已采纳
1回答
Scala使用基于System Fω的类型系统，这通常被认为是强规范化的。强规范化意味着非图灵完备性。
然而，Scala的类型系统是Turing-complete的。
与正式的算法和系统相比，哪些更改/添加/修改使Scala的类型系统图灵完整？
浏览 8提问于2011-12-14得票数 25
回答已采纳
1回答
我希望下面的代码将生成值5，正如我编写的恢复来处理异常并返回5。但是我总是在IntelliJ中看到异常。这里的错误是什么？
import scala.concurrent._
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{Failure, Success, Try}
import scala.concurrent.duration._
import scala.language.postfixOps
object ConcurrencyExample extends App {
va
浏览 2提问于2016-12-30得票数 1
回答已采纳
我在我的scala程序中使用json4s库。
我的build.sbt看起来就像
libraryDependencies ++= Seq(
"org.json4s" % "json4s-native_2.11" % "3.3.0"
)
在我的代码中，我有一个函数
import org.json4s._
import org.json4s.native.JsonMethods._
import org.json4s.JValue
class Foo {
def parse(content: String) = {
val js
浏览 1提问于2016-02-05得票数 0
回答已采纳
因此，我正在尝试编写一个任务，直到您告诉它停止为止，它一直在运行：
import scala.concurrent.Future
import scala.concurrent.ExecutionContext
import java.util.concurrent.RejectedExecutionException
def runUntilShutdown(f: => Unit) = {
val ctx = ExecutionContext.fromExecutorService(null)
import ExecutionContext.global
def runT
浏览 1提问于2018-12-06得票数 2
回答已采纳
1回答
我来自一个面向对象的背景，在那里我主要用Java编写应用程序。我最近开始探索更多关于Scala的内容，我一直在阅读一些文本。因此，我遇到了一种叫做尾递归的东西。我知道如何编写尾递归方法。
例如-添加列表中的元素(当然可以使用reduce方法完成)，但为了理解，我编写了一个尾递归方法：
@scala.annotation.tailrec
def sum(l: List[Int], acc: Int): Int = l match {
case Nil => acc
case x :: xs => sum(xs, acc + x)
}
Scala运行时如何在内部处理这种递归？
浏览 0提问于2018-01-01得票数 0
我正在使用Scalaz IO Monad和Stream在spoj.com上寻找“生命、宇宙和一切”问题的解决方案。问题是将小数字从输入重写到输出，并在读入数字42后停止处理输入。我创建了以下类：
import scalaz._, effect._
def ReadInt: IO[Int] = IO {
readInt
}
def PrintInt(i: Int): IO[Unit] = IO {
println(i)
}
def EchoInt: IO[Int] = {
for {
i <- ReadInt
_ <- Pri
浏览 3提问于2015-09-20得票数 1
下面，sumAllIf是尾部递归的，而sumAllFold不是。然而，sumAllIf实际上具有相同的实现。这是Scala编译器(或者Scala库)的一个缺点，还是我忽略了什么？
def maybeNext(in: Int): Option[Int] = if in < 10 then Some(in + 1) else None
// The Scala library implements Option.fold like this:
// @inline final def fold[B](ifEmpty: => B)(f: A => B): B =
// if
浏览 5提问于2022-01-23得票数 1
回答已采纳
函数体是否在调用后传递给Future.onComplete()，以及它们的闭包、丢弃和垃圾收集？
我之所以这样问，是因为我正在编写一个无界的Future实例序列。每个Future都有一个.onComplete { case Failure(t)...}，该.onComplete { case Failure(t)...}引用上一个Future的前一个已知的好值。我想避免的是，由于闭包体中的引用，所有Future结果都保存在JVM的内存中。
也许Scala比这更聪明，但是浏览与执行上下文和未来相关的代码并没有产生多大的效果。
谢谢。
浏览 1提问于2019-06-30得票数 3
回答已采纳
2回答
在学习Scala的一些教程时，就想到了这个问题，但我认为，在函数式编程方面，总的来说是很有趣的。
我不确定不变性在FP中的重要性。我能想到两种不同的情况：
1)类方法不返回实际字段，而是返回它们的副本。例如，如果我们有一个需要保持不可变的类Dog，那么它的函数：
getToys() { return new ArrayList(this.toys); }
而不是：
getToys() { return this.toys; }
这种情况对我来说非常有意义，在第二种情况下，客户端代码实际上会破坏对象。我对第二种情况持怀疑态度：
2)在Scala和大多数其他FP语言中，我们更喜欢递归调用：
sum
浏览 5提问于2016-06-25得票数 0
回答已采纳
2回答
我正在通过Coursera课程学习Scala。
我们正在学习从函数上思考，并在可能的情况下使用尾递归来实现函数/方法。
作为一个列表函数上的foreach的例子，我们教会了如何实现它，如下所示：
def foreach[T](list: List[T], f: [T] => Unit) {
if (!list.isEmpty) foreach(list.tail) else f(list.head)
}
然后，当我在一些Scala apis中发现以下实现时，我感到很惊讶：
override /*IterableLike*/
def foreach[B](f: A =>
浏览 0提问于2015-07-12得票数 7
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
回答已采纳
我正在使用Functional Programming in Scala书学习Scala。它的Github同伴注释说，a || go(x)仍然是尾部调用优化的递归，而1 + go(x)不是。计算有什么不同?为什么编译器可以优化其中一个而不能优化另一个？
浏览 41提问于2021-09-17得票数 1
回答已采纳
3回答
我在Scala中实现了Sphere函数(获取元素列表，对每个元素进行平方并返回和)。我想将这个函数转换为尾递归函数。我的密码在这里
def Sphere(list: List[Double]): Double = {
val power = list.map(math.pow(_, 2))
power.reduce(_+_)
}
浏览 0提问于2019-06-14得票数 1
回答已采纳
1回答
我一直在研究scala递归问题。我曾经使用循环开发程序，然后使用递归的概念将现有的循环问题转换为递归解决方案。
因此，我编写了以下代码来使用循环查找完美数字。
def isPerfect(n: Int): Boolean = {
var sum = 1
// Find all divisors and add them
var i = 2
while ( {
i * i <= n
}) {
if (n % i == 0) if (i * i != n) sum = sum + i + n / i
else s
浏览 0提问于2020-03-02得票数 2
2回答
我是Scala的新手，并开始学习尾递归。我了解到，函数编程中的尾递归是命令式编程中迭代(用于循环)的一个反部分：
简单的C++循环以求和列表元素：
uint32_t sum = 0;
for (size_t i = 0; i < list.length(); ++i) {
sum += list[i];
}
Scala递归等效：
def listSum(list: List[Int]): Int = {
def listSumHelper(list: List[Int], sum: Int): Int = {
if (list.isEmpty) sum
els
浏览 5提问于2013-03-28得票数 2
回答已采纳
我测试了spark默认PageRank示例，并将迭代设置为1024，然后它抛出stackoverflowerror。我在我的另一个program.How中也遇到了这个问题，我能解决它吗？
object SparkPageRank {
def main(args: Array[String]) {
if (args.length < 3) {
System.err.println("Usage: PageRank <master> <file> <number_of_iterations>")
Syst
浏览 3提问于2014-03-11得票数 8
3回答
我有一些副作用作用，
def f(): Future[Int] = {
val n = Random.nextInt()
println(s"Generated $n")
Future(n)
}
我想重复执行它，直到predicate返回true。
def success(n: Int): Boolean = n % 2 == 0
我的计划是构建Stream of results
val s = Stream.fill(10)(f)
然后使用Future.find获得第一个满足谓词的结果。
Future.find(s)(success) map println
问题
浏览 1提问于2014-10-18得票数 3
Hi，I‘m研究Scala未来和获取内部数据的方法在未来/Promises.So中是扭曲的，所以我编写了我所知道的所有模型，以获取Scala期货的内部数据。
我们总是看到这两种情况：
有一段时间，我们在异步函数的块中获取未来的内部数据，如map、flatMap、foreach、折叠、.
2-有一段时间，我们在未来中获得了结果，比如使用等待
在本例中，我使用Akka ?或ask函数(它的异步)，并尝试了解如何获得未来结果的最佳实践
1-走出街区？
2-进入街区？
当我们异步时，我们知道阻塞是不好的做法(所以使用Await，Sleep，.)都是坏的。
请帮助我找到替代Await或Fut
浏览 1提问于2018-04-19得票数 2
2回答
我正在阅读Scala2.11.8在andThen模块中的scala.concurrent.Future函数文档，它说：
def andThen[U](pf: PartialFunction[Try[T], U])
(implicit executor: ExecutionContext): Future[T]
将副作用函数应用于这个未来的结果，并以这个未来的结果返回一个新的未来。
此方法允许强制以指定的顺序执行回调。
请注意，如果其中一个链接的andThen回调引发异常，则该异常不会传播到后续的andThen回调。相反，随后的andThen回调将给出这个未来的原始
浏览 0提问于2016-10-18得票数 7
回答已采纳
3回答
假设我有多个任务要并行运行。
每个任务(方法)都有一个内部递归函数，该函数基本上从数据库中获取数据并将其保存在某些数据存储中。
简化内递归函数
def simplifiedSomeTask(): Unit = {
@scala.annotation.tailrec
def get(
stream: Stream[SomeEntity],
result: Seq[SomeEntity],
): Stream[SomeEntity] = result match {
case Nil =>
stream
浏览 0提问于2019-06-12得票数 2
回答已采纳
2回答
查看以下Scala代码：
def rec(n: Int) {
if (n > 1) {
val d = n / 2
rec(d)
// if (d > 1) // abort loop
rec(n/d)
}
}
这段代码将导致无限循环。由于尾递归优化，我得不到StackOverflowError。
使用jad进行反编译后，我得到了以下Java代码：
public void rec(int n)
{
int d;
for(; n > 1; n /= d)
{
int i = n;
浏览 9提问于2011-03-17得票数 7
回答已采纳
2回答
我是Scala、Play和using Futures的新手。我有下面的Play类，它进行API调用并在Future中封装结果。
如何从Future中提取结果？
class WikiArticle(url : String) {
var future : Future[WSResponse] = null
def queryApi(): Unit = {
val holder : WSRequest = WS.url(url)
future = {
holder.get()
}
future.onSuccess({
//How
浏览 0提问于2015-11-29得票数 2
我正在学习scala期货，我已经回答了我的问题。我有一个很简单的例子
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent._
import scala.util.{Failure, Success}
/**
* Created by dummy on 05/02/15.
*/
object FutureUtils extends App{
val f = Future {
Thread.sleep(1000)
println("I am learni
浏览 3提问于2015-02-05得票数 2
回答已采纳
1回答
我试图在play框架中运行async操作，并将反应性mongo用于数据库操作。在Future对象中，反应性mongo返回结果。但是，当我返回未来的结果在行动，我得到编译时错误。Play和Scala对我来说是新的，但仍然没有真正的问题是什么？我有另一段代码，代码可以成功地工作。
工作代码：
def dashboard = Action.async{
logger.info("In dashboard controller method");
var cursor: Cursor[Playlist] = playlistCollection.find(Json.obj(&
浏览 1提问于2015-03-13得票数 0
回答已采纳
我在Maven项目中发现了一个与Scala-maven-plugin相关的bug。我有一个非常长的功能序列(为了机器学习的目的)，我手工编码(74个元素)。
我在序列中添加了一个元素，它不再编译了。如果我注释这个序列中的任何元素，元素的数量就会减少，并且会编译。
有关更多信息，以下是我编译的最后输出：
[ERROR] Failed to execute goal net.alchim31.maven:scala-maven-plugin:3.3.1:compile (default) on project SecretProject: wrap: org.apache.commons.exec
浏览 3提问于2017-12-20得票数 2
回答已采纳
使用可以将多个期货组合成一个。当它们全部成功时，结果是显而易见的--这是结果的顺序，一旦它们全部完成，就可以得到结果。然而，不清楚的是，当一些(甚至是多个)期货失败时，我没有发现它被记录在案。我的似乎表明，一旦任何未来失败，故障将立即报告。
import scala.concurrent._
import scala.util._
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration.Duration
val f1 = Future {
Thread.slee
浏览 6提问于2022-08-05得票数 0
2回答
最近，我开始用Scala编写大量的编程竞赛代码。(您可以看看这里的平台- )
关于问题的本质，我经常需要对数组或输入数据进行迭代。例如，有一个问题说明，在第一个输入行上，我将得到数字M，然后我需要读取M行，或整数或其他什么。我试着用不同的方法：
for (i <- 0 until M)
----
(0 until M).foreach
----
var i = 0
while (i < M)
---
甚至尾递归
@tailrec
def recursion(i: Int): Unit = {
if (i < M) {
doSomething()
浏览 3提问于2014-09-30得票数 4
回答已采纳
有没有办法在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
回答已采纳
如何使用连续关键字跳过Scala中循环的开头？
while(i == "Y") {
println("choose an item id between 1 and 4")
val id = scala.io.StdIn.readInt()
if(id >= 5) {
println("not a valid id. please choose again")
continue
}
}
我知道Scala提供了易碎和中断抽象，但这似乎无法实现我的功能。
浏览 1提问于2020-02-29得票数 0
回答已采纳
有些人声称，如果使用scalac的-Yrecursion选项，scala能够处理递归结构类型。然而，我的简约示例不能编译：
type Num = {
def +(n: Num): Num
}
编译产生的结果：
$ scalac -version
Scala compiler version 2.8.0.final -- Copyright 2002-2010, LAMP/EPFL
$ scalac -Yrecursion 100 Num.scala
Num.scala:3: error: recursive method + needs result type
def +(n: Num)
浏览 1提问于2010-08-12得票数 6
回答已采纳
3回答
这个片段摘自。这是一个如何在Scala中进入死锁的例子。
import java.util.concurrent.Executors
import scala.concurrent._
implicit val ec = ExecutionContext.fromExecutor(Executors.newFixedThreadPool(1))
def addOne(x: Int) = Future(x + 1)
def multiply(x: Int, y: Int) = Future {
val a = addOne(x)
val b = addOne(y)
val res
浏览 0提问于2018-05-12得票数 1
回答已采纳
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
3回答
描述我的问题的简单代码示例：
import scala.util._
import scala.concurrent._
import scala.concurrent.duration._
import ExecutionContext.Implicits.global
class LoserException(msg: String, dice: Int) extends Exception(msg) { def diceRoll: Int = dice }
def aPlayThatMayFail: Future[Int] = {
Thread.sleep(1000) //t
浏览 2提问于2013-08-01得票数 4
回答已采纳
我看到Scala库中的List.scala实现如下：
override final def forall(p: A => Boolean): Boolean = {
var these: List[A] = this
while (!these.isEmpty) {
if (!p(these.head)) return false
these = these.tail
}
true
}
该方法可以递归地实现，以消除var和while循环。通过阅读所有可用的书籍、博客、文章等等，我的印象是，我们应该尽可能多地遵循Scala的递归方
浏览 3提问于2021-09-01得票数 1
回答已采纳
我想了解，如何在幕后执行这些类型的尾递归，我最近在用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
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
