您遇到了一个常见的烦恼：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）具有 kind _。它是单态的。
Base，另一方面，是参数化的。如果不提供它包含的类型，我们就不能将它用作值的类型，所以我们说 has kind _[_]。它是rank-1 多态的：一个接受类型的类型构造函数。Recursive更进一步：它有两个参数，F[_]和A。类型参数的数量在这里无关紧要，但它们的种类很重要。F[_]是 rank-1 多态的，rank-2 也是多态Recursive的：它是一个类型构造函数，它接受一个类型构造函数。- 我们称任何等级为 2 或以上的东西为 high-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”。我们定义了一个 trait，表示某种类型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
}
}
同样，这完全是从 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)
}
}