我对 Scala Future 有疑问。我有一个带有两个参数的函数：x: Future[Int] 和 y: Future[Int]。
该函数应该返回一个以以下内容完成的 future：
我似乎不知道该怎么做。
目前的代码：
def myFunction(x: Future[Int], y: Future[Int]): Future[Int] = {
x.onSuccess {
case result => return Future(result)
}
x.onFailure {
case e =>
y.onSuccess {
case res => return Future(res)
}
y.onFailure {
case f => throw f
}
}
}
我正在使用 C++11 来做一些线程程序。
现在我遇到这样的情况：
我有一个std::set<std::future<std::string>> results存储线程的一些结果，当然所有这些线程都会返回一个字符串。
但是，当我尝试获取字符串时，出现以下错误：
将 xxx 作为 xxx 的“this”参数传递会丢弃限定符
根据此链接，我认为这是因为我试图调用属于 元素的非常量函数set。换句话说， the 的元素set是std::future<std::string>并且std::future<std::string>::get()是非常量。这就是为什么我收到这样的错误。
如果我是对的，这是否意味着我永远不能声明 astd::set<std::future>因为它get总是不可用？
这是我的代码：
set<future<string>> results;
results.insert(...); // insert some future
for(auto it = results.begin(); it != results.end();)
{
if (it->wait_for(std::chrono::seconds(0)) == std::future_status::ready)
{
string tmp = it->get(); // ERROR!!!
}
}
我在 Flutter 中有一个与 Firestore 通信的异步函数。有一个运行的服务器功能，我对任务完成的指示是我使用 StreamSubscription 监听的标志。StreamSubscription 侦听代码用 Future 异步函数包装，但我无法理解如何从 StreamSubscription 的函数处理程序返回 Future。
static Future<bool> listenToProcess(
String doc, Function func) {
StreamSubscription<DocumentSnapshot> stream = Firestore.instance.collection('requests').document(doc)
.snapshots().listen((data){
if (data.data["done"])
func(true);
print ("change " + data.data["done"].toString());
});
}
该函数应等待流获得 done=true 未来答案。
我正在与 Slick 和 Cats 合作。
database.run返回 a Future，但我需要我的类的方法（泛型 on F[_]: Async）来返回 monad F。我可以让它像这样工作
val future = database.run(insertion)
val result = Await.result(future, Duration.Inf)
Async[F].delay(result)
但这肯定不是应该做的方式，因为它阻塞了线程。
有没有合适的方法来做到这一点？
这就是我正在做的：
-> 使用 FirebaseAuthentification 登录/注册 Firebase
-> 监听 AuthStateDidChangeListenerHandle
-> 我在 Firestore 中存储额外的用户信息，因此我检查 Firestore 中是否存在该用户
-> 如果用户不存在，我创建一个空用户
-> 如果一切成功，我通过回调返回未来发布者（我也想更改它）
这是 checkLoginState 函数：
func checkLoginState(completion: @escaping (AnyPublisher<AccountDetails,Error>) -> Void) {
self.handler = Auth.auth().addStateDidChangeListener { [weak self] auth, user in
guard let safeSelf = self else { return }
completion(Future<AccountDetails,Error> { promise in
if let user = user {
print(user)
print(auth)
safeSelf.checkIfUserIsInDatabase(user: user.uid) { result in
switch result {
case .success(let isAvailable):
if isAvailable {
promise(.success(AccountDetails(userUID: user.uid,name: user.displayName, loggedIn: true, premiumUser: false))) …我有一个使用 for-comprehension 运行数据库查询的代码：
val totalFeeNoticeAmountFromDB = Future(/..Doing db job../)(executionContext)
val listOfRestrictedFundFromDB = Future(/..Doing db job../)(executionContext)
val res = for {
totalFeeNoticeAmount <- totalFeeNoticeAmountFromDB
listOfRestrictedFund <- listOfRestrictedFundFromDB
} yield (totalFeeNoticeAmount, listOfRestrictedFund)
我们知道运行 for-comprehension 我们需要传递隐式执行上下文。但在这种情况下，我想手动传递执行上下文。
方法是什么？
编辑：
val res = for {
totalFeeNoticeAmount <-(?:ExecutionContext) totalFeeNoticeAmountFromDB
listOfRestrictedFund <-(?:ExecutionContext) listOfRestrictedFundFromDB
} yield (totalFeeNoticeAmount, listOfRestrictedFund)
totalFeeNoticeAmountFromDB并且listOfRestrictedFundFromDB都是 Future 类型已经启动。
有什么办法可以通过这里
<-(?:ExecutionContext)吗？
正在看clojure第 9 章底部的练习，寻找勇敢和真实的人 （特别是搜索多个引擎并返回每个引擎的第一次命中的最后一个）
我用 slurp 部分嘲笑实际搜索是这样的：
(defn search-for
[query engine]
(Thread/sleep 2000)
(format "https://www.%s.com/search?q%%3D%s", engine query))
并实现了这样的行为：
(defn get-first-hit-from-each
[query engines]
(let [futs (map (fn [engine]
(future (search-for query engine))) engines)]
(doall futs)
(map deref futs)))
（我知道这里的返回是一个列表，练习要求一个向量，但可以into为此做一个......）
但是当我在 REPL 中运行它时
(time (get-first-hit-from-each "gray+cat" '("google" "bing")))
添加后似乎需要 2 秒doall（因为 map 返回一个惰性 seq，我认为除非我使用 seq，否则任何期货都不会启动，(last futs)似乎也有效）但是当我time在 REPL 中使用宏时，它会报告即使需要 2 秒，也几乎不消耗时间：
(time (get-first-hit-from-each "gray+cat" '("google" "bing")))
"Elapsed time: 0.189609 msecs"
("https://www.google.com/search?q%3Dgray+cat" "https://www.bing.com/search?q%3Dgray+cat") …我正在尝试使用一个简单的求和任务来测试多线程，我想在其中比较单线程与多线程。
单线程：
long long summation(int start, int end)
{
long long total = 0;
for (int i = start; i < end; i++)
{
total += i;
}
return total;
}
和多线程：
long long threadedSummation(int numThreads, int start, int end)
{
long long total = 0;
int summationRange = (start + end) / numThreads; //The range of numbers for every thread to calculate
for (int i = 0; i < numThreads; i++)
{
int start = summationRange * i;
int …我是 Scala 和 Futures 的新手。我的场景如下 -
val futureTotalCount : Future[Int]
val futureProcessedCount : Future[Int]
//I need to find the difference of above two futures to get unProcessedCount, something like-
val futureUnProcessedCount : Future[Int] = (futureTotalCount - futureProcessedCount)
在 Scala 中可能有这样的事情吗？
我是 Scala 和Future. 在如下场景中
val a = Future(10)
println(a)
val b = Future{20}
println(b)
输出是
Future(Success(10))
Future(<not completed>)
我不明白为什么使用花括号会改变输出。或者这两个Futures的基本区别是什么。