Scala 我可以为参数化类型构造一个类清单，而不必为类型参数创建清单吗？

ClassManifest[T]在Scala中主要用于创建数组[T]s

我感兴趣的是数组类型T不是一个原语，而是一个接受类型构造函数的类，即AnyRef的子类型。然后，我可以为参数化类型构造一个类清单，而不必为其类型参数创建清单吗

class Foo[A]

def getManifestFor[A]: ClassManifest[Foo[A]] = ???

---

由于Foo是非原语的，因此JVM数组存储似乎是一个引用数组，其大小/内存布局不受擦除类型参数的影响（如上面的A）。因此，从理论上讲这似乎是可能的，但我不知道如何用Scala编写它。

您的评论是正确的，正如您所强调的，类清单比清单“轻”，您可以从类型构造函数构建它

scala> class Foo[A] 
defined class Foo

scala>  object test { def getManifestFor[A] = implicitly[ClassManifest[Foo[A]]] } 
defined module test

scala>  test.getManifestFor[Foo[Int]]
res2: ClassManifest[Foo[Foo[Int]]] = Foo[<?>]

scala>  :javap -p test
Compiled from "<console>"
public final class test$ extends java.lang.Object implements scala.ScalaObject{
    public static final test$ MODULE$;
    public static {};
    public scala.reflect.ClassManifest getManifestFor();
    public test$();
}

scala>class Foo[A]
定义类Foo
scala>对象测试{def getManifestFor[A]=隐式[ClassManifest[Foo[A]]]}
定义模块测试
scala>test.getManifestFor[Foo[Int]]
res2:ClassManifest[Foo[Foo[Int]]]=Foo[]
scala>：javap-p测试
从“”编译
公共最终类测试$extends java.lang.Object实现scala.ScalaObject{
公共静态最终测试$MODULE$；
公共静态{}；
public scala.reflect.ClassManifest getManifestFor（）；
公开考试$（）；
}

您的评论是正确的，正如您所强调的，类清单比清单“轻”，您可以从类型构造函数构建它

scala> class Foo[A] 
defined class Foo

scala>  object test { def getManifestFor[A] = implicitly[ClassManifest[Foo[A]]] } 
defined module test

scala>  test.getManifestFor[Foo[Int]]
res2: ClassManifest[Foo[Foo[Int]]] = Foo[<?>]

scala>  :javap -p test
Compiled from "<console>"
public final class test$ extends java.lang.Object implements scala.ScalaObject{
    public static final test$ MODULE$;
    public static {};
    public scala.reflect.ClassManifest getManifestFor();
    public test$();
}

scala>class Foo[A]
定义类Foo
scala>对象测试{def getManifestFor[A]=隐式[ClassManifest[Foo[A]]]}
定义模块测试
scala>test.getManifestFor[Foo[Int]]
res2:ClassManifest[Foo[Foo[Int]]]=Foo[]
scala>：javap-p测试
从“”编译
公共最终类测试$extends java.lang.Object实现scala.ScalaObject{
公共静态最终测试$MODULE$；
公共静态{}；
public scala.reflect.ClassManifest getManifestFor（）；
公开考试$（）；
}

一些实验回答了我的问题：

def manifestFor[A]：ClassManifest[Foo[A]]=隐式[ClassManifest[Foo[A]]]

<代码>隐式搜索隐式类清单[Foo[A]]。我想编译器可以提供一个基于我上面提到的原因。现在回想起来，这似乎是显而易见的。我最初感到困惑，因为在我的应用程序中，我对类型很粗心，使用的是Manifest[T]，而不是ClassManifest[T]。清单[T]意味着更准确；必须知道T型的所有零件。这是一个编译错误：

def manifestFor[a]：Manifest[Foo[a]]=隐式[Manifest[Foo[a]]]

为什么隐式解决方案不合适？一些实验回答了我的问题：

def manifestFor[a]：ClassManifest[Foo[a]=隐式[ClassManifest[Foo[a]]]

<代码>隐式搜索隐式类清单[Foo[A]]。我想编译器可以提供一个基于我上面提到的原因。现在回想起来，这似乎是显而易见的。我最初感到困惑，因为在我的应用程序中，我对类型很粗心，使用的是Manifest[T]，而不是ClassManifest[T]。清单[T]意味着更准确；必须知道T型的所有零件。Ie这是一个编译错误：

def manifestFor[a]：Manifest[Foo[a]]=隐式[Manifest[Foo[a]]]

为什么隐式解决方案不合适？