Question

我有一个函数get: T => scala.concurrent.Future[T]

我想迭代它：

   val futs: Iterator[Future[T]] = Iterator.iterate(get(init)){
        _.flatMap(prev => get(prev))
   }

但是Iterator的类型是Future[T]，处理这个迭代器并不容易。

我怎样才能将其转移到Process[?, T]

（也许T => Future[T]作为上下文类型F）。

Answer 1

不是超级好的解决方案，但有效

  import scala.concurrent.ExecutionContext.Implicits.global
  import scala.concurrent.{Future => SFuture}
  import scala.language.implicitConversions
  import scalaz.concurrent.Task
  import scalaz.stream._

  implicit class Transformer[+T](fut: => SFuture[T]) {
    def toTask(implicit ec: scala.concurrent.ExecutionContext): Task[T] = {
      import scala.util.{Success, Failure}
      import scalaz.syntax.either._
      Task.async {
        register =>
          fut.onComplete {
            case Success(v) => register(v.right)
            case Failure(ex) => register(ex.left)
          }
      }
    }
  }

  val init: Int = 0

  def f(i: Int): SFuture[Int] = SFuture(i + 1)

  val p = Process.repeatEval[Task, Int] {
    var prev = init
    f(prev).toTask.map(next => {prev = next; next})
  }

  println(p.take(10).runLog.run)

Answer 2

假设您知道如何转换Future - ＆gt;任务（通过隐式或通过Process.transform）这将起作用：

def get(t:T): Task[T] = ???
val initial : T = ???   

val signal = scalaz.stream.async.signal[T]

// emit initial value, and follow by any change of `T` within the signal
val source:Process[Task,T] =  eval_(signal.set(t)) fby  signal.discrete

// sink to update `T` within the signal 
val signalSink:Sink[Task,T] = constant((t:T) => signal.set(t))

// result, that esentially converts T => Task[T] into Process[Task,T]
val result: Process[Task,T] = source.observe(signalSink)

Answer 3

最后我得到了Pavel Chlupacek想说的话。信号看起来很酷，但初学者有点神秘。

  import scala.concurrent.{Future => SFuture}
  import scala.language.implicitConversions
  import scalaz.concurrent.Task
  import scalaz.stream._
  import scala.concurrent.ExecutionContext.Implicits.global

  implicit class Transformer[+T](fut: => SFuture[T]) {
    def toTask(implicit ec: scala.concurrent.ExecutionContext): Task[T] = {
      import scala.util.{Failure, Success}
      import scalaz.syntax.either._
      Task.async {
        register =>
          fut.onComplete {
            case Success(v) => register(v.right)
            case Failure(ex) => register(ex.left)
          }
      }
    }
  }

  val init: Int = 0

  def f(i: Int): SFuture[Int] = SFuture(i + 1)

  val signal = scalaz.stream.async.signal[Int]

  // Observe value and push them to signal
  val signalSink: Process[Task, Int => Task[Unit]] = // =:= Sink[Task, Int]
    Process.constant((input: Int) => signal.set(input))

  // Start from init and then consume from signal
  val result = (Process.eval(f(init).toTask) ++ signal.discrete.evalMap(i => f(i).toTask)) observe signalSink

  println(result.take(10).runLog.run)

Answer 4

我做了另一个解决方案

def iterate[F[_],A](init: A)(f: A => F[A]): Process[F, A] = {
    Process.emit(init) ++ Process.await(f(init)) { next => iterate(next)(f)}
  }

这已经是scalaz-stream 0.6的一项功能，详见<{3}}

为了使用scala.concurrent.Future作为上下文类型F

我们需要import scalaz.std.scalaFuture._和Catchable实例

implicit def futureCatchable(implicit ctx: ExecCtx): Catchable[Future] = {
    new Catchable[Future] {
      def attempt[A](f: Future[A]) = f.map(\/-(_)).recover { case e => -\/(e)}
      def fail[A](err: Throwable) = Future.failed(err)
    }
  }

最后我明白了：

package stream
import scala.concurrent._
import scalaz._
import scalaz.stream._

package object future {
  type ExecCtx = ExecutionContext

  def iterate[F[_],A](init: A)(f: A => F[A]): Process[F, A] = {
    Process.emit(init) ++ Process.await(f(init)) { next => iterate(next)(f)}
  }

  implicit def futureCatchable(implicit ctx: ExecCtx): Catchable[Future] = {
    new Catchable[Future] {
      def attempt[A](f: Future[A]) = f.map(\/-(_)).recover { case e => -\/(e)}
      def fail[A](err: Throwable) = Future.failed(err)
    }
  }
}

object futureApp extends App {
  import scalaz.Scalaz._
  import future._
  import scala.concurrent.ExecutionContext.Implicits.global
  def get(i: Int) = Future {
    println(i + 1)
    i + 1
  }
  iterate(0)(get).takeWhile(_ < 100000).run
}

重复eval T =＆gt; scala.concurrent.Future [T]到一个进程[？，T]

4 个答案: