mapN over compos

Question

我知道我可以编写Apply来处理嵌套结构，比如

def mapAll[A, B, C, D](o1: List[Option[A]],
                       o2: List[Option[B]],
                       o3: List[Option[C]])
                      (f: (A, B, C) => D)
: List[Option[D]] = {
  import cats._
  import cats.implicits._
  Apply[List].compose[Option].map3(o1, o2, o3)(f)
}

但是，有没有办法说服编译器接受(o1, o2, o3).mapN(f)而不是Apply[List].compose[Option].map3(o1, o2, o3)(f)，以便使用组合的mapN来应用Apply？

Answer 1

这正是cats.data.Nested的用途：

def mapAll[A, B, C, D](o1: List[Option[A]],
                       o2: List[Option[B]],
                       o3: List[Option[C]])
                      (f: (A, B, C) => D)
: List[Option[D]] = {
  import cats.data.Nested
  import cats.instances.list._, cats.instances.option._
  import cats.syntax.apply._

  (Nested(o1), Nested(o2), Nested(o3)).mapN(f).value
}

（注意，你需要为上面的代码启用-Ypartial-unification编译器标志来编译。或者你可以添加一些类型参数，但是我不知道他们需要的确切位置，如果你无论如何，与Cats -Ypartial-unification做任何事都是非常必要的。）

您也可以隐式地使组合实例可用：

import cats.Apply
import cats.instances.list._, cats.instances.option._
import cats.syntax.apply._

type ListOption[x] = List[Option[x]]

implicit val listOptionApply: Apply[ListOption] = Apply[List].compose[Option]

def mapAll[A, B, C, D](o1: ListOption[A],
                       o2: ListOption[B],
                       o3: ListOption[C])
                      (f: (A, B, C) => D)
: List[Option[D]] = (o1, o2, o3).mapN(f)

这实际上并不理想，但它非标准且非常脆弱（例如，类型别名是指导解决方案所必需的）。

在我看来，你最好的选择就是明确地写出Apply[List].compose[Option]并跳过花哨的元组语法，但如果你真的必须使用花哨的元组语法，请使用Nested。