val a: Set[Fruit]=Set[Apple]() does not compile, why? How can it be fixed?

Question

The line val a: Set[Fruit]=Set[Apple] does not compile, why ?

How can this be fixed ?

package sandbox.stackOverFlow

class Fruit 
class Apple extends Fruit
class Banana extends Fruit

class Why{
  val a:Set[Fruit]=Set[Apple]() // Does not compile, why ?
  val b:List[Fruit]=List[Apple]() // Does compile.
}

Produces compile error:

type mismatch;
 found   : scala.collection.immutable.Set[sandbox.stackOverFlow.Apple]
 required: Set[sandbox.stackOverFlow.Fruit]
Note: sandbox.stackOverFlow.Apple <: sandbox.stackOverFlow.Fruit, but trait Set is invariant in type A.
You may wish to investigate a wildcard type such as `_ <: sandbox.stackOverFlow.Fruit`. (SLS 3.2.10)
  val a:Set[Fruit]=Set[Apple]()
                         ^

EDIT:

As pointed out in Jatin's answer, this question is answered already here : Why is Scala's immutable Set not covariant in its type?

Jean-Philippe Pellet · Accepted Answer · 2014-03-15T08:34:13.273

4

The type parameter of Set (even immutable) is invariant (mainly because Set[A] inherits from A => Boolean, which is contra variant in A). The type parameter of List is covariant.

As for how this can be fixed, the compiler gives you a potential solution: using a wildcard, such as

val a: Set[_ <: Fruit] = Set[Apple]()

edited Mar 15 '14 at 08:34

answered Mar 14 '14 at 08:38

Jean-Philippe Pellet

59,296
21
173
234

1

As for how this can be fixed, the compiler gives you a potential solution: using a wildcard, such as `val a: Set[_<:Fruit]=Set[Apple]()` – Régis Jean-Gilles Mar 14 '14 at 08:45
Regis could you please put this as an answer, it addresses the issue of fixing it using existential types. – jhegedus Mar 14 '14 at 08:49
I have just edited Jean-Philippe Pellet's answer to include this "fix", I hope he won't mind – Régis Jean-Gilles Mar 14 '14 at 09:18

score 2 · Answer 2 · edited May 23 '17 at 12:05

Because type parameter of List (declared as List[+A])is co-variant where as for Set (declared as Set[A]) it is invariant.

In short,

Co-variance is: converting broader type to narrow type (say converting List[Animal to List[Dog]. Contra-variance is converting narrow type to broader type. For example Function1[Dog, something] extends Function1[Animal, Something]. Here you are converting Dog (narrow) to Animal (broader)

Invariance does not give you permission to do nay of above.

There are several links available which explain co-variance and contra-variance:

@jhegedus please read this http://stackoverflow.com/questions/676615/why-is-scalas-immutable-set-not-covariant-in-its-type — serejja, Mar 14 '14 at 08:40

score 1 · Answer 3 · answered Mar 14 '14 at 08:39

1

That's because Lists are covariant, ant Sets are invariant. Look at the definition:

sealed abstract class List[+A] extends...

trait Set[A] extends ...

answered Mar 14 '14 at 08:39

serejja

22,901
6
64
72

val a: Set[Fruit]=Set[Apple]() does not compile, why? How can it be fixed?

3 Answers3