reflect

Type Members

1. abstract class AnyValManifest[T <: AnyVal] extends Manifest[T] with Equals

   

   Annotations

   @SerialVersionUID()

2. trait ClassTag[T] extends ClassManifestDeprecatedApis[T] with Equals with Serializable

   

   A ClassTag[T] stores the erased class of a given type T, accessible via the runtimeClass field.

   A ClassTag[T] stores the erased class of a given type T, accessible via the runtimeClass field. This is particularly useful for instantiating Arrays whose element types are unknown at compile time.

   ClassTags are a weaker special case of scala.reflect.api.TypeTags#TypeTags, in that they wrap only the runtime class of a given type, whereas a TypeTag contains all static type information. That is, ClassTags are constructed from knowing only the top-level class of a type, without necessarily knowing all of its argument types. This runtime information is enough for runtime Array creation.

   For example:

   scala> def mkArray[T : ClassTag](elems: T*) = Array[T](elems: _*)
   mkArray: [T](elems: T*)(implicit evidence$1: scala.reflect.ClassTag[T])Array[T]
   
   scala> mkArray(42, 13)
   res0: Array[Int] = Array(42, 13)
   
   scala> mkArray("Japan","Brazil","Germany")
   res1: Array[String] = Array(Japan, Brazil, Germany)

   See scala.reflect.api.TypeTags for more examples, or the Reflection Guide: TypeTags for more details.

   Annotations

   @implicitNotFound( msg = "No ClassTag available for ${T}" )

3. trait Manifest[T] extends ClassManifest[T] with Equals

   

   A Manifest[T] is an opaque descriptor for type T.

   A Manifest[T] is an opaque descriptor for type T. Its supported use is to give access to the erasure of the type as a Class instance, as is necessary for the creation of native Arrays if the class is not known at compile time.

   The type-relation operators <:< and =:= should be considered approximations only, as there are numerous aspects of type conformance which are not yet adequately represented in manifests.

   Example usages:

   def arr[T] = new Array[T](0)                          // does not compile
   def arr[T](implicit m: Manifest[T]) = new Array[T](0) // compiles
   def arr[T: Manifest] = new Array[T](0)                // shorthand for the preceding
   
   // Methods manifest, classManifest, and optManifest are in [[scala.Predef]].
   def isApproxSubType[T: Manifest, U: Manifest] = manifest[T] <:< manifest[U]
   isApproxSubType[List[String], List[AnyRef]] // true
   isApproxSubType[List[String], List[Int]]    // false
   
   def methods[T: ClassManifest] = classManifest[T].erasure.getMethods
   def retType[T: ClassManifest](name: String) =
     methods[T] find (_.getName == name) map (_.getGenericReturnType)
   
   retType[Map[_, _]]("values")  // Some(scala.collection.Iterable)

   Annotations

   @implicitNotFound( msg = "No Manifest available for ${T}." )

4. trait OptManifest[+T] extends Serializable

   

   A OptManifest[T] is an optional scala.reflect.Manifest.

   A OptManifest[T] is an optional scala.reflect.Manifest.

   It is either a Manifest or the value NoManifest.

5. type ClassManifest[T] = ClassTag[T]

   

   A ClassManifest[T] is an opaque descriptor for type T.

   A ClassManifest[T] is an opaque descriptor for type T. It is used by the compiler to preserve information necessary for instantiating Arrays in those cases where the element type is unknown at compile time.

   The type-relation operators make an effort to present a more accurate picture than can be realized with erased types, but they should not be relied upon to give correct answers. In particular they are likely to be wrong when variance is involved or when a subtype has a different number of type arguments than a supertype.

   Annotations

   @deprecated @implicitNotFound( msg = ... )

   Deprecated

   (Since version 2.10.0) Use scala.reflect.ClassTag instead

6. trait ClassManifestDeprecatedApis[T] extends OptManifest[T]

   

   Annotations

   @deprecated

   Deprecated

   (Since version 2.10.0) Use scala.reflect.ClassTag instead