Scala无法推断Reader monad实现中的参数类型

Question

我正在使用Scala 2.13，我正在开发自己的Reader monad。 monad的实现如下。

object ReaderMonad {

  implicit def reader[From, To](f: From => To): Reader[From, To] = Reader(f)

  case class Reader[From, To](f: From => To) {
    def run(input: From): To =
      f(input)

    def map[NewTo](transformation: To => NewTo): Reader[From, NewTo] =
      Reader(c => transformation(f(c)))

    def flatMap[NewTo](transformation: To => Reader[From, NewTo]): Reader[From, NewTo] =
      Reader(c => transformation(f(c)).run(c))
  }

  def pure[From, To](a: To): Reader[From, To] = Reader((c: From) => a)
}

使用这样的单子，我正在定义股票的存储库。

trait StockRepository {
    def findAll: Map[String, Double]
}

[Stocks服务使用存储库的实现，并使用Reader monad注入回购依赖项。

object Stocks {
  def findAll: Reader[StockRepository, Map[String, Double]] = 
    (repo: StockRepository) => repo.findAll()
}

我的问题是，为什么我要在最后一个函数定义repo中明确指定(repo: StockRepository) => repo.findAll()参数类型？为什么Scala编译器无法为我隐式推断类型？

非常感谢。

Answer 1

当然，您只需要删除隐式转换并添加apply。但是，如果您有任何疑问，请告诉我。我添加了一些其他更改，以使代码更加惯用且更易于使用。

object ReaderMonad {
  final case class Reader[From, To] private[ReaderMonad] (run: From => To) {
    def map[NewTo](transformation: To => NewTo): Reader[From, NewTo] =
      Reader(c => transformation(run(c)))

    def flatMap[NewTo](transformation: To => Reader[From, NewTo]): Reader[From, NewTo] =
      Reader(c => transformation(run(c)).run(c))
  }

  // This is all you really need.
  def apply[From, To](f: From => To): Reader[From, To] =
    Reader(run = f)

  // This is called the parially applied trick:
  // https://typelevel.org/cats/guidelines.html
  // It makes easier to use pure.
  private[ReaderMonad] final class PurePartiallyApplied[From](private val dummy: Boolean) extends AnyVal {
    @inline
    final def apply[To](a: To): Reader[From, To] =
      Reader(_ => a)
  }

  // So now, you can just:
  // ReaderMonad.pure[String](10)
  // Instead of:
  // ReaderMonad.pure[String, Int](10)
  def pure[From]: PurePartiallyApplied[From] =
    new PurePartiallyApplied(dummy = true)
}

您可以这样使用它：

trait StockRepository {
  def findAll: Map[String, Double]
}

object Stocks {
  import ReaderMonad.Reader

  def findAll: Reader[StockRepository, Map[String, Double]] =
   ReaderMonad { repo =>
     repo.findAll
  }
}