Question

我正在用更高级的类型浸泡我的脚趾，探索一个非常基本的Scala示例：

A B C A D E A 
B C D E

这有效：

trait Mappable[F[_]] {
  def map[A, B](fa: F[A])(f: A => B): F[B]
}

object Mappable {
  implicit object MappableOption extends Mappable[Option] {
    def map[A, B](fa: Option[A])(f: A => B): Option[B] = fa.map(f)
  }
  implicit object MappableSeq extends Mappable[Seq] {
    def map[A, B](fa: Seq[A])(f: A => B): Seq[B] = fa.map(f)
  }
}

def bananaTuple[F[_], T](f: F[T])(implicit F: Mappable[F]): F[(String, T)] =
  F.map(f)(("banana", _))

但是这不能编译：

bananaTuple(Option(42)) // Some((banana,42))
bananaTuple(Seq(42))    // List((banana,42))

我得到的编译错误：

bananaTuple(Some(42))
bananaTuple(List(42))

如何让游戏变异？

Answer 1

我们可以使用更多参数多态来实现这项工作：

object MappableExample {
  trait Mappable[F[_]] {
    type Res[_]
    def map[A, B](f: A => B)(c: F[A]): Res[B]
  }

  implicit def seqMappable[C[X] <: Seq[X]] = new Mappable[C] {
    type Res[X] = Seq[X]
    override def map[A, B](f:A => B)(c: C[A]): Seq[B] = c.map(f)
  }

  implicit def optionMappable[C[X] <: Option[X]]: Mappable[C] = new Mappable[C] {
    type Res[X] = Option[X]
    override def map[A, B](f: A => B)(c: C[A]): Option[B] = c.map(f)
  }

  def map[A, B, C[_]](xs: C[A])(f: A => B)(implicit mappable: Mappable[C]): mappable.Res[B] = {
    mappable.map(f)(xs)
  }

  def main(args: Array[String]): Unit = {
    println(map(List(1,2,3))(("banana", _)))
    println(map(Some(1))(("banana", _)))
  }
}

收率：

List((banana,1), (banana,2), (banana,3))
Some((banana,1))

编译器现在推断Some为Mappable[Some]#Res[Int]和Mappable[List]#Res[Int]，这非常难看。人们会期望编译器实际上能够推断出正确的类型，而不需要Mappable特征上的任何共同/反演，这是我们无法做到的，因为我们在不变的位置使用它。

Answer 2

子类型多态性允许我们将某种类型或其任何子类型的值传递给方法。如果方法采用Fruit类型的值，我们也可以在内部传递Apple（毕竟苹果是一种水果）。因此，如果您希望能够将Mappable.MappableOption传递给bananaTuple方法，则必须使MappableOption成为MappableSome的子类型（因为bananaTuple的第一个参数的类型决定了隐含的类型）。这意味着您需要Mappable逆变（如果Some <: Option，那么Mappable[Some] >: Mappable[Option]）。

但是你不能在F中有Mappable[F[_]]逆变，因为F出现在map的协变位置（作为函数参数）。请注意，F也出现在map的逆变位置（作为返回值）。

如果你设法在F中设置Mappable[F[_]]逆变，它应该有效，但我不确定是否使逆变器变得有意义。也就是说，如果你想要一个子类型关系，例如Apple <: Fruit导致Mappable[Apple] >: Mappable[Fruit]（由于Apple和Fruit不是类型构造函数，因此无法编译，但我只是使用简单类型来指出这一点。）

在类型中进行类型逆变并解决出现在协变位置的逆变类型问题是一个常见问题，如果你在其他地方搜索它可能会更好（here就是一个例子）。我仍然认为最好为你想要使用的每个类型提供一个隐式对象，也就是说，为例如提供单独的隐式对象。 Seq和List。

Scala更高的kinded类型方差

2 个答案: