Trafiłeś na wspólną irytację: SI-2712 . Dla jasności, zamierzam trochę zminimalizować Twój kod: {]}

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)
  }
}

To pokazuje ten sam błąd typu co twój:

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
                    ^

Najpierw trochę składni i terminologii, które prawdopodobnie już znasz:

• w Scali mówimy, że zwykły, nieparametryczny typ danych (taki jak Int) mA typ _. Jest monomorficzna .
• Base, z drugiej strony, jest parametryzowany. nie możemy go używać jako typu wartość bez podania typu, który zawiera, więc mówimy, że ma rodzaj _[_]. Jest to polimorficzny rangi-1: Konstruktor typu, który przyjmuje typ.
• Recursive idzie dalej: ma dwa parametry, F[_] i A. Liczba parametrów typu nie ma tutaj znaczenia, ale ich rodzaje mają znaczenie. F[_] jest polimorficzny rank-1, więc Recursive jest polimorficzny rank-2 : to Konstruktor typu, który bierze konstruktor typu.
• nazywamy wszystko rangą drugą lub wyższą wyżej kinded , i tu zaczyna się zabawa.

Scala w ogóle nie ma problemów z typami o wyższym pokrewieństwie. Jest to jedna z kilku kluczowych cech, które odróżniają jego system typów od, powiedzmy, Javy. ale ma problemy z częściową aplikacją parametrów typów, gdy ma do czynienia z typami o wyższym pokrewieństwie.

Oto problem: Recursive[F[_], A] ma dwa parametry typu. W przykładowym kodzie wykonałeś trick "wpisz lambda", aby częściowo zastosować pierwszy parametr, coś w stylu:

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

To przekonuje kompilatora, że dostarczasz coś odpowiedniego (_[_]) konstruktorowi Recursive. Gdyby Scala miała current type parameter lists, na pewno użyłbym tego tutaj:

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)
}

Niestety nie (patrz SI-4719 ). Tak więc, z tego co wiem, najczęstszym sposobem radzenia sobie z tym problemem jest "podstępna sztuczka" z powodu Milesa Sabina. Oto znacznie uproszczona wersja tego, co pojawia się w 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
  }
}

W nieco ręcznych terminach, ta Unapply konstrukcja jest jak "pierwsza klasa typu lambda."Definiujemy cechę reprezentującą twierdzenie, że jakiś typ FA może być rozłożony na konstruktor typu F[_] i typ A. Następnie w jego obiekcie towarzyszącym możemy zdefiniować wywołania niejawne, aby zapewnić określone dekompozycje dla typów różnych typów. Zdefiniowałem tutaj tylko konkretny, który musimy dopasować, ale możesz napisać inne.

Z tym dodatkowym w 1997 roku, w wyniku połączenia się z klubem, został wybrany do kadry na mistrzostwa świata w piłce nożnej 2008.]}

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)
  }
}

Ta-da! Teraz wnioskowanie typu działa, a to kompiluje. Jako ćwiczenie sugerowałbym utworzenie dodatkowej klasy: {]}

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

... co nie różni się od Recursive w żaden znaczący sposób, oczywiście, ale ponownie złamie wnioskowanie typu. Następnie określ dodatkową instalację wodno-kanalizacyjną potrzebną do jej naprawy. Powodzenia!

Edytuj

Poprosiłeś o mniej uproszczoną wersję, coś świadomego klas typu. Niektóre modyfikacja jest wymagana, ale mam nadzieję, że widać podobieństwo. Po pierwsze, oto nasz ulepszony 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
    }
}

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)
  }
}