Scala：将特征方法推迟到父特征对象中的隐式类

Question

具体来说，我正在尝试使用Applicative 扩展我的Functor 类型类。

trait Functor[F[_]] {
  def fmap[A, B](r: F[A], f: A => B): F[B]
}

object Functor {
  implicit class FunctorOps[A, F[_]: Functor](xs: F[A]) {
    def fmap[B](f: A => B): F[B] = implicitly[Functor[F]].fmap(xs, f)
  }

  implicit def SeqFunctor: Functor[Seq] = new Functor[Seq] {
    def fmap[A, B](r: Seq[A], f: A => B) = r map f
  }
}

trait Applicative[F[_]] extends Functor[F] {
// What I want to do, but this *does not* work.
  def fmap[A, B](r: F[A], f: A => B): F[B] = Functor.FunctorOps[A, F](r).fmap(f)

  def pure[A](x: A): F[A]
  def fapply[A, B](r: F[A], f: F[A => B]): F[B]
}

object Applicative {
  implicit class ApplicativeOps[A, F[_]](a: F[A])(implicit F: Applicative[F]) {
    def fapply[B](f: F[A => B]): F[B] = F.fapply(a, f)
  }

  implicit def SeqApplicative: Applicative[Seq] = new Applicative[Seq] {
    def pure[A](x: A) = Seq(x)
    def fapply[A, B](xs: Seq[A], fs: Seq[A => B]): Seq[B] = xs.flatMap(x => fs.map(_(x)))
  }
}

它的要点是我必须为所有Applicatives 实现fmap，但它实际上应该与我的FunctorOps 类中定义的方法相同。我该如何以最简洁的方式做到这一点？

Answer 1

Applicative[F] <: Functor[F] 部分是正确的，但你应该认真考虑这意味着什么。这意味着Applicative[F] 的一个实例也 提供了Functor[F] 的方法。也就是说，您不能同时拥有implicit val listFunctor: Functor[List]; implicit val listApplicative: Applicative[List]，因为当您请求implicit param: Functor[List] 时，编译器会感到困惑。你应该只有后者。然后，您尝试做的事情是荒谬的，因为您正在根据自身定义F 的Functor 实例（因为Applicative[F] 应该成为 Functor[F]），无论如何，你最终都会得到两个Functor[Seq]s。

你可以做的是在pure和fapply方面实现fmap：

trait Applicative[F[_]] extends Functor[F] {
  override def fmap[A, B](r: F[A], f: A => B): F[B] = fapply(r, pure(f))

  def pure[A](x: A): F[A]
  def fapply[A, B](r: F[A], f: F[A => B]): F[B]
}

然后删除 Functor[Seq] 实例并保持您的 Applicative[Seq] 原样（或根据需要覆盖 fmap）。你现在有一个不同的问题，因为隐式搜索有点转向，因为Functor[Seq] 实例实际上在object Applicative 中，但是修复隐式解析比强制独立的Functor 和Applicative 的一致性要简单实例。在这种情况下，Seq 是您无法控制其伴生对象的类型，cats 至少会执行类似

package instances {
  trait SeqInstances {
    implicit val seqFunctor: Functor[Seq] = ???
  }
  package object seq extends SeqInstances
  package object all extends SeqInstances
                        with AAAInstances
                        with BBBInstances
                        with ...
}

仅供参考：我建议使用你的类型类方法

def fmap[A, B](r: F[A])(f: A => B): F[B]
def fapply[A, B](r: F[A])(f: F[A => B]): F[B]

在ApplicativeOps 中有一个flip fapply 可能会很好

def ylppaf[I, B](f: F[I])(implicit ev: A =:= (I => B))
  : F[B] = F.fapply(a.fmap(ev))(f)