What's the difference between these two calls to a function taking a collection of structural types?

Question

Why does the call to fn(Iterator("foo") compile, but the call to fn(fooIterator) fail with an error "type mismatch; found : Iterator[java.lang.String] required: 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
}

Aren't they the same thing?

Answer 1

This formulation works:

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)
}

Answer 2

It has to be a bug in the representation of refinements, because the following two formulations both work.

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:

Too early in the morning. It's String with the length() method, which does have parens, which means it's right and you're wrong for thinking length and length() are the same method. (It's a nice little trap I've documented before.)