Scala's .type and Java's .class literal

Question

我从语言设计的角度思考为什么Scala已经删除了Java的类文字（例如String.class ）并用classOf[String]替换它，但是后来添加了一个“类型文字”，其单例类似于Singleton.type而不是类似于typeOf[Singleton] ？

Answer 1

Here is my rationalization:

classOf[T]

classOf is defined in Predef as a function with this signature:

def classOf[T]: Class[T]

Although it's implemented by the compiler, using the function syntax is possible without having to create any special treatment in terms of syntax . So that's one reason here to consider this option.

The alternative like String.class would imply that each class has a companion object with a field class . So there are two problems:

1. class is a keyword, so that causes a problem where the syntax would require a special case for it
2. if you just create class A without a companion object, it's would be odd to be able to refer to A.class , which would be like accessing the class field on the companion A .

A.type:

On why typeOf[A] may be confusing. It looks like a function call, but types don't live in the same world as function results (function results have types, but the type itself only makes sense at compile time). I can ascribe a type to a variable:

scala> val a: A.type = A
a: A.type = A$@c21a68

I can't assign a type like it's returned by a function:

scala> val b = A.type
<console>:1: error: identifier expected but 'type' found.
   val b = A.type
             ^

On the other hand types can be member of a object:

scala> object A { type type1 = Int }
defined module A

scala> val x: A.type1 = 1
x: A.type1 = 1

So it is not a big stretch to have A.type refer to the type of object A . Note that .type aren't used beyond referring to types of singleton objects, so it's not really that frequent.

Answer 2

Actually, it is quite consistent. Singleton.type is a dependent type of Singleton , while classOf[Class] is a type parameter to a method.

Consider this:

class A {
    class B
}

val a: A = new A
val b: a.B = new a.B

The point here is that . is used to indicate something that is a member of a value. It may be a val , a var , a def or an object and it may also be a type , a class or a trait .

Since a singleton object is a value, then Singleton.type is perfectly valid.

On the other hand, a class is not an object, so Class.class doesn't make sense. Class doesn't exist (as a value), so it is not possible to get a member of it. On the other hand, it's definition as def classOf[T]: Class[T] is plain Scala code (even if the actual implementation is compiler magic).