Why the variation in operators?

Question

Long time lurker, first time poster.

In Scala, I'm looking for advantages as to why it was preferred to vary operators depending on type. For example, why was this:

Vector(1, 2, 3) :+ 4

determined to be an advantage over:

Vector(1, 2, 3) + 4

Or:

4 +: Vector(1,2,3)

over:

Vector(4) + Vector(1,2,3)

Or:

Vector(1,2,3) ++ Vector(4,5,6)

over:

Vector(1,2,3) + Vector(4,5,6)

So, here we have :+, +:, and ++ when + alone could have sufficed. I'm new at Scala, and I'll succumb. But, this seems unnecessary and obfuscated for a language that tries to be clean with its syntax.

I've done quite a few google and stack overflow searches and have only found questions about specific operators, and operator overloading in general. But, no background on why it was necessary to split +, for example, into multiple variations.

FWIW, I could overload the operators using implicit classes, such as below, but I imagine that would only cause confusion (and tisk tisks) from experienced Scala programmers using/reading my code.

object AddVectorDemo {

    implicit class AddVector(vector : Vector[Any]) {
        def +(that : Vector[Any]) = vector ++ that
        def +(that : Any) = vector :+ that
    }

    def main(args : Array[String]) : Unit = {
        val u = Vector(1,2,3)
        val v = Vector(4,5,6)
        println(u + v)
        println(u + v + 7)
    }
}

Outputs:

Vector(1, 2, 3, 4, 5, 6)
Vector(1, 2, 3, 4, 5, 6, 7)

See also https://stackoverflow.com/questions/6559996/scala-list-concatenation-vs — DNA, Jun 05 '15 at 21:50

score 6 · Answer 1 · answered Jun 05 '15 at 21:48

The answer requires a surprisingly long detour through variance. I'll try to make it as short as possible.

First, note that you can add anything to an existing Vector:

scala> Vector(1)
res0: scala.collection.immutable.Vector[Int] = Vector(1)

scala> res0 :+ "fish"
res1: scala.collection.immutable.Vector[Any] = Vector(1, fish)

Why can you do this? Well, if B extends A and we want to be able to use Vector[B] where Vector[A] is called for, we need to allow Vector[B] to add the same sorts of things that Vector[A] can add. But everything extends Any, so we need to allow addition of anything that Vector[Any] can add, which is everything.

Making Vector and most other non-Set collections covariant is a design decision, but it's what most people expect.

Now, let's try adding a vector to a vector.

scala> res0 :+ Vector("fish")
res2: scala.collection.immutable.Vector[Any] = Vector(1, Vector(fish))

scala> res0 ++ Vector("fish")
res3: scala.collection.immutable.Vector[Any] = Vector(1, fish)

If we only had one operation, +, we wouldn't be able to specify which one of these things we meant. And we really might mean to do either. They're both perfectly sensible things to try. We could try to guess based on types, but in practice it's better to just ask the programmer to explicitly say what they mean. And since there are two different things to mean, there need to be two ways to ask.

Does this come up in practice? With collections of collections, yes, all the time. For example, using your +:

scala> Vector(Vector(1), Vector(2))
res4: Vector[Vector[Int]] = Vector(Vector(1), Vector(2))

scala> res4 + Vector(3)
res5: Vector[Any] = Vector(Vector(1), Vector(2), 3)

That's probably not what I wanted.

score 5 · Accepted Answer · edited May 23 '17 at 11:58

It's a fair question, and I think it has a lot to do with legacy code and Java compatibility. Scala copied Java's + for String concatenation, which has complicated things.

This + allows us to do:

(new Object) + "foobar" //"java.lang.Object@5bb90b89foobar"

So what should we expect if we had + for List and we did List(1) + "foobar"? One might expect List(1, "foobar") (of type List[Any]), just like we get if we use :+, but the Java-inspired String-concatenation overload would complicate this, since the compiler would fail to resolve the overload.

Odersky even once commented:

One should never have a + method on collections that are covariant in their element type. Sets and maps are non-variant, that's why they can have a + method. It's all rather delicate and messy. We'd be better off if we did not try to duplicate Java's + for String concatenation. But when Scala got designed the idea was to keep essentially all of Java's expression syntax, including String +. And it's too late to change that now.

There is some discussion (although in a different context) on the answers to this similar question.

Helpful context for the above Odersky quote: http://www.scala-lang.org/old/node/5441 — l p, Jun 09 '15 at 21:45
While both responses were insightful, I marked this as the answer because it led me to justification from the designer of the language himself (whether I agree with it or not). — l p, Jun 09 '15 at 21:53

Why the variation in operators?

2 Answers2