Особенности различных видов пути-зависимых типов в Скале

Question

Предположим, есть черта:

trait OuterTrait { 
    type InnerType 
} 

Теперь мы можем написать необщего функцию someAlgo:

def pairToString[S, U](x: S, y: U): String = 
    "{" + y.toString + " in " + x.toString + "}" 

def pairPrintln[S, U](x: S, y: U) { 
    println(pairToString(x, y)) 
} 

def someAlgo(x: OuterTrait)(y: x.InnerType): x.InnerType = { 
    pairPrintln(x, y) 
    y 
} 

и ряд общих функций:

def someAlgoObjObj[T <: OuterTrait](x: T)(y: x.InnerType): x.InnerType = { 
    pairPrintln(x, y) 
    y 
} 

def someAlgoObjType[T <: OuterTrait](x: T)(y: x.InnerType): T#InnerType = { 
    pairPrintln(x, y) 
    y 
} 

def someAlgoTypeType[T <: OuterTrait](x: T)(y: T#InnerType): T#InnerType = { 
    pairPrintln(x, y) 
    y 
} 

И еще одна общая функция не компилируется:

def someAlgoTypeObj[T <: OuterTrait](x: T)(y: T#InnerType): x.InnerType = { 
    pairPrintln(x, y) 
    y 
} 

Кажется, что: 1) someAlgo и someAlgoObjObj являются наиболее правильными функциями; 2), и нет смысла использовать общую функцию в этом примере вообще.

И я хотел бы уточнить некоторые различия между родовыми функциями выше. Пожалуйста, исправьте меня, если я сделаю ошибки.

Так как я понимаю тип T соответствует статического типа x (назовем его X) или явного типа общего вызова (я имею в виду algo[Int], например). Вот почему T#InnerType соответствует типу в объявлении типа X. Но x.InnerType также соответствует InnerType от статический тип x. Где разница?

Далее ... someAlgoObjType компилирует, так что кажется, что x.InnerType должен быть подтип из T#InnerType. Тогда это нормально, что someAlgoTypeObj не компилируется, так как мы не можем сделать утапливание неявно. Хотя мы можем переписать последний:

def someAlgoTypeObj[T <: OuterTrait](x: T)(y: T#InnerType): x.InnerType = { 
    pairPrintln(x, y) 
    y.asInstanceOf[x.InnerType] 
} 

UPD1: Я нашел одно различие между someAlgoObjObj и someAlgoTypeType, если их использовать с параметром явного типа. Если мы напишем некоторый класс, расширяющий OuterTrait:

class OuterIntClass extends OuterTrait{ 
    type InnerType = Int 
} 
val x: OuterIntClass = new OuterIntClass() 
val y: Int = 5 

Тогда:

someAlgoObjObj[OuterTrait](x)(y) // OK 

и следующий звонок не работает:

someAlgoTypeType[OuterTrait](x)(y) 

Answer 1

T#InnerType означает «InnerType принадлежность в некоторых T ", а x.InnerType означает" A InnerType, принадлежащий в заданном x (типа OuterTrait) ".

Ключ здесь в понимании их в некотором Т против в заданном х. Вы можете интерпретировать в некотором как некоторых T, но мы не имеем то, что T instance, что означает, что в двух Ts не обязательно одинаковы, поэтому T # InnerType не может быть доказано равным другому T #InnerType.

Давайте проанализируем подпись:

/* 1 */ def someAlgoObjObj[T <: OuterTrait](x: T)(y: x.InnerType): x.InnerType = ??? 
/* 2 */ def someAlgoObjType[T <: OuterTrait](x: T)(y: x.InnerType): T#InnerType = ??? 
/* 3 */ def someAlgoTypeType[T <: OuterTrait](x: T)(y: T#InnerType): T#InnerType = ??? 

1. Учитывая е и InnerType принадлежности в это х возвращает его InnerType.
2. Учитывая й и InnerType принадлежащего в этого х возвращает InnerType, принадлежащего некоторого Т, что означает некоторого Т не обязательно тот же экземпляр, как х.
3. Учитывая й и InnerType, принадлежащий некоторого T возвращает InnerType принадлежащего некоторого Т

Теперь четвёртые один:

def someAlgoTypeObj[T <: OuterTrait](x: T)(y: T#InnerType): x.InnerType = y 

Подписи гласит: даны х и InnerType принадлежащих к некоторые T, возвращает InnerType, принадлежащий , этому x. Но в реализации мы пытаемся вернуть y, который принадлежит T, который не обязательно совпадает с x, поэтому компилятор жалуется.

Answer 2

Небольшая заметка о обновление.

someAlgoTypeType[OuterTrait](x)(y) 

Failes, потому что ваш метод подписи говорит, что он ожидает, что его параметр y соответствовать типу T#InnerType и ваш y.type является Int. Для того, чтобы сделать его работу, вы должны изменить его тип к следующему:

class OuterIntClass extends OuterTrait{ 
    type InnerType = Int 
} 
val x: OuterIntClass = new OuterIntClass() 
val y: x.InnerType = 5 

Теперь типа проекции удовлетворяет типа y «s T#InnerType и someAlgoTypeType[OuterTrait](x)(y) компилирует