问题
Could someone explain how the type keyword and # operator works in scala and how to use it?
Please look at examples.
//Example1
scala> type t1 = Option.type
defined type alias t1
//Shouldn't this work since previous example simply works?
scala> type t2 = String.type
<console>:7: error: type mismatch;
found : String.type
required: AnyRef
type t2 = String.type
^
//lets define custom trait T
scala> trait T
defined trait T
//... and obtain it's type like in Example1.
//Shouldn't this work since previous Example1 simply works?
scala> type t3 = T.type
<console>:7: error: not found: value T
type t3 = T.type
^
//Lets define some value of type T
scala> val v4 = new T{}
v4: T = $anon$1@5c3e8c76
//and obtain it's type (works)
scala> type t4 = v4.type
defined type alias t4
//this doesn't work
scala> type t4_1 = (new T{}).type
<console>:1: error: identifier expected but 'new' found.
type t4_1 = (new T{}).type
//as well as this (doesn't work)
scala> type t5 = "abc".type
<console>:1: error: identifier expected but string literal found.
type t5 = "abc".type
^
//but this compiles well
scala> val v6 = "abc"
v6: String = abc
scala> type t6 = v6.type
defined type alias t6
//lets create some values of created types:
scala> type t1 = Option.type
defined type alias t1
scala> val v1_1 = Some(10)
v1_1: Some[Int] = Some(10)
scala> type t7 = v1_1.type
defined type alias t7
scala> val v7:t7 = null
v7: t7 = null
scala> val v7_1:t7 = v1_1
v7_1: t7 = Some(10)
scala> val v7_2:t7 = Some(10)
<console>:9: error: type mismatch;
found : Some[Int]
required: t7
(which expands to) v1_1.type
val v7_2:t7 = Some(10)
^
//next let's try # operator
scala> class X[A,B](a:A,b:B)
defined class X
//doesn't work
scala> type xa = X[A,B]#A
<console>:8: error: not found: type A
type xa = X[A,B]#A
^
<console>:8: error: not found: type B
type xa = X[A,B]#A
^
//but such approach works:
scala> trait X2[C]{
type A
type B
val c:C
}
defined trait X2
scala> type xa2_1 = X2[String]#A
defined type alias xa2_1
scala> type xa2_2[M] = X2[M]#A
defined type alias xa2_2
回答1:
First, your questions about type:
The right hand side of a type declaration has to be the name of a type with a stable path. So taking your examples one by one:
type t1 = Option.type
t1 is an alias for the type of the Option object, not the Option class.
type t2 = String.type
This is an error because there is no String object. The error's a little weird because String's a Java class and so operates under different rules (since Java classes never have companions).
type t3 = T.type
ditto. This time the error's clearer, because T is a Scala class and so the compiler can unambiguously say "T does not name an object with a type"
type t4 = v4.type
This is the singleton type of the object named by the val v4. It doesn't refer to any instance of type T, or even any instance of the anonymous class created by your new T{} expression. It refers to a type that is only represented by v4 and null, i.e. they are the only allowed values of that type.
type t4_1 = (new T{}).type
This is illegal because the thing you're taking the type of has to be a stable identifier (roughly, an identifier whose referant can never change -- if the full path to the idenfier consists of only the names of packages, objects, and vals, it's stable).
type t5 = "abc".type
Ditto.
type t6 = v6.type
v6 is a stable identifier. t6 is the type inhabited solely by that particular instance of String which is referred to by the name v6 (and null).
type v6 = v1_1.type
Again, a singleton type.
val v7: t7 = null
null is a valid value of type t7
val v7_1:t7 = v1_1
So is this particular object.
val v7_2:t7 = Some(10)
But this is a different object (even though it's == to v7, it's not eq to it) and therefore is not a member of this type.
Now about #:
class X[A,B](a:A,b:B)
A and B are type parameters. They can't be referred to outside the class. You can think of them like abstract type aliases with private[this] visibility, though that's not quite accurate.
type xa = X[A,B]#A
So yeah, not visible.
type xa2_1 = X2[String]#A
Since this A refers to a public type alias, it can be referred to by name outside the class. Note that this particular case is pretty useless, because you know absolutely nothing about this type. if your trait X2 had a method that returned values of type A, you could do something like
val aFromX2: xa2_1 = x2instance.methodThatReturnsAnA
..but then you couldn't do anything else with it, even pass it back to an instance of X2[String] because there's no guarantee that that the two As would refer to the same type! On the other hand, if you have a concrete instance, you could do this:
def passAroundA(x2instance: X2[String]) {
type x2a = x2instance.A // note dot, not #
val a: x2a = x2instance.methodThatReturnsAnA
x2instance.methodThatTakesAnA(a)
}
In this case it works because even though we have no idea what A actually is, we know that the two methods use the same type -- whatever was fixed at x2instance's construction.
回答2:
Practically everything regarding your question is explained in this imho absolutely essential talk on use cases like pattern matching etc. I suggest you to take the time to watch it and the effort to thing about it. A lot of scala Type system related stuff was actually a magic to me until I watched this video. I might spare a lot of my man days trying to resolve weird behavior of the type system and type inference if I was aware of these things.
来源：https://stackoverflow.com/questions/12959438/investigation-of-type-and-keywords-in-scala