Scala 2.10 Использование TypeTag

Я копаю новый scala отражение api и не могу понять, почему следующий фрагмент не работает должным образом. Данная иерархия (пыталась упростить как можно больше):

import scala.reflect.runtime.universe._

trait TF[A] {
  implicit def t: TypeTag[A]

  def f[T <: A: TypeTag]: PartialFunction[Any, A] = {
    case msg: T if typeOf[T] =:= typeOf[A] => msg
  }
}

class TFilter[T: TypeTag] extends TF[T] {
  def t = typeTag[T]
}

case class Foo(x: Int)

Я ожидаю, что метод f будет фильтровать объекты данного типа. Поэтому следующий фрагмент должен возвращать Seq[Foo]

val messages = Seq(1, "hello", Foo(1))

val tFilter = new TFilter[Foo]
messages collect tFilter.f[Foo]

И он фактически возвращает Seq[Foo], но с другими сообщениями, нефильтрованными, что звучит как ошибка.

res1: Seq[Foo] = List(1, hello, Foo(1))

Вопрос. Я использую TypeTag неправильно или это дефект нового отражения api?

PS0. Пробовали Scala 2.10.0-RC1 и 2.10.0-RC2

PS1. Обходной путь заключается в замене TypeTag на Manifest, поэтому следующий код collect в последовательности вернет List(Foo(1)), как ожидалось.

trait MF[A] {
  implicit def m: Manifest[A]

  def f[T <: A: Manifest]: PartialFunction[Any, A] = {
    case msg: T if typeOf[T] =:= typeOf[A] => msg
  }
}

class MFilter[T: Manifest] extends MF[T] {
  def m = manifest[T]
}

Обновить. То же самое с новым выпуском Scala 2.10.0-RC2.

ОТВЕТЫ

Ответ 1

Итак, я думаю, что ключевая проблема заключается в том, что вам нужно сопоставлять тип msg, но его тип времени компиляции Any (из объявления PartialFunction). По существу, для каждого элемента в List[Any] требуется другой TypeTag. Но поскольку все они имеют тип времени Any для компиляции в силу того, что все они помещены в один список, вы больше не будете иметь TypeTag, который более специфичен.

Я думаю, что вы, вероятно, хотите сделать, это использовать ClassTag вместо TypeTag:

trait TF[A] {
  implicit def t: ClassTag[A]

  def f: PartialFunction[Any, A] = {
    case msg: A => msg
  }
}

class TFilter[T: ClassTag] extends TF[T] {
  def t = classTag[T]
}

case class Foo(x: Int)

val messages = Seq(1, "hello", Foo(1), List(1), List("a"))
messages collect new TFilter[Foo].f // produces List(Foo(1))

Как Ajran указывает, как и версия Manifest, вы должны знать обо всех ограничениях типов времени выполнения, включая проблемы стирания и бокса:

messages collect new TFilter[List[Int]].f // produces List(List(1), List("a"))
messages collect new TFilter[Int].f // produces List()
messages collect new TFilter[java.lang.Integer].f // produces List(1)

Есть несколько советов о том, как сделать TypeTag более полезным для сопоставления шаблонов (например, SI-6517), но я думаю, что эти поможет только в том случае, если вы сопоставляете объект с полезным TypeTag, а не с типом времени Any.

Ответ 2

на самом деле вы не проверяете здесь тип msg, компилятор предупредит вас, что msg: T стирается, поэтому все, что вы оставили, проверяет, что тип, определенный в TFilter, такой же, как тип, определенный для функции f.

Мне кажется, что совпадение шаблонов "помогает" Manifest и ClassTag, поэтому msg: T действительно правильный тип. Если вы попробуете его с помощью примитивов или List [T], это будет работать неправильно.

val mFilter = new MFilter[Int]
messages collect mFilter.f[Int] // res31: Seq[Int] = List()

val messages = List(List(1), List("a"))
val mFilter = new MFilter[List[Int]]
messages collect mFilter.f[List[Int]] // res32: List[List[Int]] = List(List(1), List(a))

Посмотрите на эту дискуссию: http://grokbase.com/t/gg/scala-user/126p8eh1w0/how-to-make-typetag-work-in-a-pattern

bug "Использовать TypeTags при сопоставлении с образцом, иначе стираемых типов": здесь

Ответ 3

Просто для удовольствия:

import scala.reflect._
import scala.reflect.runtime.{currentMirror=>cm,universe=>ru}
import ru._

object Test extends App {
  type MyTag[A] = TypeTag[A]
  //type MyTag[A] = ClassTag[A]

  trait TF[A] {
    implicit def t: MyTag[A]

    def f[T <: A: MyTag]: PartialFunction[Any, A] = {
      //case msg: T => msg            // ok for ClassTag
      case msg: T @unchecked if matching[T](msg) => msg
      //case msg: T if typeOf[T] =:= typeOf[A] => msg
    }
    def matching[T](a: Any)(implicit tt: TypeTag[T]) =
      (cm reflect a).symbol.toType weak_<:< tt.tpe
  }

  case class TFilter[A: MyTag]() extends TF[A] {
    def t = implicitly[MyTag[A]]
  }

  trait Foo { def x: Int }
  case class Bar(x: Int) extends Foo
  case class Baz(x: Int) extends Foo

  val messages = Seq(1, Bar(0), "hello", Baz(1))
  println(messages collect TFilter[Foo].f[Foo])
  println(messages collect TFilter[Foo].f[Bar])
}

Ответ 4

Спасибо всем за отзыв. Подумайте, я нашел причину, по которой ClassTag следует использовать при сопоставлении шаблонов.

Мне удалось найти [SI-5143] Совпадение шаблонов по абстрактным типам не работает, а связанная фиксация объясняет, что для проверки шаблона должен быть экземпляр ClassTag.

Итак, да, я использовал TypeTag неправильно; в случае соответствия шаблону я должен использовать ClassTag.