Implicit '=' operator

Continuing on with operators, There is a special type of operator in Scala. It is an operator that ends with =. If a class has operation (methods with an operator identifer) the = can be appended to the effectively creating a new method. In truth a new method is not created instead the compiler rewrites the line.

For example. If a method (like Int) defines + then a method call += can be used. It can be used to mutate a variable:

1. scala> var i = 1
2. i: Int = 1
4. scala> i += 1
6. scala> i
7. res3: Int = 2

To illustrate this is not a special case for Int the next example defines several operations and demonstrates in place variable mutation.

1. scala> case class MyClass(i:Int) {      
2.      | def +(j:Int) = new MyClass(j + i)
3.      | def -(j:Int) = new MyClass(i - j)
4.      | def ^(j:Int) = MyClass(j)
5.      | def +|(j:Int) = new MyClass(j + i / 3)
6.      | }
7. defined class MyClass
9. scala> var c = MyClass(1)
10. c: MyClass = MyClass(1)
12. scala> c+=6
14. scala> c
15. res5: MyClass = MyClass(7)
17. scala> c -= 2
19. scala> c
20. res7: MyClass = MyClass(5)
22. scala> c ^= 10
24. scala> c
25. res23: MyClass = MyClass(10)
27. scala> c +|= 5
29. scala> c
30. res25: MyClass = MyClass(8)

Here are several more examples using existing classes in Scala. They are all immutable examples.

1. scala> var l = Set(1,2,3) 
2. l: scala.collection.immutable.Set[Int] = Set(1, 2, 3)
4. scala> l += 10
6. scala> l
7. res7: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 10)
9. scala> var seq = Seq(5,6,3)
10. seq: Seq[Int] = List(5, 6, 3)
12. scala> seq :+= 10
14. scala> seq                 
15. res9: Seq[Int] = List(5, 6, 3, 10)
17. scala> seq +:= 10   
19. scala> seq       
20. res11: Seq[Int] = List(10, 5, 6, 3, 10)
22. scala> var list = List(32)
23. list: List[Int] = List(32)
25. scala> list ::= 12
27. scala> list
28. res13: List[Int] = List(12, 32)

Note: assignment operators can also be defined as methods to mutate an object

1. scala> case class MyClass(var i:Int) {
2.      | def += (j:Int) = { i+=j ; this }
3.      | }
4. defined class MyClass
6. scala> val m = MyClass(6)
7. m: MyClass = MyClass(6)
9. scala> m += 7
10. res0: MyClass = MyClass(13)
12. scala> m += 9
13. res1: MyClass = MyClass(22)
15. scala> res1 eq m
16. res2: Boolean = true

Operators

Since Scala allows one to define the behavior of operators there are some rules involving operators and assignment like +=. One of the standard method calls in most languages is i += 1.

Since i+=1(no spaces) is also valid, Scala has some rules regarding how statements like i+=1 should be broken up. Obviously we know it should be 'i' '+=' and '1'. So there is a special class of characters called operators. I don't know all of them but a few are: + - ^ * / % ! | & =( ':' is sort of part of this group but has some special properties as well).

These characters can be method names but they cannot be combined with other identifier characters.

Update: These characters can be combined with other identifier characters if there is an under score so:

1. def x+ = 3   // not valid
2. def x_+ = 3  // valid
3. def +x = 3   // not valid

However these characters are special because they can be combined in a special way with '=' for a special assignment construct as shown in the next post.

(end update)

1. scala> case class MyClass(i:Int) {
2.      | def +(j:Int) = new MyClass(j + i)
3.      | def -(j:Int) = new MyClass(i - j)
4.      | def ^(j:Int) = MyClass(j)
5.      | def +|(j:Int) = new MyClass(j + i / 3)
6.      | }
7.  
8.  scala> val c = MyClass(3)
9.  c: MyClass = MyClass(3)
11.  scala> c + 4
12.  res26: MyClass = MyClass(7)
14.  scala> c-2 
15.  res27: MyClass = MyClass(1)
17.  scala> c -6
18.  res28: MyClass = MyClass(-3)
20.  scala> c ^ 3
21.  res29: MyClass = MyClass(3)
23.  scala> c+|5
24.  res31: MyClass = MyClass(6)