scala – 如何使用Future [M [_]]使用免费monad

通过制作Fetch和Store a Future [List [Record]]]的预期结果类型,可以限制如何解释此代数的可能性.也许在您的测试中,您不希望异步连接到Web服务或数据库,只想使用Map [Int,Result]或Vector [Result]进行测试,但现在您需要返回一个Future,测试比它们更复杂.

但是说你不需要ETL [Future [List [Record]]]并没有解决你的问题：你正在使用异步库而你可能想要返回一些Future.

从第一次实施开始：

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import cats.implicits._
import cats.free.Free

type Record = String
type Response = String

sealed trait EtlOp[T]
case class Fetch(offset: Int,amount: Int) extends EtlOp[List[Record]]
case class Store(recs: List[Record]) extends EtlOp[List[Response]]

type ETL[A] = Free[EtlOp,A]

def fetch(offset: Int,amount: Int): ETL[List[Record]] = 
  Free.liftF(Fetch(offset,amount))
def store(recs: List[Record]): ETL[List[Response]] = 
  Free.liftF(Store(recs))

def fetchStore(offset: Int,amount: Int): ETL[List[Response]] =
  fetch(offset,amount).flatMap(store)

但现在我们还没有期货？这是我们翻译的工作：

import cats.~>

val interpretFutureDumb: EtlOp ~> Future = new (EtlOp ~> Future) {
  def apply[A](op: EtlOp[A]): Future[A] = op match {
    case Store(records) => 
      Future.successful(records.map(rec => s"Resp($rec)"))
      // store in DB,send to webservice,...
    case Fetch(offset,amount) =>
      Future.successful(List.fill(amount)(offset.toString))
      // get from DB,from webservice,...
  }
}

有了这个解释器(当然你会用更有用的东西替换Future.successful(…))我们可以得到我们的Future [List [Response]]：

val responses: Future[List[Response]] = 
  fetchStore(1,5).foldMap(interpretFutureDumb)

val records: Future[List[Record]] = 
  fetch(2,4).foldMap(interpretFutureDumb)

responses.foreach(println)
// List(Resp(1),Resp(1),Resp(1))
records.foreach(println)
// List(2,2,2)

但是我们仍然可以创建一个不会返回Future的不同解释器：

import scala.collection.mutable.ListBuffer
import cats.Id

val interpretSync: EtlOp ~> Id = new (EtlOp ~> Id) {
  val records: ListBuffer[Record] = ListBuffer()
  def apply[A](op: EtlOp[A]): Id[A] = op match {
    case Store(recs) => 
      records ++= recs
      records.toList
    case Fetch(offset,amount) =>
      records.drop(offset).take(amount).toList
  }
}

val etlResponse: ETL[List[Response]] =
  for { 
    _       <- store(List("a","b","c","d"))
    records <- fetch(1,2)
    resp    <- store(records)
  } yield resp

val responses2: List[Response] = etlResponse.foldMap(interpretSync)
// List(a,b,c,d,c)