function - Scala -- 如何在非函数类型上使用仿函数？

Question

在阅读此博客上对 Functors 的描述时:

https://hseeberger.wordpress.com/2010/11/25/introduction-to-category-theory-in-scala/

有一个 Functor 的通用定义和一个更具体的定义:

trait GenericFunctor[->>[_, _], ->>>[_, _], F[_]] {
  def fmap[A, B](f: A ->> B): F[A] ->>> F[B]
}
trait Functor[F[_]] extends GenericFunctor[Function, Function, F] {
  final def fmap[A, B](as: F[A])(f: A => B): F[B] =
    fmap(f)(as)
}

显然，这意味着除了 Function 对象之外，Functors 还可以与其他更高级的类型一起使用。有人可以举个例子或解释一下如何或为什么或在什么情况下会这样做吗？也就是说，在 Scala 中 GenericFunctor 的另一个实现是什么——它使用与 Function 不同的类型构造函数？谢谢!

编辑:

只是为了澄清:

object Functor {

  def fmap[A, B, F[_]](as: F[A])(f: A => B)(implicit functor: Functor[F]): F[B] =
    functor.fmap(as)(f)

  implicit object ListFunctor extends Functor[List] {
    def fmap[A, B](f: A => B): List[A] => List[B] =
      as => as map f
  }
}
scala> fmap(List(1, 2, 3))(x => x + 1)
res0: List[Int] = List(2, 3, 4)

澄清一下，根据我的理解，ListFunctor 在 GenericFunctor 中实现了 1-arg fmap，而 repl 脚本中的代码调用了 Trait Functor 中的 fmap，而 Trait Functor 又调用了 fmap 实现(例如在 ListFunctor 中)。

这不会改变整体问题，只是认为它会帮助人们尝试提供答案。提供的任何见解将不胜感激。

Answer 1

在您的示例中 Functor是 Scala 类型范畴中的一个内仿函数，具有 Function1作为箭头。

还有其他类别。例如，假设一个类别中的对象是 Scala 类型，并且有一个箭头 A >~> B如果 B是 A 的子类型.此类别在 Scalaz被称为 Liskov .有一个来自 Liskov 的“健忘”仿函数类别到 Function1类别:

import scalaz._
import Scalaz._
trait Forget[F[-_]] extends GenericFunctor[>~>, Function1, F] {
  def fmap[A, B](f: A >~> B): F[A] => F[B] = fa => f.subst(fa)
}

请注意，您可以通过将一个或多个参数固定为 GenericFunctor 来构建一些有趣的仿函数。 .例如...

A 常数仿函数将一个类别中的每个对象映射到另一个类别中的单个对象:

type ConstantFunctor[->>[_, _], ->>>[_, _], C] =
  GenericFunctor[->>,->>>,({type F[x] = C})#F]
// def fmap[A, B](f: A ->> B): C ->>> C

安 内仿函数将类别映射到自身:

type EndoFunctor[->>[_, _], F[_]] = GenericFunctor[->>, ->>, F]
// def fmap[A, B](f: A ->> B): F[A] ->> F[B]

安 恒等仿函数将每个对象和箭头映射到自身:

type IdentityFunctor[->>[_, _]] = EndoFunctor[->>, ({type F[x] = x})#F]
// def fmap[A, B](f: A ->> B): A ->> B

当然，您的 Functor trait 只是一个 EndoFunctor在 Function1类别。

type Functor[F[_]] = EndoFunctor[Function1, F]
// def fmap[A, B](f: A => B): F[A] => F[B]