タイプラムダを正しく定義するには？

Question

簡単な最小限の例を作成する目的で、ラムダの例として=:=を使用しました。

=:=タイプは2つの引数を取るので、タイプレベルで1つカレーしたいと思います。

私はナイーブな実装type Curry[G] = {type l[L] = L =:= G}を取ることが、実用的には、それはエラーが発生し使用しています。

type X = Int 
type Y = Int 

type CurryInt[T] = T =:= Int 
type Curry[G] = {type l[L] = L =:= G} 
type CurrStatic = {type l[L] = L =:= Int} 
object CurryObj {type l[L] = L =:= Int} 

trait Apply[P[_], T] 
implicit def liftApply[P[_], T](implicit ev : P[T]) = new Apply[P,T] {} 

implicitly[Apply[CurryInt, Y]] // ok 
implicitly[Apply[Curry[X]#l, Y]] // fails 
implicitly[Apply[Curry[X]#l, Y]](liftApply) // fails 
implicitly[Apply[Curry[X]#l, Y]](liftApply[Curry[X]#l, Y]) // ok 
implicitly[Apply[CurrStatic#l, Y]] // fails 
implicitly[Apply[CurryObj.l, Y]] // ok 

型推論がここに壊れます。タイプlambdaを定義するにはどのようにすればいいですか？

Answer 1

やや冗長な、しかしコンパイル:)（スカラ座2.12.3）

type X = Int 
    type Y = Int 

    type CurryInt[T] = T =:= Int 
    type Curry[G] = {type l[L] = =:=[L, G]} 
    type CurrStatic = {type l[L] = L =:= Int} 
    object CurryObj {type l[L] = L =:= Int} 

    trait Apply[P[_], T] 
    implicit def liftApply[P[_], T](implicit ev : P[T]) = new Apply[P,T] {} 


    type L1[R] = =:=[R, X] 
    type L2[R] = =:=[R, Int] 
    implicitly[Apply[CurryInt, Y]] // ok 
    implicitly[Apply[L1, Y]] // ok 
    implicitly[Apply[L1, Y]](liftApply[L1, Y]) // ok 
    implicitly[Apply[Curry[X]#l, Y]](liftApply[Curry[X]#l, Y]) // ok 
    implicitly[Apply[L2, Y]] // ok 
    implicitly[Apply[CurryObj.l, Y]] // ok 

Answer 2

はあなたの例のこの簡易版考えてみます。

trait Secret 
type Curry = { type l[L] = Secret } 

def foo[P[_], T](ev : P[T]) = ??? 
val bar: Curry#l[Int] = ??? 

foo(bar) 

を値barが単純であるfooを呼び出すときSecretのタイプの場合、コンパイラはあなたの特定のSecretの出所を知らない。

barの値はちょうどSecretであり、Curry#l[Int]を指す情報は保持されません。

コンパイラは、P => Curry#lとT => Intと推測できません。

コンパイラはSecretを見て、Curry#l[Int]代わりのSecretと種類に注釈を付けるにもかかわらず、Curry#lコンテキストを失います。

（this質問から来て）別の例として、同様の行動を暴露：

trait Curry { type l } 
trait CurryB extends Curry { type l = String } 

def foo[P <: Curry](x: P#l) = ??? 
val bar: CurryB#l = ??? 

foo(bar) 

---

CurryObj状況がCurryInt#l、Curry#l、およびCurrStatic#lだけのエイリアスを入力していることを考慮し、異なっています。代わりにCurryObj.lが実際のタイプであり、具体的なオブジェクトCurryObjの一部です。

はのは、この（REPL）を見てみましょう：タイプの別名 Curry#l[Int]こと

scala> trait Secret 
defined trait Secret 

scala> type Curry = { type l[L] = Secret } 
defined type alias Curry 

scala> object CurryObj { type l[L] = Secret } 
defined object CurryObj 

scala> object S extends Secret 
defined object S 

scala> val foo0: Curry#l[Int] = S 
foo0: Secret = S$@2c010477 

scala> val foo1: CurryObj.l[Int] = S 
foo1: CurryObj.l[Int] = S$@2c010477 

注 - >Secretは、すぐに代わりに実際の型CurryObj.l[Int]保たれているが解消されます。

Answer 3

scalaコンパイラが型投影から裸の型を処理できなかったようです。私は-Ytyper-debugの出力をトレースし、必要なすべてのタイプ情報が持ち去られているが、明白な理由で拒否されていることがわかりました。しかし、ラムダ型ラップを式の中に入れることは、まだ可能です。 That answerは私に解決策の洞察を与えました。

type X = Int 
type Y = Int 

trait Wrap { 
    type l[T] 
} 
trait GenWrap[W[_]] extends Wrap { 
    final type l[T] = W[T] 
} 

type CInt[T] = T =:= Int 
class CurryInt extends Wrap {type l[T] = T =:= Int} 
class Curry[U] extends Wrap {type l[T] = T =:= U} 
type TCurry[U] = Wrap {type l[T] = T =:= U} 

trait Apply[W <: Wrap, T] 
implicit def lift[W <: Wrap, T](implicit ev : W#l[T]) = new Apply[W,T] {} 

implicitly[Apply[CurryInt, Y]] 
implicitly[Apply[Curry[X], Y]] 
implicitly[Apply[TCurry[X], Y]] 
implicitly[Apply[GenWrap[CInt], Y]]