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. }

Return values

As with most functional languages, most control structures ( if, for, try ) return values. The common java idiom:

1. String name=null;
2. if( xxx ) name="yyy";
3. else name="zzz";

can be replaced by

1. val name = if( xxx ) "yyy"; else "zzz";

The benefit (other than less boiler plate code) is that name can now be a val instead of a var.

Another other point about returns: The return keyword is not required when returning a value from methods or control structures. The last value is always the return value. This is why you will get an error if the last line in a method or control structure is an assignment.

Examples:

1. scala> val name = if( 1==2 ) "Jesse" else "Mauricio"
2. name: java.lang.String = Mauricio
4. scala> println(name)
5. Mauricio
7. scala> val collection = for( i <- 1 to 100; if(i%20 == 3) ) yield i
8. collection: Seq.Projection[Int] = RangeFM(3, 23, 43, 63, 83)
10. scala> collection.foreach( i => print( i +" ") )
11. 3 23 43 63 83
13. scala> val someObj:AnyRef = "Hello"
14. someObj: AnyRef = Hello
16. scala> val choice = someObj match {
17.      | case _:java.io.File => "File"
18.      | case _:String => "String"
19.      | case _ => "Dunno"
20.      | }
21. choice: java.lang.String = String
23. scala> val result = try {
24.      | "two".toInt
25.      | }catch{
26.      | case e:NumberFormatException => -1
27.      | case _ => 0
28.      | }
29. result: Int = -1
30. scala> var i=0
31. i: Int = 0
33. // while and do-while do not have return values
34. scala> while( i<4 ){
35.      | "22"
36.      | i += 2
37.      | }
39. scala> println( if(i>0) "great" else "less" )
40. great
42. // code blocks return the last statement
43. scala> val m = {
44.      | val x = 1
45.      | x + 2
46.      | }
47. m: Int = 3