Scala未来派生的可观察回调未被调用

使用scala 2.11.7、rxscala_2.11 0.25.0、rxjava 1.0.16，my

oddFutures

回调不会在

AsyncDisjoinedChunkMultiprocessing.process（）中被调用：

包jj.async
导入scala.concurrent.Future
导入scala.concurrent.ExecutionContext
导入rx.lang.scala.Observable
导入jj.async.helpers_
/*问题：如何在块中异步处理多个记录。
处理步骤：
-从存储库中获取有限的记录（每次10条(
如果（赔率.size+oddsBuffer.size>=chunkSize）{
val chunkReach=chunkSize-oddsBuffer.size
val poors=oddsBuffer++赔率
enrichedFutures=enrichedFutures+poors
oddsBuffer=赔率下降
}否则{
oddsBuffer++=赔率
},
错误=>抛出错误，
（）=>enrichedFutures+oddsBuffer）
enrichedFutures.Toblock.toList.flatten
}
私有期货：可观察[Set[Int]]=
Repository.query（chunkSize）{chunk=>
未来（区块）图{
filtered=>chunk——filtered
}
}
private-def-evenFuture（块：Set[Int]）：Future[Set[Int]={
checkSizeLimit（块）
未来{远程偶数块}
}
}
类（i:Int）
对象丰富{
def应用（i:Int）=新增加（i）
def浓缩（poors:Set[Int]）：Set[FUNCHED]={
检查尺寸限值（poors）；
线程。睡眠（1000）
poors映射{富集（)}
}
}
对象存储库{
def查询（fetchSize:Int）（f:Set[Int]=>Future[Set[Int]]）：可观察的[Set[Int]={
隐式val ec=ExecutionContext.global
可见的{
线程。睡眠（20）
（第（1、2、3、4、5、6、7、8、9、10）组）
线程。睡眠（20）
（一套（11、12、13、14、15、16、17、18、19、20））
线程。睡眠（15）
（一套（21、22、23、24、25））
}
}
}
包对象帮助程序{
val chunkSize=10
隐式类EnrichedObservable（enrichedObs:Observable[Set[Enriched]]{
def+（poors:Set[Int]）：可观察的[Set[FUNCED]={
enrichedObs合并可观察到{
丰富的，丰富的
}
}
}
def checkSizeLimit（set:set[uuChunkSize）抛出新的IllegalArgumentException（s“$chunkSize元素限制被违反：${set.size}”）
}
//不可修改
对象远程{
def偶数={xs:Set[Int]=>
线程。睡眠（1500）
xs筛选器{{%2==0}
}
}

在
Repository.query（）
）中创建我的
observatable.from（Future）
的方法是否有问题？
问题是，我试图从多个未来创建一个observatable，但只提供一个单一的未来（编译器没有抱怨，因为我不小心省略了分隔逗号，从而篡夺了一个毫无疑问的重载）。我的解决方案：

object Repository {
  def query(f: Set[Int] => Future[Set[Int]])(fetchSize: Int = 10): Observable[Future[Set[Int]]] =
    // observable (as opposed to list) because modeling a process 
    // where the total result size is unknown beforehand. 
    // Also, not creating or applying because it blocks the futures
    (1 to 21 by fetchSize).foldLeft(Observable just Future((Set[Int]()))) { (obs, i) =>
      obs + f(DataSource.fetch(i)())
    }
}

object DataSource {
  def fetch(begin: Int)(fetchSize: Int = 10) = {
    val end = begin + fetchSize
    Thread.sleep(200)
    (for {
      i <- begin until end
    } yield i).toSet
  }
}

object Repository {
  def query(f: Set[Int] => Future[Set[Int]])(fetchSize: Int = 10): Observable[Future[Set[Int]]] =
    // observable (as opposed to list) because modeling a process 
    // where the total result size is unknown beforehand. 
    // Also, not creating or applying because it blocks the futures
    (1 to 21 by fetchSize).foldLeft(Observable just Future((Set[Int]()))) { (obs, i) =>
      obs + f(DataSource.fetch(i)())
    }
}

object DataSource {
  def fetch(begin: Int)(fetchSize: Int = 10) = {
    val end = begin + fetchSize
    Thread.sleep(200)
    (for {
      i <- begin until end
    } yield i).toSet
  }
}

implicit class FutureObservable(obs: Observable[Future[Set[Int]]]) {
  def +(future: Future[Set[Int]]) =
  obs merge (Observable just future)
}