Quelle est la différence entre ces deux appels à une fonction prenant une collection de types structurels?

Question

Pourquoi l'appel à fn (Iterator ("foo") compile, mais l'appel à fn (fooIterator) échoue avec une erreur "incompatibilité de type; found: Iterator [java.lang.String] requis: scala.Iterator [ com.banshee.Qx.HasLength] "

object Qx { 
    type HasLength = {def length: Int} 
    def fn(xs: Iterator[HasLength]) = 3 
    var tn = fn(Iterator("foo")) 
    var fooIterator = Iterator("foo") 
    var tnFails = fn(fooIterator) //doesn't compile 
} 

sont-ils pas la même chose

Answer 1

Il doit être un bogue dans la représentation des raffinements, car les deux formules suivantes les deux fonctionnent.

object Qx1 { 
    // give length() parens, even though the Iterator definition doesn't have them 
    type HasLength = { def length(): Int } 

    def fn(xs: Iterator[HasLength]) = 3 
    var tn = fn(Iterator("foo")) 
    var fooIterator = Iterator("foo") 
    var tnFails = fn(fooIterator) //doesn't compile 
} 

object Qx2 { 
    type HasLength = { def length: Int } 

    def fn(xs: Iterator[HasLength]) = 3 
    var tn = fn(Iterator("foo")) 
    // annotate the type of fooIterator before the type inferencer can mis-infer 
    var fooIterator: Iterator[HasLength] = Iterator("foo") 
    var tnFails = fn(fooIterator) //doesn't compile 
} 

Edit:

trop tôt le matin. C'est String avec la méthode length(), qui a des parens, ce qui signifie que c'est juste et que vous avez tort de penser que length et length() sont la même méthode. (C'est un joli petit piège que j'ai documenté auparavant.)

Answer 2

Cette formulation fonctionne:

object Qx { 
    type HasLength = {def length: Int} 
    def fn[HL <% HasLength](xs: Iterator[HL]) = 3 
    val tn = fn(Iterator("foo")) 
    val fooIterator = Iterator("foo") 
    val tnFails = fn(fooIterator) 
}