当我使用"Reader monad"进行依赖注入时,如何注入多个依赖项？

Question

我正在尝试Reader monad用于依赖注入,但是当方法需要不同的依赖项时会遇到问题:

class PageFetcher {
  def fetch(url: String) = Reader((dep1: Dep1) => Try {
    ...
  })
}

class ImageExtractor {
  def extractImages(html: String) = Reader((deps: (Dep2, Dep3)) => {
    ...
  })
}


object MyImageFinder {
  def find(url: String) = Reader((deps: (PageFetcher, ImageExtractor)) => {
    val (pageFetcher, imageExtractor) = deps
    for {
      htmlTry <- pageFetcher.fetch(url)
      html <- htmlTry
      images <- imageExtractor.extractImages(html)
    } yield images
  })
}

// I add these 3 useless dependencies here just for demo
class Dep1

class Dep2

class Dep3

你可以看到PageFetcher.fetch,并ImageExtractor.extractImages和MyImageFinder.find所有有不同的相关性.

我不确定我是否使用Reader正确的方式,很快当我将它们组合在一起并希望传递依赖关系时,我不知道该怎么做:

val pageFetcher = new PageFetcher
val imageExtractor = new ImageExtractor
val dep1 = new Dep1
val dep2 = new Dep2
val dep3 = new Dep3

def main(args: Array[String]) {
  args.headOption match {
    case Some(url) =>
      MyImageFinder.find(url)(???) match {
        case Success(images) => images.foreach(println)
        case Failure(err) => println(err.toString)
      }
    case _ => println("Please input an url")
  }
}

注意代码MyImageFinder.find(url)(???),我想传递依赖关系pageFetcher/imageExtractor/dep1/dep2/dep3,无论我怎么试,它都无法编译.

我的使用方法Reader是否正确？如何轻松传递依赖项？

Answer 1

如果要在for-comprehension中使用多个读者,则参数类型必须相同,不管是这样还是另一种.一种简单的方法就是将所有内容捆绑在一个环境类型中(它可能只是一个元组),然后将其用作所有读者的依赖项.

但是,这会抛弃关于类型中细粒度依赖关系的大量信息,并且您还可以将其local用作for-comprehension中输入的一种映射:

case class Foo(i: Int)
case class Bar(s: String)
case class Config(foo: Foo, bar: Bar)

val doSomethingWithFoo: Reader[Foo, String] = Reader(foo => "hello " * foo.i)
val doSomethingWithBar: Reader[Bar, String] = Reader(bar => s"bar is $bar")

val doSomethingWithConfig: Reader[Config, String] = for {
  resFoo <- doSomethingWithFoo.local(_.foo)
  resBar <- doSomethingWithBar.local(_.bar)
} yield (resFoo, resBar)

正如map一个功能A => B可以改变Reader[E, A]的Reader[E, B],local以E => F改变Reader[F, A]到Reader[E, A],在这种情况下考虑环境的块特定的读者需求和自身喂养它.

请注意,有许多其他组合器Kleisli(更通用的类型 - Reader只是别名Kleisli[Id, _, _])值得一读.

Answer 2

更新:删除自定义flatMap以支持scalaz的Reader

正如Travis已经指出的那样,要使用Reader模式,您需要单个参数函数.因此,为了将它用于多个依赖项,您需要以某种方式将所有依赖项都放入单个参数中.在这里它变得有趣.Travis显示的方式是最简单的方法,但您还必须使用.local调用手动切换环境,如果您需要多个依赖项来计算子树,则需要手动构建本地环境.

另一种方法是让Scala的子类型自动神奇地解决它.只要您的依赖项可以混合使用,组合具有不同或多个依赖项的东西就可以正常工作(如果您实际使用的是scalaz的Reader,那么如果您在Function1上使用flatMap就像某些Reader示例那样).

选项1:杯子蛋糕模式

允许您的依赖项混合的一种方法是剥离蛋糕模式.我称之为杯形蛋糕模式,如果我不得不给它命名,Dick Wall称之为Parfait(参见https://parleys.com/play/53a7d2cde4b0543940d9e55f/chapter28/about).这个想法不是将所有内容都放在蛋糕中,而是将依赖项放入蛋糕中并将其作为上下文对象传递,您可以使用阅读器进行抽象.我们将它应用于您的示例:

// business logic
class PageFetcher {
  def fetch(url: String) = Reader((deps: Dep1Component) => Try {
    ...
  })
}

class ImageExtractor {
  def extractImages(html: String) = Reader((deps: (Dep2Component with Dep3Component)) => {
    ...
  })
}


object MyImageFinder {
  def find(url: String) = 
    for {
      pageFetcher <- Reader((deps: PageFetcherComponent) => dep.pageFetcher)
      imageExtractor <- Reader((deps: ImageExtractorComponent) => dep.imageExtractor)
      htmlTry <- pageFetcher.fetch(url)
      html <- htmlTry
      images <- imageExtractor.extractImages(html)
    } yield images
}

// I add these 3 useless dependencies here just for demo
class Dep1

class Dep2

class Dep3

// cupcake modules
trait PageFetcherComponent{
  def pageFetcher: PageFetcher
}
trait ImageExtractorComponent{
  def imageExtractor: ImageExtractor
}
trait Dep1Component{
  def dep1: Dep1
}
trait Dep2Component {
  def dep2: Dep2
}
trait Dep3Component{
  def dep3: Dep3
}

object Dependencies extends PageFetcherComponent with ImageExtractorComponent with Dep1Component with Dep2Component with Dep3Component{
  val pageFetcher = new PageFetcher
  val imageExtractor = new ImageExtractor
  val dep1 = new Dep1
  val dep2 = new Dep2
  val dep3 = new Dep3
}

def main(args: Array[String]) {
  args.headOption match {
    case Some(url) =>
      MyImageFinder.find(url)(Dependencies) match {
        case Success(images) => images.foreach(println)
        case Failure(err) => println(err.toString)
      }
    case _ => println("Please input an url")
  }
}

如果您有多个相同依赖项的实例(多个记录器,多个dbs等)并且有一些您希望能够在其中一个上有选择地使用的代码,则cup-cake模式会变得棘手.

选项2:类型索引映射

我最近提出了另一种使用特殊数据结构的方法,我称之为类型索引映射.它保存了所有的cup-cake锅炉板,使得使用相同类型依赖的多个实例变得更加容易(即只需将它们包装在单个成员类中以区分它们).

/** gets stuff out of a TMap */
def Implicit[V:TTKey] = Reader((c: TMap[V]) => c[V])

// business logic
class PageFetcher {
  def fetch(url: String) = Implicit[Dep1].map{ dep1 => Try {
    ...
  }}
}

class ImageExtractor {
  def extractImages(html: String) = for{
    dep2 <- Implicit[Dep1]
    dep3 <- Implicit[Dep3]
  } yield {
    ...
  }
}


object MyImageFinder {
  def find(url: String) = 
    for {
      pageFetcher <- Implicit[PageFetcherComponent]
      imageExtractor <- Implicit[ImageExtractorComponent]
      htmlTry <- pageFetcher.fetch(url)
      html <- htmlTry
      images <- imageExtractor.extractImages(html)
    } yield images
}

// I add these 3 useless dependencies here just for demo
class Dep1

class Dep2

class Dep3

val Dependencies =
  TMap(new PageFetcher) ++
  TMap(new ImageExtractor) ++
  TMap(new Dep1) ++
  TMap(new Dep2) ++
  TMap(new Dep3)

def main(args: Array[String]) {
  args.headOption match {
    case Some(url) =>
      MyImageFinder.find(url)(Dependencies) match {
        case Success(images) => images.foreach(println)
        case Failure(err) => println(err.toString)
      }
    case _ => println("Please input an url")
  }
}

我在这里发布了https://github.com/cvogt/slick-action/.相应的测试用例在这里:https://github.com/cvogt/slick-action/blob/master/src/test/scala/org/cvogt/di/TMapTest.scala#L213它在maven上,但要小心使用它,因为代码是不稳定的,并且当前的实现在2.10中不是线程安全的,仅在2.11中,因为它依赖于TypeTags.我可能会在某个时候发布一个适用于2.10和2.11的版本.

附录 虽然这解决了使用阅读器monad的多依赖注入,但仍然会出现htmlTry的类型错误,因为您将Reader/Function1-composition与Try-composition混合在一起.解决方案是创建一个包装Monad,它在内部包装Function1 [TMap [...],尝试[...]]并允许组合它们.这确实需要你将所有内容都填充到这种类型的monad中,即使某些东西不需要Try.