修改

Question

在以下简化的示例代码中：

case class One[A](a: A) // An identity functor
case class Twice[F[_], A](a: F[A], b: F[A]) // A functor transformer
type Twice1[F[_]] = ({type L[α] = Twice[F, α]}) // We'll use Twice1[F]#L when we'd like to write Twice[F]

trait Applicative[F[_]] // Members omitted
val applicativeOne: Applicative[One] = null // Implementation omitted
def applicativeTwice[F[_]](implicit inner: Applicative[F]): Applicative[({type L[α] = Twice[F, α]})#L] = null

我可以在applicativeOne上调用applicativeTwice，并且在我尝试在applicativeTwice（applicativeOne）上调用它时类型推断有效，推理失败：

val aOK = applicativeTwice(applicativeOne)
val bOK = applicativeTwice[Twice1[One]#L](applicativeTwice(applicativeOne))
val cFAILS = applicativeTwice(applicativeTwice(applicativeOne))

scala 2.10.0中的错误是

- type mismatch; 
  found : tools.Two.Applicative[[α]tools.Two.Twice[tools.Two.One,α]]
  required: tools.Two.Applicative[F]
- no type parameters for method applicativeTwice: 
  (implicit inner: tools.Two.Applicative[F])tools.Two.Applicative[[α]tools.Two.Twice[F,α]]
  exist so that it can be applied to arguments 
  (tools.Two.Applicative[[α]tools.Two.Twice[tools.Two.One,α]]) 
  --- because --- 
  argument expression's type is not compatible with formal parameter type; 
     found : tools.Two.Applicative[[α]tools.Two.Twice[tools.Two.One,α]] 
     required: tools.Two.Applicative[?F]

为什么“？F”不匹配任何东西（正确类型）？最终我希望applicativeTwice是一个隐式函数，但我必须首先使用类型推理。我见过类似的问题，答案指出了类型推断算法的局限性。但是这个案子看起来非常有限，而且在monad变形金刚中一定非常烦恼，所以我怀疑我错过了一些解决这个问题的技巧。

Answer 1

你遇到了一个共同的烦恼：SI-2712。为清楚起见，我将尽量减少您的代码：

import language.higherKinds

object Test {
  case class Base[A](a: A)
  case class Recursive[F[_], A](fa: F[A])

  def main(args: Array[String]): Unit = {
    val one = Base(1)
    val two = Recursive(one)
    val three = Recursive(two) // doesn't compile
    println(three)
  }
}

这演示了与您相同的类型错误：

argument expression's type is not compatible with formal parameter type;
 found   : Test.Recursive[Test.Base,Int]
 required: ?F
        val three = Recursive(two) // doesn't compile
                    ^

首先你可能已经知道了一些语法和术语：

在Scala中，我们说明确的，未参数化的数据类型（例如Int）具有类_。它是单态。
Base已参数化。我们不能在没有提供它包含的类型的情况下将它用作值的类型，所以我们说有类_[_]。它是 rank-1 polymorphic ：一个类型的类型构造函数。
Recursive更进一步：它有两个参数，F[_]和A。类型参数的数量在这里并不重要，但它们的类型确实如此。 F[_]是rank-1多态，因此Recursive是 rank-2 polymorphic ：它是一个采用类型构造函数的类型构造函数。
我们称任何等级为2级或以上更高级的，这就是乐趣开始的地方。

Scala一般对高级类型没有问题。这是将其类型系统与Java相区别的几个关键特性之一。但是在处理更高级别的类型时，它确实存在类型参数的部分应用的问题。

问题在于：Recursive[F[_], A]有两个类型参数。在您的示例代码中，您执行了“type lambda”技巧以部分应用第一个参数，例如：

val one = Base(1)
val two = Recursive(one)
val three = {
  type λ[α] = Recursive[Base, α]
  Recursive(two : λ[Int])
}

这使编译器相信您正在向_[_]构造函数提供正确类型（Recursive）。如果Scala有curried类型参数列表，我肯定会在这里使用它：

case class Base[A](a: A)
case class Recursive[F[_]][A](fa: F[A]) // curried!

def main(args: Array[String]): Unit = {
  val one = Base(1)          // Base[Int]
  val two = Recursive(one)   // Recursive[Base][Int]
  val three = Recursive(two) // Recursive[Recursive[Base]][Int]
  println(three)
}

唉，它没有（见SI-4719）。因此，据我所知，处理这个问题最常见的方法是由于Miles Sabin的“不适用技巧”。这是scalaz中出现的大大简化的版本：

import language.higherKinds

trait Unapply[FA] {
  type F[_]
  type A
  def apply(fa: FA): F[A]
}

object Unapply {
  implicit def unapply[F0[_[_], _], G0[_], A0] = new Unapply[F0[G0, A0]] {
    type F[α] = F0[G0, α]
    type A = A0
    def apply(fa: F0[G0, A0]): F[A] = fa
  }
}

在一些手动的术语中，这个Unapply构造就像一个“一流的lambda”。我们定义了一个表示断言的特征，即某些类型FA可以分解为类型构造函数F[_]和类型A。然后在其伴随对象中，我们可以定义implicits以为各种类型提供特定的分解。我在这里只定义了我们需要使Recursive适合的具体内容，但你可以写其他内容。

通过这些额外的管道，我们现在可以做我们需要的事情：

import language.higherKinds

object Test {
  case class Base[A](a: A)
  case class Recursive[F[_], A](fa: F[A])

  object Recursive {
    def apply[FA](fa: FA)(implicit u: Unapply[FA]) = new Recursive(u(fa))
  }

  def main(args: Array[String]): Unit = {
    val one = Base(1)
    val two = Recursive(one)
    val three = Recursive(two)
    println(three)
  }
}

钽哒！现在类型推断工作，并编译。作为练习，我建议你创建一个额外的课程：

case class RecursiveFlipped[A, F[_]](fa: F[A])

...当然，它与任何有意义的方式都与Recursive没有什么不同，但会再次打破类型推断。然后定义修复它所需的额外管道。祝你好运！

修改

你要求一个不太简化的版本，一些意识到类型的东西。需要进行一些修改，但希望您能看到相似之处。首先，这是我们升级的Unapply：

import language.higherKinds

trait Unapply[TC[_[_]], FA] {
  type F[_]
  type A
  def TC: TC[F]
  def apply(fa: FA): F[A]
}

object Unapply {
  implicit def unapply[TC[_[_]], F0[_[_], _], G0[_], A0](implicit TC0: TC[({ type λ[α] = F0[G0, α] })#λ]) =
    new Unapply[TC, F0[G0, A0]] {
      type F[α] = F0[G0, α]
      type A = A0
      def TC = TC0
      def apply(fa: F0[G0, A0]): F[A] = fa
    }
}

同样，这是completely ripped off from scalaz。现在使用它的一些示例代码：

import language.{ implicitConversions, higherKinds }

object Test {

  // functor type class
  trait Functor[F[_]] {
    def map[A, B](fa: F[A])(f: A => B): F[B]
  }

  // functor extension methods
  object Functor {
    implicit class FunctorOps[F[_], A](fa: F[A])(implicit F: Functor[F]) {
      def map[B](f: A => B) = F.map(fa)(f)
    }
    implicit def unapply[FA](fa: FA)(implicit u: Unapply[Functor, FA]) =
      new FunctorOps(u(fa))(u.TC)
  }

  // identity functor
  case class Id[A](value: A)
  object Id {
    implicit val idFunctor = new Functor[Id] {
      def map[A, B](fa: Id[A])(f: A => B) = Id(f(fa.value))
    }
  }

  // pair functor
  case class Pair[F[_], A](lhs: F[A], rhs: F[A])
  object Pair {
    implicit def pairFunctor[F[_]](implicit F: Functor[F]) = new Functor[({ type λ[α] = Pair[F, α] })#λ] {
      def map[A, B](fa: Pair[F, A])(f: A => B) = Pair(F.map(fa.lhs)(f), F.map(fa.rhs)(f))
    }
  }

  def main(args: Array[String]): Unit = {
    import Functor._
    val one = Id(1)
    val two = Pair(one, one) map { _ + 1 }
    val three = Pair(two, two) map { _ + 1 }
    println(three)
  }
}

Answer 2

注意（3年后，2016年7月），scala v2.12.0-M5开始实施SI-2172（支持更高级别的统一）

请参阅commit 892a6d6

中的Miles Sabin

-Xexperimental模式现在只包含-Ypartial-unification

遵循Paul Chiusano＆＃39; simple algorithm：

// Treat the type constructor as curried and partially applied, we treat a prefix
// as constants and solve for the suffix. For the example in the ticket, unifying
// M[A] with Int => Int this unifies as,
//
//   M[t] = [t][Int => t]  --> abstract on the right to match the expected arity
//   A = Int               --> capture the remainder on the left

test/files/neg/t2712-1.scala包括：

package test

trait Two[A, B]

object Test {
  def foo[M[_], A](m: M[A]) = ()
  def test(ma: Two[Int, String]) = foo(ma) // should fail with -Ypartial-unification *disabled*
}

和（test/files/neg/t2712-2.scala）：

package test

class X1
class X2
class X3

trait One[A]
trait Two[A, B]

class Foo extends Two[X1, X2] with One[X3]
object Test {
  def test1[M[_], A](x: M[A]): M[A] = x

  val foo = new Foo

  test1(foo): One[X3]     // fails with -Ypartial-unification enabled
  test1(foo): Two[X1, X2] // fails without -Ypartial-unification
}

Scala中更高级别类型的推断有哪些限制？

2 个答案:

修改