Question

我正在试图弄清楚如何使用scalaz7 IO和monad变换器以优雅的纯函数风格编写这段代码，但却无法理解它。

想象一下，我有这个简单的API：

def findUuid(request: Request): Option[String] = ???
def findProfile(uuid: String): Future[Option[Profile]] = redisClient.get[Profile](uuid)

使用这个API我可以轻松地用OptionT变换器编写不纯的函数，如下所示：

val profileT = for {
  uuid <- OptionT(Future.successful(findUuid(request)))
  profile <- OptionT(findProfile(uuid))
} yield profile
val profile: Future[Option[Profile]] = profileT.run

正如您所注意到的 - 此函数包含带副作用的findProfile（）。我想在IO monad中隔离这个效果并解释纯函数之外但不知道如何将它们组合在一起。

def findProfileIO(uuid: String): IO[Future[Option[Profile]]] = IO(findProfile(uuid))

val profileT = for {
  uuid <- OptionT(Future.successful(findUuid(request)))
  profile <- OptionT(findProfileIO(uuid)) //??? how to put Option inside of the IO[Future[Option]]
} yield profile
val profile = profileT.run //how to run transformer and interpret IO with the unsafePerformIO()???

关于如何做到的任何和平建议？

Answer 1

IO对于同步效果意味着更多。 Task更符合您的要求！请参阅此问题和答案：What's the difference between Task and IO in Scalaz?

您可以将Future转换为Task，然后使用以下API：

def findUuid(request: Request): Option[String] = ??? 
def findProfile(uuid: String): Task[Option[Profile]] = ???

这是有效的，因为Task可以表示同步和异步操作，因此findUuid也可以包含在Task而不是IO中。

然后你可以将它们包装在OptionT：

中

val profileT = for {
  uuid <- OptionT(Task.now(findUuid(request)))
  profile <- OptionT(findProfileIO(uuid))
} yield profile

然后在某处你可以运行它：

profileT.run.attemptRun

查看此链接以将期货转换为任务，反之亦然：Scalaz Task <-> Future

Answer 2

最后得到这段代码，认为它可能对某人有用（Play 2.6）。

Controller方法是一个纯函数，因为Task评估发生在PureAction ActionBuilder内部的控制器之外。感谢Luka的回答！

尽管仍然在Play 2.6中使用Action组合的新范例，但这是另一个故事。

<强> FrontendController.scala：

def index = PureAction.pure { request =>
  val profileOpt = (for {
    uuid <- OptionT(Task.now(request.cookies.get("uuid").map(t => uuidKey(t.value))))
    profile <- OptionT(redis.get[Profile](uuid).asTask)
  } yield profile).run
  profileOpt.map { profileOpt =>
    Logger.info(profileOpt.map(p => s"User logged in - $p").getOrElse("New user, suggesting login"))
    Ok(views.html.index(profileOpt))
  }
}

<强> Actions.scala

最后使用任务分辨率的便捷行动

class PureAction @Inject()(parser: BodyParsers.Default)(implicit ec: ExecutionContext) extends ActionBuilderImpl(parser) {
  self =>
  def pure(block: Request[AnyContent] => Task[Result]): Action[AnyContent] = composeAction(new Action[AnyContent] {
    override def parser: BodyParser[AnyContent] = self.parser
    override def executionContext: ExecutionContext = self.ec
    override def apply(request: Request[AnyContent]): Future[Result] = {
      val taskResult = block(request)
      taskResult.asFuture //End of the world lives here
    }
  })
}

<强> Converters.scala

任务 - ＆gt;未来和未来 - ＆gt;任务隐式转换器

implicit class FuturePimped[+T](root: => Future[T]) {
  import scalaz.Scalaz._
  def asTask(implicit ec: ExecutionContext): Task[T] = {
    Task.async { register =>
      root.onComplete {
        case Success(v) => register(v.right)
        case Failure(ex) => register(ex.left)
      }
    }
  }
}

implicit class TaskPimped[T](root: => Task[T]) {
  import scalaz._
  val p: Promise[T] = Promise()
  def asFuture: Future[T] = {
    root.unsafePerformAsync {
      case -\/(ex) => p.failure(ex); ()
      case \/-(r) => p.success(r); ()
    }
    p.future
  }
}

IO和未来[选项] monad变换器

2 个答案: