How to circumvent invariance? E.g. passing Array[T] to func(Array[U]) where T<:U

Question

I'm practicing scala using an existing java library. It's quite common to pass Array[T] to func(Array[U]) where T<:U. For example:

Java:

public class Quick { ...
    public static void sort(Comparable[] a) { ... }
}

public class Edge implements Comparable<Edge> { ... }

public class EdgeWeightedGraph { ...
    public Iterable<Edge> edges() { ... }
}

Scala:

class Kruskal(private val G: EdgeWeightedGraph) {
    init()
    private def init() = {
        val es = G.edges().asScala.toArray
        /* **Error** Type mismatch, 
         *           expected: Array[Comparable[_]], 
         *           actual: Array[Edge]
         */
        Quick.sort(es)  
        ...
    }
}

I believe it's because the fact that Array is invariant. Here's my attempt to circumvent this, but it looks ugly and inefficient:

val es = G.edges().asScala.map(_.asInstanceOf[Comparable[_]]).toArray)
Quick.sort(es)

How do I do it in a better way?

Answer 1

Arrays are invariant because they are mutable. If they weren't invariant you could do something like

class Fruit
class Apple extends Fruit
class Orange extends Fruit

val apples:Array[Apple] =  Array(new Apple())
val fruits:Array[Fruit] = apples
fruits.update(0,new Orange)

val apple:Apple = apples(0) //<= epic fail I now have an orange as an apple ?

The only way I can think of is to copy the collection to an equivalent immutable collection (subtype of collection.immutable.Seq)

class Fruit
class Apple extends Fruit
class Orange extends Fruit

val apples:Array[Apple] =  Array(new Apple())
val fruits:collection.immutable.Seq[Fruit]=apples.toList // or apples.toIndexedSeq

then get an immutable collection and you can get variance

in your specific example you could change

val es = G.edges().asScala.toArray

to

val es = G.edges().asScala.toIndexedSeq

but then you will have to make the QuickSort signature accept an IndexedSeq I guess. It is hard to tell the consequences without more code ...