Странное несоответствие типов при использовании доступа к членам вместо экстрактора
-
09-12-2019 - |
Вопрос
Дан кортеж с элементами типа A
и другой тип, параметризованный в A
:
trait Writer[-A] { def write(a: A): Unit }
case class Write[A](value: A, writer: Writer[A])
И сайт использования:
trait Cache { def store[A](value: A, writer: Writer[A]): Unit }
Почему следующее работает так, как ожидалось, с использованием экстрактора кортежа:
def test1(set: Set[Write[_]], cache: Cache): Unit =
set.foreach {
case Write(value, writer) => cache.store(value, writer)
}
Но следующее не удается:
def test2(set: Set[Write[_]], cache: Cache ): Unit =
set.foreach { write =>
cache.store(write.value, write.writer)
}
с сообщением об ошибке
found : Writer[_$1] where type _$1
required: Writer[Any]
cache.store(write.value, write.writer)
^
Могу ли я исправить вторую форму(test2
) правильно скомпилировать?
РЕДАКТИРОВАТЬ
Отталкиваясь от идей Оуэна, я попробовал, смогу ли я вообще заставить его работать без сопоставления с образцом (это то, чего я хотел в первую очередь).Вот еще два странных случая, один работает, другой нет:
// does not work
def test3(set: Set[Write[_]], cache: Cache): Unit = {
def process[A](write: Write[A]): Unit =
cache.store(write.value, write.writer)
set.foreach(process)
}
// _does work_
def test4(set: Set[Write[_]], cache: Cache): Unit = {
def process[A](write: Write[A]): Unit =
cache.store(write.value, write.writer)
set.foreach(w => process(w))
}
Для меня пока что-то непонятное...
Решение
Бег с -Xprint:typer
здесь освещает.Проблема с test2
это то, что существует экзистенциальный тип, который появляется в двух отдельных местах:обаwrite.value
и write.writer
иметь экзистенциальный тип, но, что важно, компилятор не может знать, что у них есть такой же Существенно количественная переменная типа.Даже если вы получаете доступ к ним из того же объекта, компилятор забывает, что они пришли из того же места.
Когда test1
полностью напечатан, вы видите:
def test1(set: Set[Write[_]], cache: Cache) =
set.foreach(((x0$1: Write[_]) => x0$1 match {
case (value: _$1, writer: Writer[_$1])Write[_$1]((value @ _), (writer @ _)) =>
cache.store[_$1](value, writer)
}));
Переменная типа _$1
сопоставляется со значениями.Соответствие переменной типа _$1
связывает его в объеме case
, так что это больше не экзистенциально, и Скала может сказать, что value
и writer
имеют одинаковый параметр типа.
Решение для test2
заключается в том, чтобы не использовать экзистенциалы:
def test2[A]( set: Set[ Write[ A ]], cache: Cache ) {
set.foreach { write =>
cache.store( write.value, write.writer )
}
}
или связать переменную типа с совпадением:
def test2( set: Set[ Write[ _ ]], cache: Cache ) {
set.foreach { case write: Write[a] =>
cache.store( write.value, write.writer )
}
}
редактировать
Позвольте мне попытаться ответить на новые вопросы, которые вы подняли.
Причина test3
не работает, это когда пишешь:
set.foreach(процесс)
process
, который является полиморфным, необходимо сделать мономорфным по двум причинам (которые мне известны):
Функции в Scala не могут быть полиморфными;могут быть только методы.
process
как определено как метод;когда используется как функция первого класса, это функция.Компилятор выполняет вывод типа, главным образом, беря полиморфные значения и объединяя их вместе, чтобы сделать их менее полиморфными.Для передачи фактического полиморфного значения в качестве аргумента метода потребуются типы более высокого ранга.
Причина того, что test4
делает работа заключается в том, что функциональный литерал:
set.foreach( w => process( w ))
на самом деле это не полиморфная функция!В качестве аргумента он принимает экзистенциально определенный тип;но не полиморфный тип.Затем он вызывает метод (не функция) process
, и сопоставляет переменную экзистенциального типа с process
параметр типа.Довольно дико, да?
Вы также можете написать:
set.foreach( process(_) )
что создание анонимной функции означает то же самое.
Другой маршрут, который вы можете или не можете найти подходящим, - это отказаться от экзистенциальных типов и использовать члены типа:
trait Writable {
type A
val value: A
val writer: Writer[A]
}
case class Write[T]( value: T, writer: Writer[ T ]) extends Writable {
type A = T
}
def test2( set: Set[Writable], cache: Cache ) {
set.foreach { write =>
cache.store( write.value, write.writer )
}
}
Здесь Scala может это увидеть write.value
и write.writer
Имейте один и тот же параметр типа, потому что они имеют один и тот же зависимый тип пути.