investigation of `type` and `#` keywords in scala

Question

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 :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 :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 :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 :1: error:…

Accepted Answer

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, `object`s, and `val`s, 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 `A`s 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.

investigation of `type` and `#` keywords in scala

Solution

Problem

Related problems