您遇到了一个常见的烦恼：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 多态性：一个接受类型的类型构造函数。
-
Recursive 更进一步：它有两个参数，F[_] 和 A。类型参数的数量在这里无关紧要，但它们的种类很重要。 F[_] 是 rank-1 多态的，所以 Recursive 是 rank-2 多态的：它是一个接受类型构造函数的类型构造函数。
- 我们称任何等级为 2 或以上的事物为 higher-kinded，这就是乐趣的开始。
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。然后在它的伴生对象中，我们可以定义隐式来为各种类型提供特定的分解。我在这里只定义了我们需要使 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)
}
}