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)

Temporary variables during object instantiation

In Java a common pattern with class constructors is to assign field values and often there are several intermediate values used for the calculation. If the code is ported to Scala the resulting class will have the intermediate values as fields, which take up space in the object. However the issue is easily worked around. Lets look at a couple examples.

Example 1: Assigning a single field

1. //  Java
2. import java.io.File
4. /** 
5. No real logic behind class.  But for some reason it needs the path of a tmp directory in the working directory
6. */
7. class OneAssignment {
8.   final String field;
9.   public OneAssignment() {
10.     File file = new File("tmp");
11.     if(!file.exists()) {
12.       file.mkdirs();
13.     }
14.     field = file.getAbsolutePath();
15.   }
16. }

In Scala the naive way to port this would be:

1. //  Scala
2. import java.io.File
3. class OneAssignment {
4.   val file = new File("tmp")
5.   if(!file.exists()) {
6.     file.mkdirs()
7.   }
8.   val field = file.getAbsolutePath()
9. }

Problem is that it has an extra field "file" now. The correct way to port this would be as follows:

1. //  Scala
2. import java.io.File
3. class OneAssignment {
4. /* 
5. notice that assignment is in a block so file is only visible within the block
6. */
7.   val field = {
8.     val file = new File("tmp")
9.     if(!file.exists()) {
10.       file.mkdirs()
11.     }
12.     file.getAbsolutePath()
13.   }
14. }

Example 2: Assigning multiple fields

1. //  Java
2. import java.io.File
4. /** 
5. Basically the same as last example but multiple fields are assigned
6. Notice that 2 fields depend on the temporary file variable but count does not
7. */
8. class MultipleAssignments {
9.   final String tmp,mvn_repo;
10.   find int count;
11.   public OneAssignment() {
12.     File file = new File("tmp");
13.     if(!file.exists()) {
14.       file.mkdirs();
15.     }
16.     tmp = file.getAbsolutePath();
17.     count = file.listFiles.length;
18.     
19.     File home = new File(System.getProperty("user.home"));
20.     mvn_repo = new File(home, ".m2").getPath();
21.   }
22. }

The Scala port:

1. //  Scala
2. import java.io.File
3. class MultipleAssignments {
4. /*
5. When multiple fields depend on the same temporary variables the fields can be assigned together from one block by returning a tuple and using Scala's matching to expand the tuple during assignment.  See previous topics on assignment for details 
6. */
7.   val (tmp,count) = {
8.     val file = new File("tmp");
9.     if(!file.exists()) {
10.       file.mkdirs();
11.     }
12.     val tmp = file.getAbsolutePath();
13.     val count = file.listFiles.length;
14.     (tmp, count)
15.   }
16.   val mvn_repo = {
17.     val home = new File(System.getProperty("user.home"));
18.     new File(home, ".m2").getPath();
19.   }
20. }

In some ways the Scala port is cleaner in that it splits the constructor up and decouples the dependencies between fields.

Import Instance Properties

A truly fantastic aspect of Scala is the uniform principle that Scala attempts to adhere to. In other words Scala tries to not make any rules that only apply to a single case when it can be applied generally.

One example is matching you can see several uses of matching in the following topics:

• Assignments
• Assignment and Parameter Objects

But matching it applies to today's topic as well. This topic covers a cool trick that helps assist with parameter objects and complex return types.

This topic is another take on Assignment and Parameter Objects. There are cases when a method has a large number of parameters and the API can be cleaned up by introducing a parameter object. Or perhaps an object with several public proprties are passed to a method.

1. scala> case class Params(p1:Int, p2:Int, p3:Int)
2. defined class Params
4. scala>  def method(params:Params) = {
5.      |   println(params.p1, params.p2, params.p3)
6.      | }
7. method: (Params)Unit
9. scala> method(Params(1,2,3))
10. (1,2,3)
11. }

The symbol 'params' introduces noise into the code. The noise can be reduced further by assigned the properties of the parameter object to local variables:

1. scala>  case class Params(p1:Int, p2:Int, p3:Int)
2. defined class Params
4. scala> 
6. scala>  def method(params:Params) = {
7.      |   val Params(p1,p2,p3) = params
8.      |   println(p1,p2,p3)
9.      | }
10. method: (Params)Unit
12. scala> method(Params(1,2,3))
13. (1,2,3)
14. }

But we can do better remember that we can import methods and properties from an object:

1. scala> object Obj {
2.      |  val prop = 10
3.      | }
4. defined module Obj
6. scala> import Obj._
7. import Obj._
9. scala> println(prop)
10. 10

Since all instance are objects it is possible to import fields and methods from instances as well:

1. scala>  case class Params(p1:Int, p2:Int, p3:Int)
2. defined class Params
4. scala> 
6. scala>  def method(params:Params) = {
7.      |   import params._
8.      |   println(p1, p2, p3)
9.      | }
10. method: (Params)Unit
11. }

The same technique is extremely useful when a method needs to return multiple values:

1. scala>  def method() = {
2.      |   (1,2,3)
3.      | }
4. method: ()(Int, Int, Int)
6. scala> val retVal = method()
7. retVal: (Int, Int, Int) = (1,2,3)
8. /*
9.  retVal is a tuple so we can import the tuple
10.  properties.  Becareful to not do this multiple times in
11.  the same scope
12. */
13. scala> import retVal._
14. import retVal._
16. scala> println(_1,_2,_3)
17. (1,2,3)
19. scala> def method2={
20.        // Notice case class declaration can be contained in method
21.      | case class Return(v1:Int,v2:Int)
22.      | Return(6,7)
23.      | }
24. method2: java.lang.Object with ScalaObject with Product{def v1: Int; def v2: Int}
26. scala> val r = method2
27. r: java.lang.Object with ScalaObject with Product{def v1: Int; def v2: Int} = Return(6,7)
29. scala> import r._
30. import r._
32. scala> println(v1,v2)
33. (6,7)
34. }

Assignments

Assignment in Scala follows more or less the same rules as Java and other related rules. There are some differences.

Increment operators do not work (i++). As I understand it the rational is that it is too specific an idiom. There is not an easy way to generalize it. Instead you must use i += 1.

Assignments do not return a value. For example you cannot do val i = j = 2 or while( (i = read(buffer)) > 0 ){...}.

One feature that is fairly unique in Scala is the ability to expand a case-class or other class that has an associated extractor. For details look at the previous topic Assignment and Parameter Objects.

Examples:

1. scala> val i,j=2
2. i: Int = 2
3. j: Int = 2
5. scala> val (i,j) = (1,2)
6. i: Int = 1
7. j: Int = 2
9. scala> val (i,j,k) = (1,"two",3.0)
10. i: Int = 1
11. j: java.lang.String = two
12. k: Double = 3.0
14. scala> case class Data( name:String, age:Int, weight:Float)
15. defined class Data
17. scala> val Data(name, age, weight) = Data("Jesse", 133, 100f)
18. name: String = Jesse
19. age: Int = 133
20. weight: Float = 100.0
22. scala> val value = 1
23. value: Int = 1
25. scala> i += 1
26. :10: error: reassignment to val
27.        i += 1
28.          ^
30. scala> var variable = 1
31. variable: Int = 1
33. scala> variable += 1
35. scala> println(variable)
36. 2

Assignment and Parameter Objects

One of the principle design goals of Scala is to be "deep" not wide, which means the language attempts to have a small set of rules that can be applied in many different ways in different situations. Pattern matching is one of my favourite examples of this. Pattern matching is commonly seen in match { case... } statements but you will also see it frequently in exception handling, function declaration and, most important for this post, assignment.

Scala does not have multiple assignment like some languages. Instead it has tuples and matching. Tuples are a light-weight way of grouping data in a simple data object. (1,2.0,'c',"string", true). A simple example of a 5 element tuple. Tuples can be up to 22 elements long and can be homogenous or heterogenous. Using this for multiple assignement works something like:

1. val (firstname, lastname) = ("Jesse","Eichar")

This is pattern matching.

1. scala> ("Jesse","Eichar") match {
2.      | case (firstname,lastname) => println(firstname,lastname)
3.      | }
4. (Jesse,Eichar)

Notice that in both cases you need the brackets around firstname, lastname. This instructs the compiler that you are matching against a Tuple.

Now the interesting use is with parameter objects. Tuples are a poor substitute for parameter objects because they do not have context. Changing:

1. def myMethod( firstname:String, middlename:String, lastname:String) = {...}

to

1. def myMethod( name:(String,String,String)) = {...}

Is not a good change because you loose context. What are the 3 strings? The information must go in the Javadocs. A better option:

1. case class Name(first:String, middle:String, last:String)
3. def myMethod( name:Name ) = {
4.   val Name(first, middle, last) = name
6.   // do something with first middle last
7. }

The beauty is that you have an object that you can pass around easily. It is a case class therefore extracting the information is incredibly easy and unlike a tuple it has context and can have methods added easily.

Yes it is longer to write but if you need to reuse the data in several locations the trade off is well worth it in clarity.

Examples:

1. // define name data object.
2. // Notice toString is a lazy val.  This means value is calculated only once.
3. scala> case class Name(first:String, middle:String, last:String) {
4.      | override lazy val toString="%s, %s %s" format (last, first,middle)
5.      | }
6. defined class Name
8. // toString formats name nicely.
9. scala> Name("Jesse","Dale","Eichar")
10. res1: Name = Eichar, Jesse Dale
12. scala> def readName() = {
13.      | //maybe load from a file or database
14.      | Name("Jesse","Dale","Eichar") :: Name("Jody","","Garnett") :: Name("Andrea","","Antonello"):: Nil
15.      | }
16. readName: ()List[Name]
18. scala> def firstLastName(name:Name) = {
19.      |  // we are putting _ because we don't care about middle name
20.      | val Name( first, _, last ) = name
21.      | (first, last)
22.      | }
23. firstLastName: (Name)(String, String)
25. // convert the list of Names to a list of tuples of first and last name
26. scala> readName().map( firstLastName _ )
27. res2: List[(String, String)] = List((Jesse,Eichar), (Jody,Garnett), (Andrea,Antonello))
29. // print all first names starting with J
30. scala> for( Name(first,_,_) <- readName; if (first.startsWith("J"))) println(first)
31. Jesse
32. Jody
34. // print the first and middle parts of the first name in the list
35. scala> readName() match {
36.      | // the :: _ indicates that we are matching against a list but we don't care about the rest of the list
37.      | case Name(f,m,_) ::  _ => println( f, m)
38.      | case _ => println("Not a list of names")
39.      | }
40. (Jesse,Dale)

Simple classes

Scala classes are similar to java classes but are designed to work around some of the boiler plate code. We will address multiple constructors another day. But one thing to note is that normally the code that is in a Java constructor goes directly in the body of a Scala class or in a companion object (also covered later).

1. scala> class NewClass( aPrivateInt:Int, val iAmPublic:Int, var iAmAlsoPublic:Int)
2. defined class NewClass
4. scala> val c = new NewClass(1,2,3)
5. c: NewClass = NewClass@da99836
7. scala> c.aPrivateInt
8. :7: error: value aPrivateInt is not a member of NewClass
9.        c.aPrivateInt
10.          ^
12. scala> c.iAmPublic
13. res2: Int = 2
15. scala> c.iAmAlsoPublic
16. res3: Int = 3
18. scala> c.iAmPublic = 10 // not allowed because iAmPublic is a val
19. :6: error: reassignment to val
20.        c.iAmPublic = 10
21.                    ^
23. scala> c.iAmAlsoPublic = 10 // iAmAlsoPublic is a var
25. scala> c.iAmAlsoPublic
26. res4: Int = 10
28. scala> class c2( aPrivate:Int ) {
29.      | val aPublic = aPrivate + 10
30.      | }
31. defined class c2
33. scala> class c3(tmp:Int) extends c2(tmp){
34.      | override val aPublic = tmp * 10 // can't access super.aPrivate because it
35.  is class private so use tmp
36.      | }
37. defined class c3
39. scala> new c2(10).aPublic
40. res5: Int = 20
42. scala> new c3(10).aPublic
43. res6: Int = 100
45. scala> class c4( aPrivate:Int ) {
46.      | println(aPrivate)
47.      | private val private2 = aPrivate % 10
48.      | println(private2)
49.      | }
50. defined class c4
52. scala> new c4(22)
53. 22
54. 2
55. res7: c4 = c4@64d90254