2

我创建了一个简单的trait和他的实现：

trait UserRepositoryAlg[F[_]] {

  def find(nick: String): F[User]

  def update(user: User): F[User]
}

class UserRepositoryInterpreter extends UserRepositoryAlg[Either[Error, *]] {
  override def find(nick: String): Either[Error, User] = for {
    res <- users.find(user => user.nick == nick).toRight(UserError)
  } yield res

  override def update(user: User): Either[Error, User] = for {
    found <- users.find(u => u.nick == user.nick).toRight(UserError)
    updated = found.copy(points = found.points + user.points)
  } yield updated
}

在这里，我想使用EitherorEitherT来“捕捉”错误，但我也想使用IOorFuture作为主要的单子。在我的主类中，我创建了对此实现的调用：

 object Main extends App {

  class Pointer[F[_] : Monad](repo: UserRepositoryAlg[F]) {
    def addPoints(nick: String): EitherT[F, Error, User] = {
      for {
        user <- EitherT.right(repo.find(nick))
        updated <- EitherT.right(repo.update(user))
      } yield Right(updated)
    }
  }
  val pointer = new Pointer[IO](new UserRepositoryInterpreter{}).addPoints("nick")
}

但是在pointer创建的行中，IntelliJ 向我显示了一个错误：Type mismatch - required: UserRepositoryAlg[F], found: UserRepositoryInterpreter我不明白为什么。我用as 创建了一个Pointer类，并想使用. 我该如何解决这个问题或者在这种情况下有什么好的做法？如果我想实现这样的目标：或.F[_]IOUserRepositoryAlg[F]IO[Either[Error, User]]EitherT[IO, Error, User]

我试图改变class UserRepositoryInterpreter extends UserRepositoryAlg[Either[Error, *]]成类似的东西class UserRepositoryInterpreter[F[_]] extends UserRepositoryAlg[F[Either[Error, *]]]，但它对我没有帮助。

编辑： 我发现了如何F[Either[Error,User]]使用Applicative[F]which transform返回A => F[A]：

class UserRepositoryInterpreter[F[_] : Applicative] extends UserRepositoryAlg[F[Either[Error, *]]] {
  override def find(nick: String): F[Either[Error, User]] = for {
    res <- Applicative[F].pure(users.find(user => user.nick == nick).toRight(UserError))
  } yield res

  override def update(user: User): F[Either[Error, User]] = for {
    found <- Applicative[F].pure(users.find(u => u.nick == user.nick).toRight(UserError))
    updated = Applicative[F].pure(found.map(u => u.copy(points = u.points + user.points)))
  } yield updated
}

但是我在 main 函数中仍然存在问题，因为我无法获得以下Right值Either：

 def addPoints(nick: String): EitherT[F, Error, User] = {
      for {
        user <- EitherT.liftF(repo.find(nick))
        updated <- EitherT.rightT(repo.update(user))
      } yield Right(updated)
    }

这里updated <- EitherT.rightT(repo.update(user)) user是Either[Error, User]，但我只需要通过User。所以我尝试做类似的事情： Right(user).map(u=>u)并通过它，但它也无济于事。我应该如何取这个值？

4

1 回答 1

3

F[_]描述你的主要影响。理论上，您可以使用任何 monad（甚至任何更高种类的类型），但在实践中，最好的选择是 monad，它允许您像cats-effector一样暂停执行Future。

你的问题是你试图IO用作你的主要效果，但UserRepositoryInterpreter你的设置Either为你的F.

你应该做的只是参数化UserRepositoryInterpreter，你可以选择你的效果单子。如果你想同时使用Either处理错误和F暂停效果，你应该使用 monad stack F[Either[Error, User]]。

示例解决方案：

import cats.Monad
import cats.data.EitherT
import cats.effect.{IO, Sync}
import cats.implicits._

case class User(nick: String, points: Int)

trait UserRepositoryAlg[F[_]] {

  def find(nick: String): F[Either[Error, User]]

  def update(user: User): F[Either[Error, User]]
}

//UserRepositoryInterpreter is parametrized, but we require that F has typeclass Sync,
//which would allow us to delay effects with `Sync[F].delay`.
//Sync extends Monad, so we don't need to request is explicitly to be able to use for-comprehension
class UserRepositoryInterpreter[F[_]: Sync] extends UserRepositoryAlg[F] {

  val users: mutable.ListBuffer[User] = ListBuffer()

  override def find(nick: String): F[Either[Error, User]] = for {
    //Finding user will be delayed, until we interpret and run our program. Delaying execution is useful for side-effecting effects,
    //like requesting data from database, writting to console etc.
    res <- Sync[F].delay(Either.fromOption(users.find(user => user.nick == nick), new Error("Couldn't find user")))
  } yield res


  //we can reuse find method from UserRepositoryInterpreter, but we have to wrap find in EitherT to access returned user
  override def update(user: User): F[Either[Error, User]] = (for {
    found <- EitherT(find(user.nick))
    updated = found.copy(points = found.points + user.points)
  } yield updated).value
}

object Main extends App {

  class Pointer[F[_] : Monad](repo: UserRepositoryAlg[F]) {
    def addPoints(nick: String): EitherT[F, Error, User] = {
      for {
        user <- EitherT(repo.find(nick))
        updated <- EitherT(repo.update(user))
      } yield updated
    }
  }

  //at this point we define, that we want to use IO as our effect monad
  val pointer = new Pointer[IO](new UserRepositoryInterpreter[IO]).addPoints("nick")

  pointer.value.unsafeRunSync() //at the end of the world we run our program

}
于 2019-11-08T13:36:02.217 回答