7

我有一个Foo有两个参数的类，我正在尝试为 Foo 编写一个 Functor 实例，其中第一个参数是固定的，如下所示：

object Scratchpad {

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

  case class Foo[X, Y](value: Y)

  implicit def fooInstances[X]: Functor[Foo[X, _]] =
    new Functor[Foo[X, _]] {
      def fmap[A, B](f: A => B): Foo[X, A] => Foo[X, B] =
        foo => Foo[X, B](f(foo.value))
    }
}

但是上面的代码编译失败，产生如下错误：

Error:(9, 41) Scratchpad.Foo[X, _] takes no type parameters, expected: one
  implicit def fooInstances[X]: Functor[Foo[X, _]] =

我知道 Scalaz 对他们的\/类型做了类似的事情，但是检查他们的源代码会发现一个奇怪的?，它不能为我编译：

implicit def DisjunctionInstances1[L]: Traverse[L \/ ?] with Monad[L \/ ?] with BindRec[L \/ ?] with Cozip[L \/ ?] with Plus[L \/ ?] with Optional[L \/ ?] with MonadError[L \/ ?, L] =

Scalaz 是如何?工作的，我该如何编写 Functor 实例Foo？

4

2 回答 2

9

但是检查他们的源代码会发现一个奇怪的？，它不适合我

?来自kind-projector项目，这是一个 Scala 编译器插件，您需要添加到您的build.sbt：

resolvers += Resolver.sonatypeRepo("releases")

addCompilerPlugin("org.spire-math" %% "kind-projector" % "0.9.4")

这为您美化了类型 lambdas 的创建：

implicit def fooInstances[X]: Functor[Foo[X, ?]] =
  new Functor[Foo[X, ?]] {
    def fmap[A, B](f: A => B): Foo[X, A] => Foo[X, B] =
      foo => Foo[X, B](f(foo.value))
}

请记住，我们还可以使用带有类型别名的部分类型应用程序：

implicit def fooInstances[X] = {
  type PartiallyAppliedFoo[A] = Foo[X, A]
  new Functor[PartiallyAppliedFoo] {
    override def fmap[A, B](f: (A) => B): (PartiallyAppliedFoo[A]) => PartiallyAppliedFoo[B] = foo => Foo[X, B](f(foo.value))
  }
}

编辑 (05/04/2020)

请注意 kind 项目的语法已从部分应用类型更改为?to *，因此上面的示例应该是：

sbt：

resolvers += Resolver.sonatypeRepo("releases")

addCompilerPlugin("org.spire-math" %% "kind-projector" % "0.11.0")

代码：

implicit def fooInstances[X]: Functor[Foo[X, *]] =
  new Functor[Foo[X, *]] {
    def fmap[A, B](f: A => B): Foo[X, A] => Foo[X, B] =
      foo => Foo[X, B](f(foo.value))
}
于 2017-07-24T06:41:41.357 回答
8

您正在寻找部分应用类型级构造函数。不幸的是，我们不能直接这样做。但是，我们仍然可以使用一个叫做Structural Types的小特性间接地做到这一点。为了Foo从两个参数的类型构造函数转变为一个参数的类型构造函数，我们将在匿名的结构类型中定义一个类型同义词。

implicit def fooInstances[X]: Functor[({ type T[A] = Foo[X, A] })#T] =
  new Functor[({ type T[A] = Foo[X, A] })#T] {
    // ...
  }

类型上下文中的大括号{}定义了一个匿名类型，我们正在利用它在类型级别创建一个 lambda 函数。我们定义了一个带有别名的匿名类型，然后立即评估该别名。

于 2017-07-24T03:54:14.853 回答