-1

我想要类似 runProgram2 的东西，但目前该部分无法编译。有没有办法编写它有点像 runProgram2 但它编译..

package transformer

import scala.concurrent.{ExecutionContext, Promise, Future}
import ExecutionContext.Implicits.global
import java.util.concurrent.TimeUnit
import scala.concurrent.duration.Duration

object TestingForComprehensions2 {

    def main(args: Array[String]) = {
      val future1: Future[String] = runMyProgram()
      future1.onSuccess {
        case r:String =>       System.out.println("result="+r)
      }


      val future2: Future[String] = runMyProgram2()
      future2.onSuccess {
        case r:String =>       System.out.println("result="+r)
      }

      System.out.println("waiting")
      Thread.sleep(600000)
    }

    def runMyProgram() : Future[String] = {
      val future = serviceCall()
      val middle = serviceCallWrap(future)
      val future2 = middle.flatMap(serviceCall2)
      val future3 = future2.map(processAllReturnCodes)
      future3
    }

    def runMyProgram2() : Future[String] = {
      for {
        result1 <- serviceCall()
        middle = serviceCallWrap(result1)
        result2 <-  serviceCall2(middle)
      } yield processAllReturnCodes(result2)
    }

    def processAllReturnCodes(theMsg: String) : String = {
      "dean"+theMsg
    }

    def serviceCall() : Future[Int] = {
      val promise = Promise.successful(5)
      promise.future
    }

    def serviceCallWrap(f:Future[Int]) : Future[Int] = {
      f
    }

    def serviceCall2(count:Int) : Future[String] = {
      val promise = Promise.successful("hithere"+count)
      promise.future
    }

}
4

2 回答 2

1

serviceCallWrap期待未来，但您正在传递Int，第一步是删除result1 <- serviceCall()零件并直接调用middle = serviceCallWrap(serviceCall())。

现在middle是一个未来，但serviceCall2需要一个Int，在这种情况下，您可以使用 提取未来的价值middle <- serviceCallWrap(serviceCall())，所有这些：

def runMyProgram2() : Future[String] = {
  for {
    middle <- serviceCallWrap(serviceCall())
    result2 <-  serviceCall2(middle)
  } yield processAllReturnCodes(result2)
}

如果你想保持理解结构：

def runMyProgram2() : Future[String] = {
  for {
    result1 <- serviceCall()
    middle <- serviceCallWrap(Future(result1))
    result2 <-  serviceCall2(middle)
  } yield processAllReturnCodes(result2)
}

唯一不能保留的（AFAIK）是 的赋值表达式middle，如果你想保留它，你需要更改serviceCall2签名。这种方法虽然与第一种方法的结果完全相同，只是更冗长。

于 2014-08-20T19:25:07.823 回答
0

我想我现在已经弄清楚了。或者至少可以编译，所以我可以在不同的行上做......

def runMyProgram2() : Future[String] = {
  for {
    result1 <- serviceCall()
    middle <- serviceCallWrap(Promise.successful(result1).future)
    result2 <-  serviceCall2(middle)
  } yield processAllReturnCodes(result2)
}
于 2014-08-20T19:38:54.030 回答