score:6

If you look at the type signature of `toIndexedSeq` on `List` you'll see it takes a type parameter `B`, which can be any supertype of `A`:

``````def toIndexedSeq [B >: A] : IndexedSeq[B]
``````

If you leave out that type parameter then the compiler essentially has to guess what you meant, taking the most specific type possible. You could have meant `List(3,2,1).toIndexedSeq[Any]`, which of course can't be sorted since there's no `Ordering[Any]`. It seems the compiler doesn't play "guess the type parameter" until the whole expression has been checked for correct typing (maybe someone who knows something about compiler internals can expand on this).

To make it work you can either a) provide the required type parameter yourself i.e.

``````List(3,2,1).toIndexedSeq[Int].sortBy(x=>x)
``````

or b) separate the expression into two so that the type parameter has to be inferred before calling `sortBy`:

``````val lst = List(3,2,1).toIndexedSeq; lst.sortBy(x=>x)
``````

Edit:

It's probably because `sortBy` takes a `Function1` argument. The signature of `sortBy` is

``````def sortBy [B] (f: (A) => B)(implicit ord: Ordering[B]): IndexedSeq[A]
``````

whereas `sorted` (which you should use instead!) works fine with `List(3,2,1).toIndexedSeq.sorted`

``````def sorted [B >: A] (implicit ord: Ordering[B]): IndexedSeq[A]
``````

I'm not sure exactly why `Function1` causes this problem and I'm going to bed so can't think about it further...