web-dev-qa-db-ja.com

Scala:TypeTagとは何ですか、どのように使用しますか?

TypeTagについて私が知っているのは、何らかの形でマニフェストを置き換えたことだけです。インターネット上の情報は乏しく、主題についての良い感覚を私に提供しません。

だから、誰かが例や人気のあるユースケースを含むTypeTagの有用な資料へのリンクを共有してくれたら嬉しいです。詳細な回答と説明も歓迎します。

351
Sergey Weiss

TypeTagは、Scalaの型が実行時に消去されるという問題を解決します(型消去)。やりたいなら

class Foo
class Bar extends Foo

def meth[A](xs: List[A]) = xs match {
  case _: List[String] => "list of strings"
  case _: List[Foo] => "list of foos"
}

警告が表示されます:

<console>:23: warning: non-variable type argument String in type pattern List[String]↩
is unchecked since it is eliminated by erasure
         case _: List[String] => "list of strings"
                 ^
<console>:24: warning: non-variable type argument Foo in type pattern List[Foo]↩
is unchecked since it is eliminated by erasure
         case _: List[Foo] => "list of foos"
                 ^

この問題を解決するために マニフェスト がScalaに導入されました。ただし、パス依存型など、多くの便利な型を表すことができないという問題があります。

scala> class Foo{class Bar}
defined class Foo

scala> def m(f: Foo)(b: f.Bar)(implicit ev: Manifest[f.Bar]) = ev
warning: there were 2 deprecation warnings; re-run with -deprecation for details
m: (f: Foo)(b: f.Bar)(implicit ev: Manifest[f.Bar])Manifest[f.Bar]

scala> val f1 = new Foo;val b1 = new f1.Bar
f1: Foo = [email protected]
b1: f1.Bar = [email protected]

scala> val f2 = new Foo;val b2 = new f2.Bar
f2: Foo = [email protected]
b2: f2.Bar = [email protected]

scala> val ev1 = m(f1)(b1)
warning: there were 2 deprecation warnings; re-run with -deprecation for details
ev1: Manifest[f1.Bar] = [email protected]#Foo$Bar

scala> val ev2 = m(f2)(b2)
warning: there were 2 deprecation warnings; re-run with -deprecation for details
ev2: Manifest[f2.Bar] = [email protected]#Foo$Bar

scala> ev1 == ev2 // they should be different, thus the result is wrong
res28: Boolean = true

したがって、これらは TypeTags に置き換えられます。これは、はるかに使いやすく、新しいReflection APIにうまく統合されています。それらを使用して、パス依存型に関する上記の問題をエレガントに解決できます。

scala> def m(f: Foo)(b: f.Bar)(implicit ev: TypeTag[f.Bar]) = ev
m: (f: Foo)(b: f.Bar)(implicit ev: reflect.runtime.universe.TypeTag[f.Bar])↩
reflect.runtime.universe.TypeTag[f.Bar]

scala> val ev1 = m(f1)(b1)
ev1: reflect.runtime.universe.TypeTag[f1.Bar] = TypeTag[f1.Bar]

scala> val ev2 = m(f2)(b2)
ev2: reflect.runtime.universe.TypeTag[f2.Bar] = TypeTag[f2.Bar]

scala> ev1 == ev2 // the result is correct, the type tags are different
res30: Boolean = false

scala> ev1.tpe =:= ev2.tpe // this result is correct, too
res31: Boolean = false

また、型パラメーターを確認するために簡単に使用できます。

import scala.reflect.runtime.universe._

def meth[A : TypeTag](xs: List[A]) = typeOf[A] match {
  case t if t =:= typeOf[String] => "list of strings"
  case t if t <:< typeOf[Foo] => "list of foos"
}

scala> meth(List("string"))
res67: String = list of strings

scala> meth(List(new Bar))
res68: String = list of foos

この時点で、=:=(型の等価性)と<:<(サブタイプの関係)を使用して等価性チェックを行うことを理解することが非常に重要です。どうすればよいかわからない限り、==!=を使用しないでください。

scala> typeOf[List[Java.lang.String]] =:= typeOf[List[Predef.String]]
res71: Boolean = true

scala> typeOf[List[Java.lang.String]] == typeOf[List[Predef.String]]
res72: Boolean = false

後者は、構造的な同等性をチェックします。これは、プレフィックスなどのことを気にしないので、実行されるべきではないことがよくあります(例のように)。

TypeTagは完全にコンパイラーによって生成されます。つまり、コンパイラーは、TypeTagを期待するメソッドを呼び出したときにTypeTagを作成して入力します。タグには3つの異なる形式があります。

ClassTagClassManifestを置き換えますが、TypeTagManifestの代わりになります。

前者では、汎用配列を完全に使用できます。

scala> import scala.reflect._
import scala.reflect._

scala> def createArr[A](seq: A*) = Array[A](seq: _*)
<console>:22: error: No ClassTag available for A
       def createArr[A](seq: A*) = Array[A](seq: _*)
                                           ^

scala> def createArr[A : ClassTag](seq: A*) = Array[A](seq: _*)
createArr: [A](seq: A*)(implicit evidence$1: scala.reflect.ClassTag[A])Array[A]

scala> createArr(1,2,3)
res78: Array[Int] = Array(1, 2, 3)

scala> createArr("a","b","c")
res79: Array[String] = Array(a, b, c)

ClassTagは、実行時に型を作成するために必要な情報(消去された型)のみを提供します。

scala> classTag[Int]
res99: scala.reflect.ClassTag[Int] = ClassTag[int]

scala> classTag[Int].runtimeClass
res100: Class[_] = int

scala> classTag[Int].newArray(3)
res101: Array[Int] = Array(0, 0, 0)

scala> classTag[List[Int]]
res104: scala.reflect.ClassTag[List[Int]] =↩
        ClassTag[class scala.collection.immutable.List]

上記でわかるように、彼らは型の消去を気にしません。したがって、「完全な」型が必要な場合はTypeTagを使用する必要があります。

scala> typeTag[List[Int]]
res105: reflect.runtime.universe.TypeTag[List[Int]] = TypeTag[scala.List[Int]]

scala> typeTag[List[Int]].tpe
res107: reflect.runtime.universe.Type = scala.List[Int]

scala> typeOf[List[Int]]
res108: reflect.runtime.universe.Type = scala.List[Int]

scala> res107 =:= res108
res109: Boolean = true

ご覧のとおり、tpeのメソッドTypeTagは、完全なTypeになります。これは、typeOfが呼び出されたときと同じです。もちろん、ClassTagTypeTagの両方を使用することもできます。

scala> def m[A : ClassTag : TypeTag] = (classTag[A], typeTag[A])
m: [A](implicit evidence$1: scala.reflect.ClassTag[A],↩
       implicit evidence$2: reflect.runtime.universe.TypeTag[A])↩
      (scala.reflect.ClassTag[A], reflect.runtime.universe.TypeTag[A])

scala> m[List[Int]]
res36: (scala.reflect.ClassTag[List[Int]],↩
        reflect.runtime.universe.TypeTag[List[Int]]) =↩
       (scala.collection.immutable.List,TypeTag[scala.List[Int]])

残りの質問は、WeakTypeTagの意味は何ですか?つまり、TypeTagは具象型を表します(つまり、完全にインスタンス化された型のみが許可されます)が、WeakTypeTagは任意の型のみを許可します。ほとんどの場合、どちらが何であるかは気にしません(つまり、TypeTagを使用する必要があります)が、たとえば、ジェネリック型で機能するマクロを使用する場合は必要です。

object Macro {
  import language.experimental.macros
  import scala.reflect.macros.Context

  def anymacro[A](expr: A): String = macro __anymacro[A]

  def __anymacro[A : c.WeakTypeTag](c: Context)(expr: c.Expr[A]): c.Expr[A] = {
    // to get a Type for A the c.WeakTypeTag context bound must be added
    val aType = implicitly[c.WeakTypeTag[A]].tpe
    ???
  }
}

WeakTypeTagTypeTagに置き換えた場合、エラーがスローされます。

<console>:17: error: macro implementation has wrong shape:
 required: (c: scala.reflect.macros.Context)(expr: c.Expr[A]): c.Expr[String]
 found   : (c: scala.reflect.macros.Context)(expr: c.Expr[A])(implicit evidence$1: c.TypeTag[A]): c.Expr[A]
macro implementations cannot have implicit parameters other than WeakTypeTag evidences
             def anymacro[A](expr: A): String = macro __anymacro[A]
                                                      ^

TypeTagWeakTypeTagの違いに関する詳細な説明については、この質問を参照してください。 Scala Macros:“未解決の型パラメーターを持つ型TからTypeTagを作成できません”

Scalaの公式ドキュメントサイトには、 Reflectionのガイド も含まれています。

540
kiritsuku