Where is the `++=` operator defined for a scala immutable list?

Question

How is the ++= being evaluated in the code below? The ++= operator is being applied to a class that is explicitly defined as an immutable list, which does not have the ++= operator. x ++= y appears to have the same behavior as x = x ++ y, but I cannot find where this behavior is coming form. What is happening here? (and where is it documented?)

object ListConcatenation extends App { var list = scala.collection.immutable.List[Int](1) println(list) list = list ++ scala.collection.immutable.List[Int](2) println(list) // This operator does not exist on the List class, but has the same behavior as the operation above. list ++= scala.collection.immutable.List[Int](3) println(list) }

Output

List(1) List(1, 2) List(1, 2, 3)

Isn't it actually two operators? The unary var++ and an assignment with =? — Laurel
– Laurel, Commented May 16, 2016 at 21:57
@Laurel if I put a space between the ++ and the = operator, then is does not compile. — Rylander
– Rylander, Commented May 16, 2016 at 21:59

sepp2k · Accepted Answer · 2016-05-16 22:05:46Z

x ++= y appears to have the same behavior as x = x ++ y

It does.

but I cannot find where this behavior is coming form.

It's built into the language. When x op= y can't be interpreted as a calling the method op= (because no such method exists in x's class or any class that it can be implicitly converted to), it's instead interpreted as calling the method op and an assignment.

(and where is it documented?)

In Scala's language specification, section 6.12.4:

Assignment Operators

An assignment operator is an operator symbol (syntax category op in Identifiers) that ends in an equals character “=”, with the exception of operators for which one of the following conditions holds:

the operator also starts with an equals character, or

the operator is one of (<=), (>=), (!=).

Assignment operators are treated specially in that they can be expanded to assignments if no other interpretation is valid.

Let's consider an assignment operator such as += in an infix operation l += r, where l, r are expressions. This operation can be re-interpreted as an operation which corresponds to the assignment
l = l + r 
except that the operation's left-hand-side l is evaluated only once.

The re-interpretation occurs if the following two conditions are fulfilled.

The left-hand-side l does not have a member named +=, and also cannot be converted by an implicit conversion to a value with a member named +=.

The assignment l = l + r is type-correct. In particular this implies that l refers to a variable or object that can be assigned to, and that is convertible to a value with a member named +.

Collectives™ on Stack Overflow

Where is the `++=` operator defined for a scala immutable list?

1 Answer 1

Assignment Operators

Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Assignment Operators

Comments

Linked

Related