は高次の型を暗黙的に変換します

Question

私はスカラの初心者です...無知を仮定します。そう

Iは<の定義を見れば：<

sealed abstract class <:<[-From, +To] extends (From => To) implicit def conforms[A]: A <:< A = new (A <:< A) {def apply(x: A) = x}

、これはタイプAはB.

<のサブタイプであることの証拠を定義するために使用される：B

を

...しかし、もし私がその証拠を持っていたいなら、 B [T]

：T. A [T] < FORALL

？

OK ....ので、私は同じレシピ

abstract class Foo[-A[_],+B[_]] { def apply[C](x : A[C]) : B[C] } 

implicit def conforms[A[_]] : Foo[A,A] = new Foo[A,A] { def apply[C](x : A[C]) : A[C] = x } 

に従うことをしようと、私は手動で変換を適用し、この制約を使用することができますが、私は暗黙のうちにそれを「適用」するようにコンパイラを取得することはできません。 （A => Bを拡張しないため）

などです。

abstract class FooInt[-A[_],+B[_]] extends (A[Int] => B[Int]) 

implicit def conformsInt[A[Int]] : FooInt[A,A] = new FooInt[A,A] { def apply(x : A[Int]) : A[Int] = x } 

その後、コンパイラが自動的にタイプA [INT]の値に変換を適用します

私はちょうど[T]

の考えにこれを一般化したい

？

Answer 1

sealed abstract class <:< - これは「新しい証拠」を構築できないことを示しています。既存の2つのタイプが既存の証拠を満たしていることをコンパイラーに頼らざるを得ません。これはすでにすべてのタイプで動作するはずです。そうでない場合は、間違っていることを証明しようとします。

あなたは、そのことを証明したいと述べています。A[T] <: B[T] forAll { type T }。これは、AとBの型パラメータの分散に依存します。そのパラメータを無視したい場合は、証拠A[_] <:< B[_]のみを要求することができます。例えば。

trait Animal; trait Cat extends Animal 

trait Foo[A] 
trait Bar[A] extends Foo[A] 

implicitly[Bar[Cat] <:< Foo[Cat]]  // ok, A is fixed 
implicitly[Bar[Cat] <:< Foo[Animal]] // not possible 
implicitly[Bar[Animal] <:< Foo[Cat]]  // not possible 
implicitly[Bar[_]  <:< Foo[_]]  // ok, we forget about A 

あなたが分散していた場合、あなたは保存できます。

trait Breeds[+A] // covariant, can "produce" A 
trait Feeds [-A] // contravariant, can "consume" A 
class Baz[A] extends Breeds[A] with Feeds[A] 

implicitly[Baz[Cat] <:< Feeds[Animal]] // nope 
implicitly[Baz[Animal] <:< Feeds[Cat]]  // ok 
implicitly[Baz[Cat] <:< Breeds[Animal]] // ok 
implicitly[Baz[Animal] <:< Breeds[Cat]] // nope