Polymorphism not working as expected in scala - scala

Question

I have two methods declared in object List:
def reduce[A, B >: A](l: List[A])(f: (B, B) => B): B =
reduceLeft(l)(f)
def reduceLeft[A, B >: A](l: List[A])(op: (B, A) => B): B = ???
I've borrowed the signatures from the scala.collection.TraversableOnce class. (I'm re-creating my own classes for pedagogical reasons).
The compiler is giving me this error:
[error] /.../List.scala:159: type mismatch;
[error] found : (B, B) => B
[error] required: (A, A) => A
[error] reduceLeft(l)(f)
[error] ^
my List class is
final case class ::[A](head: A, tail: List[A]) extends List[A] {
override def isEmpty: Boolean = false
}
sealed trait List[+A] {
def head: A
def tail: List[A]
def isEmpty: Boolean
def ::[B >: A](x: B): List[B] =
datastructures.::(x, this)
}
how can the TraversableOnce definition get away with this? Is it something to do with me not having defined the method as an infix operation?
sealed trait List[+A] {
...
def reduce(op: (B,B) => B):B = reduceLeft(op) // e.g.
... //reduceLeft...
}
Update
I've tried it in the way the TraversableOnce class declares in infix to the trait and it seems to work (see below), however I'm still curious as to why the object definition doesn't work.
sealed trait List[+A] {
...
def reduce[B >: A](f: (B, B) => B): B =
self.reduceLeft(f)
def reduceLeft[B >: A](op: (B, A) => B): B = {
if (isEmpty)
throw new UnsupportedOperationException("empty.reduceLeft")
var first = true
var acc: B = 0.asInstanceOf[B]
for (x <- self) {
if (first) {
acc = x
first = false
}
else acc = op(acc, x)
}
acc
}
#tailrec
final def foreach[U](f: A => U): Unit = { f(head); tail.foreach(f); }
...
}

Answer 1

Here's what's happening here: when you call reduceLeft(l)(f), you first call reduceLeft(l), with l: List[A]. Since your reduceLeft takes two type arguments, but you're not specifying them explicitly, and so far it only has A to work with. So, compiler infers the types as best as it can, using A for both types. You can see this by extracting this partial application into variable:
val partiallyApplied: ((A, A) => A) => A = reduceLeft(l)
Then, when you apply the second argument list with f: (B, B) => B, the types mismatch.
The fix is simple - explicitly state the types when calling reduceLeft:
def reduce[A, B >: A](l: List[A])(f: (B, B) => B): B = {
reduceLeft[A, B](l)(f)
}