Scala 中依赖注入的读者组成

Question

这是一个简单的服务示例，其方法return reader:

trait Service1_1{
  def s1f1:Reader[Map[String,Int],Int] =
    Reader(_("name"))

  def s1f2:Reader[Map[String,Int],Int] =
    Reader(_("age"))
}

这是一个服务消费者，它接受参数、映射以及 returns reader 本身：

trait Service1_2 {
  def s12f1(i:Int, map:Map[String,Int]):Reader[Service1_1, Int] =
    Reader(s => {
      val r = for {
        r1 <- s.s1f1
        r2 <- s.s1f2
      } yield r1 + r2
      r.run(map) + i
    })
}

好的，要使用 Service1_2.s12f1 我必须在参数列表中有映射：

object s1 extends Service1_1
object s2 extends Service1_2
val r = s2.s12f1(3, Map("age"-> 1, "name"-> 2)).run(s1)

问题：如何实现Service1_2.s12f2：

trait Service1_2 {
  def s2f2 = ???
}

为了能够运行喜欢:

s2.s2f2(2)
  .run(s1)
  .run(Map("age"-> 1, "name"-> 2))

主要思想是推迟将依赖项传递给执行。这应该允许获得更好的组合和延迟执行。如何让它发挥作用？ Readers 的最佳实践是什么，以防存在具有此类依赖关系的嵌套调用。例如，假设服务 Service1_3 在一种方法中将同时使用 Service1_2.s2f2 和 Service1_1.s1f1

UPDATE，好的，我可以实现它，但它看起来太复杂了：

  def s2f2(i:Int): Reader[Service1_1, Reader[Map[String,Int],Int]] =
    Reader(s => Reader(map => {
      val r = for {
        r1 <- s.s1f1
        r2 <- s.s1f2
      } yield r1 + r2
      r.run(map) + i
    }))

问题来了，有没有更好的办法？或者至少语法？因为有几个级别的依赖，它看起来会很奇怪。

Answer 1

我可能会 "uncurry" reader，所以我不会有两层（或更多层）reader，而是有一个 n 元组作为环境。然后你可以 "raise" 更小的 readers 进入当前级别 local.

例如，我会使用 Reader[(Service1_1, Map[String, Int]), Int]:

而不是 Reader[Service1_1, Reader[Map[String, Int], Int]]

import cats.data.Reader

trait Service1_1{
  def s1f1: Reader[Map[String, Int], Int] = Reader(_("name"))
  def s1f2: Reader[Map[String, Int], Int] = Reader(_("age"))
}

trait Service1_2 {
  type Env = (Service1_1, Map[String,Int])

  def s2f2(i: Int): Reader[Env, Int] =
    for {
      s <- Reader((_: Env)._1)
      r1 <- s.s1f1.local((_: Env)._2)
      r2 <- s.s1f2.local((_: Env)._2)
    } yield r1 + r2 + i
}

然后：

scala> object s1 extends Service1_1
defined object s1

scala> object s2 extends Service1_2
defined object s2

scala> s2.s2f2(2).run((s1, Map("age"-> 1, "name"-> 2)))
res0: cats.Id[Int] = 5

这与您的 s2f2 完全相同，除了我们编写 s2.s2f2(2).run((s1, myMap)) 而不是 s2.s2f2(2).run(s1).run(myMap)，甚至只是 s2.s2f2(2).run(s1, myMap) 使用适应的参数。

这种方法的优点是，即使您添加了图层，您也可以通过 local 在单个 for 中组合新的和以前的 reader。 21=]

Scala 中依赖注入的读者组成

Composition of Readers for Dependency Injection in Scala

scala

dependency-injection

composition

scala-cats

reader-monad