あなたはよくある煩わしさを感じました：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一方、はパラメータ化されています。含まれているタイプを指定せずに値のタイプとして使用することはできないため、kindがあると言います_[_]。ランク1のポリモーフィック：型をとる型コンストラクターです。Recursiveさらに進んでください：それは2つのパラメータを持っています、F[_]そしてA。ここでは型パラメーターの数は重要ではありませんが、その種類は重要です。F[_]はランク1のポリモーフィックであり、Recursiveランク2のポリモーフィックも同様です。型コンストラクターをとる型コンストラクターです。- 私たちはランク2以上のものを高種類と呼び、ここから楽しみが始まります。
Scalaは一般的に、より種類の多いタイプでは問題ありません。これは、その型システムをJavaなどと区別するいくつかの重要な機能の1つです。ただし、より種類の多い型を処理する場合、型パラメーターの部分適用には問題があります。
ここに問題Recursive[F[_], A]があります：2つのタイプパラメータがあります。サンプルコードでは、「タイプラムダ」トリックを実行して、次のような最初のパラメーターを部分的に適用しました。
val one = Base(1)
val two = Recursive(one)
val three = {
type λ[α] = Recursive[Base, α]
Recursive(two : λ[Int])
}
これにより、コンストラクターに正しい種類（_[_]）を提供していることがコンパイラーに納得します。RecursiveScalaがカレー型パラメーターリストを持っていたら、私は間違いなくそれをここで使用したでしょう：
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を参照）。したがって、私の知る限り、この問題に対処する最も一般的な方法は、MilesSabinによる「不適切なトリック」です。これは、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構成は「ファーストクラスタイプのラムダ」のようなものです。ある型を型コンストラクターとFA型に分解できるというアサーションを表す特性を定義します。次に、そのコンパニオンオブジェクトで、さまざまな種類のタイプに特定の分解を提供する暗黙の定義を行うことができます。ここでは、適合させるために必要な特定のものだけを定義しましたが、他のものを書くこともできます。F[_]ARecursive
この余分な配管を使用して、必要なことを実行できます。
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)
}
}