Scala requires String: Question about Scala generics

However, would seem it simply attempts to make sense of + and generic A's by calling .toString

This is not what happens. The result is similar, but it's not calling .toString. You found the underlying problem though.

The sum function operates on a generic A on which you want to call the +method on.

But A doesn't have a + method (Remember that + in infix position is the same as x.+(y)). The compiler then searches the implicit scope for a function or class constructor to convert this A into something that has a + method. It finds it in any2stringadd.

Your method actually looks like

def sum[A](as: List[A]): Int = foldRight(as, 0)(any2Stringadd(_) + _)

Now the error makes sense. Because the + method of the any2Stringadd class expects a string as its argument. But your z argument is of type Int. You can see that, when you explicitly add the types to the inline function argument.

As other pointed out, this is not reconcilable without constraining the type parameter.

As others have said, you can't try to add instances of some type A that you know nothing about, since the Scala compiler gets confused and tries to implicitly turn your A objects into Strings, even though you have 0, which is an Int. However, you can get around this with typeclasses, like this.

trait Sum[T] {
  def id: T
  def add(_1: T, _2: T): T
}

implicit object IntSum extends Sum[Int] {
  def id = 0
  def add(i1: Int, i2: Int) = i1 + i2
}

def sum[A](as: List[A])(implicit sum: Sum[A]): A = foldRight(as, sum.id)(sum.add)

Here, IntSum is passed to the sum method implicitly, and its add method is used to sum your list together. You can define as many such implicit objects as you like for Double, String, etc.

Let's name some functions properly by thinking about what they are supposed to do:

def foldRight[A,B](l: List[A], z: B)(f: (A,B) => B): B =
  l match {
    case Nil => z
    case x :: xs => f(x, foldRight(xs, z)(f))
  }

def sumInts(numbers: List[Int]): Int = foldRight(numbers, 0)(_ + _)

def concatStrings(strings: List[String]): String = foldRight(strings, "")(_ + _)

def concatStringRepresentations[A](as: List[A]): String = foldRight(as, "")(_ + _)
concatStringRepresentations(List(List(), List(1,2,3), List(0))) // List()List(1, 2, 3)List(0)
concatStringRepresentations(List(1.0, 2.0, 3.0)) // 1.02.03.0

def sumIntRepresentations[A](as: List[A]): Int = foldRight(as, 0)(_ + _)  
// --> type mismatch, found: String, required: Int, for second param of (_ + _)

This is what your sum function was probably supposed to be named. To make it compile, we wish that there is

• a method +: Int => Int defined for any type, or...
• implicit conversions that convert any type to Int (something like toString with Int), or...
• other implicit conversions that make sense, or...
• something else, that can make this function succeed and is recognized by the compiler.

It turns out that Any can be implicitly converted to something that has a method +(other: String) => String that makes the String example work, but there is no implicit conversion from Any to something that has a method +(other: Int) => Int.

This could be explained in more detail and other answers already do that.

Opinions:

So, yes, the compiler gives a message that is confusing due to existence of implicit conversions. But let's look at the problem at hand which probably was our wishful thinking. Sometimes stuff just works like in the concatStringRepresentations function. It does not work in general, but in this special case with String it does.

Sometimes something works for a special case. And when we don't see that it is a special case, mistakes can happen, for instance when we apply it to something else.