Scala 隐式用于任意深度的 Functor 组合

Question

我正在尝试为 Scala 中的现有类 Elem 提供扩展方法。但是，我还希望任何M[Elem] 都可以使用这些操作，只要M 的Scalaz Functor 在范围内。行为始终是使用map 将操作应用于函子。

import scalaz._
import Scalaz._

class Elem

implicit class Ops[F[_]: Functor, A <% Elem](self: F[A]) {
  def foo = self.map(_ => "bar")
}

val elem = new Elem

// TODO (nice to have): can we avoid this "explicit implicit" conversion?
implicit def idOps[A <% Elem](self: A) = new Ops[Id, A](self)

elem.foo                        // bar
Option(elem).foo                // Some(bar)
List(elem).foo                  // List(bar)

我想更进一步，让我的扩展方法可用于任意深度的函子，例如List[Option[Elem]] 和Option[Option[Option[Elem]]]。我能够为两个函子的组合编写一个隐式提供 Ops，但我无法将其推广到任意嵌套深度：

// TODO: can we improve this to provide arbitrarily deep functor composition?
implicit def compositeOps[F[_]: Functor, G[_]: Functor, A <% Elem](self: F[G[A]]) = {
  implicit val FG = implicitly[Functor[F]].compose[G]
  new Ops[({ type FG[X] = F[G[X]] })#FG, A](self)
}

List(Option(elem)).foo          // List(Some(bar))
Option(List(Option(elem))).foo  // doesn't compile

有什么办法可以做到吗？

Answer 1

您可以递归地使隐式助手可用：

sealed trait Helper[FA] {
  type A
  type F[_]
  def w(fa: FA): F[A]
  val f: Functor[F]
}
trait Helper1 {
  implicit def nil[A] = new Helper[A] {
    type A = A
    type F[X] = X
    def w(a: A) = a
    val f = implicitly[Functor[Id]]
  }
}
object Helper extends Helper1 {
  implicit def cons[FA1, RA](implicit u: Unapply[Functor, FA1]{type A = RA},
    rest: Helper[RA]) = new Helper[FA1] {
    type A = rest.A
    type F[X] = u.M[rest.F[X]]
    def w(fa: FA1) = u.TC.map(u.apply(fa))(rest.w)
    val f = rest.f.compose(u.TC) //or the other way around, I can never remember
  }
}
implicit def compositeOps[FA, A1](self: FA)(
  implicit helper: Helper[FA]{type A = A1}, conv: A1 => Elem) = {
    implicit val FG = helper.f
    new Ops[helper.F, helper.A](helper.w(self))
}

Answer 2

我们可以创建一个特征来代表你想要的

trait DeepFunctor[X, A] {
  type Result[_]
  def map[B](x: X)(f: A => B): Result[B]
}

请注意，它允许将X 映射到Result[B]。 X 在这一点上可以是任何东西。

最简单的版本是我们说X 等于A。结果应该是Id[B]。它被放入一个 trait 以确保它具有低优先级。

trait LowerPriorityDeepFunctor {
  implicit def identity[A] =
    new DeepFunctor[A, A] {
      type Result[x] = Id[x]
      def map[B](x: A)(f: A => B) = f(x)
    }
}

请注意，Id 的Functor 无需询问。

更复杂的版本是X 是定义了Functor 的某个容器。

object DeepFunctor extends LowerPriorityDeepFunctor {
  implicit def deep[F[_], X, A](
    implicit F: Functor[F], inner: DeepFunctor[X, A]) =
    new DeepFunctor[F[X], A] {
      type Result[x] = F[inner.Result[x]]
      def map[B](x: F[X])(f: A => B) = F.map(x)(inner.map(_)(f))
    }
}

deep 方法的结果是DeepFunctor 对应于F[X]。由于我们对X 一无所知，我们为X 请求DeepFunctor。这将递归搜索DeepFunctor 实例，直到找到identity。

您的Ops 类现在变得相对简单

implicit class Ops[X](self: X) {
  def foo[A](implicit F: DeepFunctor[X, A]) = F.map(self)(_ => "bar")
}

请注意，_ 现在的类型为 A。如果要限制为某种类型，可以将A 定义为A <: SomeType。如果您希望能够支持隐式转换，您可以使用额外的隐式参数ev: A => SomeType。如果你想让A成为一个特定的类型，你可以把A去掉，直接把SomeType放到DeepFunctor里面。