Type Inference with Abstract Types

A second "gotcha" that one might get tripped up when dealing with abstract types is the signature of the concrete class contains type information about the abstract type. So if you are not explicit when assigning a variable or defining a function you can get unexpected compiler errors.

1. scala> trait S {
2.      |   type x
3.      |   def get : x
4.      | }
5. defined trait S
7. scala> var sample = new S{ 
8.      |   type x = Int
9.      |   def get = 3
10.      | }
11. sample: java.lang.Object with S{type x = Int} = $anon$1@397af435
13. scala> sample = new S {
14.      |   type x = Double
15.      |   def get = 3.0
16.      | }
17. < console>:7: error: type mismatch;
18.  found   : java.lang.Object with S
19.  required: java.lang.Object with S{type x = Int}
20.        sample = new S {

In this example sample uses type inference so the actual type is S with underlying type Int. The consequence is that sample can only be assigned with instances of S with type x = Int. The fix is to explicitly declare the variable type:

1. scala> var sample2 : S = new S{ 
2.      |   type x = Int
3.      |   def get = 3
4.      | }
5. sample2: S = $anon$1@31602bbc
7. scala> sample2 = new S {
8.      |   type x = Double
9.      |   def get = 3.0
10.      | }
11. sample2: S = $anon$1@4de5ed7b

The same thing happens when declaring functions and allows type inference for function definition

1. scala> class Fac {
2.      |   def newS = new S {
3.      |     type x = Int
4.      |     def get = 3
5.      |   }
6.      | }
7. defined class Fac
9. scala> class SubFac extends Fac{
10.      |   override def newS = new S {
11.      |     type x = Double
12.      |     def get = 3.0
13.      |   }
14.      | }
15. < console>:8: error: type mismatch;
16.  found   : java.lang.Object with S
17.  required: java.lang.Object with S{type x = Int}
18.          override def newS = new S {

The fix for this example is to be explicit in the definition of the function in the superclass