Question

我有一些Scala代码可以大量使用泛型，我从文档中收集到，在参数化约束中使用清单可以帮助我解决类型擦除问题（例如，我想实例化一个新的对象通用类型）。只是，我想更多地了解这是如何工作的。它几乎感觉像是某种哈希映射为每个调用站点获取一个条目......这里有人可以详细说明吗？

class Image[T <: Pixel[T] : Manifest](fun() => T, size: Array[Int], data: Array[T]) {
    def this(fun: () => T, size: Array[T]) {
        this(fun, size, new Array[T](size(0) * size(1));
    }
}

这在我在网站上找到的任何文档中似乎都没有涉及，而在Google上我主要使用语法差异很大的帖子，因为2.8似乎有很多东西改变了，我不确定那些仍然准确。

Answer 1

自从我挖掘Scala的源代码以寻求回答同样的问题以来，已经有一段时间了...但我回忆起简短的回答 -

Manifest是一个作弊代码，允许COMPILER绕过Type擦除（它没有在运行时使用）。它会导致在编译时为与清单匹配的可能输入类型生成多个代码路径。

Manifest是隐式解析的，但是如果编译时有关Manifest类型的含义有什么歧义，编译器将会停止。

使用Manifest的副本，您可以使用一些内容。您通常需要的主要内容是通过java.lang.Class删除的erasure：

class BoundedManifest[T <: Any : Manifest](value: T) {
  val m = manifest[T]
  m.erasure.toString match {
    case "class java.lang.String" => println("String")
    case "double" | "int"  => println("Numeric value.")
    case x => println("WTF is a '%s'?".format(x))
    }
}

class ImplicitManifest[T <: Any](value: T)(implicit m: Manifest[T]) {
  m.erasure.toString match {
    case "class java.lang.String" => println("String")
    case "double" | "int" => println("Numeric value.")
    case x => println("WTF is a '%s'?".format(x))
  }
}

new BoundedManifest("Foo Bar!")
// String 
new BoundedManifest(5)
// Numeric value.
new BoundedManifest(5.2)
// Numeric value.
new BoundedManifest(BigDecimal("8.62234525"))
// WTF is a 'class scala.math.BigDecimal'?
new ImplicitManifest("Foo Bar!")
// String 
new ImplicitManifest(5)
// Numeric value.
new ImplicitManifest(5.2)
// Numeric value.
new ImplicitManifest(BigDecimal("8.62234525"))
// WTF is a 'class scala.math.BigDecimal'?

这是一个相当不稳定的例子，但显示了正在发生的事情。我在Scala 2.8上运行了输出以及FWIW。

[T ... : Manifest]边界是Scala 2.8中的新边界...您曾经必须隐式抓取清单，如ImplicitManifest所示。你实际上并没有获得Manifest的副本。但是，您可以在val m = manifest[T]中manifest[_]定义Predef，并在明确的块中找到正确的清单类型，从而在代码中取一个。

您从Manifest获得的另外两个主要项目是<:<和>:>，它们测试一个清单与另一个清单的子类型/超类型。如果我没记错的话，这些都是非常天真的实现，并不总是匹配，但我有一堆生产代码使用它们来测试几个可能的擦除输入。检查另一个清单的简单示例：

class BoundedManifestCheck[T <: Any : Manifest](value: T) {
  val m = manifest[T]
  if (m <:< manifest[AnyVal]) {
    println("AnyVal (primitive)")
  } else if (m <:< manifest[AnyRef]) {
    println("AnyRef")
  } else {
    println("Not sure what the base type of manifest '%s' is.".format(m.erasure))
  }
}


new BoundedManifestCheck("Foo Bar!")
// AnyRef
new BoundedManifestCheck(5)
// AnyVal (primitive)
new BoundedManifestCheck(5.2)    
// AnyVal (primitive)
new BoundedManifestCheck(BigDecimal("8.62234525"))
// AnyRef

Jorge Ortiz有一篇很棒的博文（尽管很老）：http://www.scala-blogs.org/2008/10/manifests-reified-types.html

修改：

通过要求它打印出擦除编译器阶段的结果，您实际上可以看到Scala正在做什么。

在scala -Xprint:erasure test.scala上面的最后一个示例中运行会产生以下结果：

final class Main extends java.lang.Object with ScalaObject { def this(): object Main = { Main.super.this(); () }; def main(argv: Array[java.lang.String]): Unit = { val args: Array[java.lang.String] = argv; { final class $anon extends java.lang.Object { def this(): anonymous class $anon = { $anon.super.this(); () }; class BoundedManifestCheck extends java.lang.Object with ScalaObject { <paramaccessor> private[this] val value: java.lang.Object = _; implicit <paramaccessor> private[this] val evidence$1: scala.reflect.Manifest = _; def this($outer: anonymous class $anon, value: java.lang.Object, evidence$1: scala.reflect.Manifest): BoundedManifestCheck = { BoundedManifestCheck.super.this(); () }; private[this] val m: scala.reflect.Manifest = scala.this.Predef.manifest(BoundedManifestCheck.this.evidence$1); <stable> <accessor> def m(): scala.reflect.Manifest = BoundedManifestCheck.this.m; if (BoundedManifestCheck.this.m().<:<(scala.this.Predef.manifest(reflect.this.Manifest.AnyVal()))) scala.this.Predef.println("AnyVal (primitive)") else if (BoundedManifestCheck.this.m().<:<(scala.this.Predef.manifest(reflect.this.Manifest.Object()))) scala.this.Predef.println("AnyRef") else scala.this.Predef.println(scala.this.Predef.augmentString("Not sure what the base type of manifest '%s' is.").format(scala.this.Predef.genericWrapArray(Array[java.lang.Object]{BoundedManifestCheck.this.m().erasure()}))); protected <synthetic> <paramaccessor> val $outer: anonymous class $anon = _; <synthetic> <stable> def Main$$anon$BoundedManifestCheck$$$outer(): anonymous class $anon = BoundedManifestCheck.this.$outer }; new BoundedManifestCheck($anon.this, "Foo Bar!", reflect.this.Manifest.classType(classOf[java.lang.String])); new BoundedManifestCheck($anon.this, scala.Int.box(5), reflect.this.Manifest.Int()); new BoundedManifestCheck($anon.this, scala.Double.box(5.2), reflect.this.Manifest.Double()); new BoundedManifestCheck($anon.this, scala.package.BigDecimal().apply("8.62234525"), reflect.this.Manifest.classType(classOf[scala.math.BigDecimal])) }; { new anonymous class $anon(); () } } } }

Answer 2

“上下文绑定”T ... : Manifest是隐式参数的语法糖：(implicit man: Manifest[T])。因此，在class Image指定的类型构造函数的实例化时，编译器查找/提供用于类型参数T的实际类型的清单，并且该值“坚持”生成的类实例在其存在期间，将Image[Something]的每个特定实例“锚定”到其T的清单。

Scala（2.8）Manifest如何工作？

2 个答案: