Effective Programming In Scala - Part 1 : Standardizing code in better way

Reading Time: 4 minutes

A language is a set of standards. One has to follow them in order to avail benefits from the language. In order to maintain these standards, code in Scala has to be written in order to minimize the errors whether they are related with the concepts like redundancy of operations, use of properties of language those not supported by ScalaStyle or ScapeGoat or other checkers.

The standard of code is maintained in order to write a block of code having few lines and perform large operations effectively. In order to follow the effective standard of Scala, we can go through the following conditions and what should be their standard representations,

Matching without null

Sometimes we want to match a value whether it is a string or something that returns a null in case of default case, the code to simply match it is written as,

scala> val name = null
name: Null = null

scala> name == null
res0: Boolean = true

But in a better way it can be defined as,

scala> val name = null
name: Null = null

scala> Option(name).isDefined
res3: Boolean = false

scala> val name = "John"
name: String = John

scala> Option(name).isDefined
res4: Boolean = true

Indices of List

In few cases when we want to read the content of many collections at the same time or we say, we want to iterate more than one list at a time and get the element of another list at the same time, we prefer the following code for simplicity,

scala> val names = List("John", "Doc", "Stephen", "Doe")
names: List[String] = List(John, Doc, Stephen, Doe)

scala> val age = List(20, 30, 40, 50)
age: List[Int] = List(20, 30, 40, 50)

scala> 0 until names.length map (nameIndex => age(nameIndex))
res8: scala.collection.immutable.IndexedSeq[Int] = Vector(20, 30, 40, 50)

In a better way to iterate the indices of a list, we can rewrite the above code as,

scala> val names = List("John", "Doc", "Stephen", "Doe")
names: List[String] = List(John, Doc, Stephen, Doe)

scala> val age = List(20, 30, 40, 50)
age: List[Int] = List(20, 30, 40, 50)

scala> names.indices map (nameIndex => age(nameIndex))
res9: scala.collection.immutable.IndexedSeq[Int] = Vector(20, 30, 40, 50)

Avoid map

In Scala, the map is commonly and most frequently used to iterate a collection. But sometimes there can be the following two conditions possible,

We return some value,
We return a unit, in case of performing any file content writing operations

scala> val names = List("John", "Doc", "Stephen", "Doe")
names: List[String] = List(John, Doc, Stephen, Doe)

scala> names map (name => name.toUpperCase)
res11: List[String] = List(JOHN, DOC, STEPHEN, DOE)

In above case map returns a list of string, so it is good to use the it here.

scala> val writer = new java.io.PrintWriter("/tmp/AnyFile.txt")
writer: java.io.PrintWriter = java.io.PrintWriter@35ef439e

scala> val names = List("John", "Doc", "Stephen", "Doe")
names: List[String] = List(JOHN, Doc, Stephen, Doe)

scala> names map (name => writer.print(name))
res12: List[Unit] = List((), (), (), ())

In above case we are not returning any value, so here we should replace map with foreach as below,

scala> val writer = new java.io.PrintWriter("/tmp/AnyFile.txt")
writer: java.io.PrintWriter = java.io.PrintWriter@35ef439e

scala> val names = List("John", "Doc", "Stephen", "Doe")
names: List[String] = List(John, Doc, Stephen, Doe)

scala> names foreach (name => writer.print(name))

Avoid map over match

Sometimes if we are in situation where we have a list defining some values may be defined or undefined (Options). Now to iterate the code is written as below,

scala> val names = List(Some("John"), Some("Sam"), None, None)
names: List[Option[String]] = List(Some(John), Some(Sam), None, None)

scala> val DEFAULT = "NOT_FOUND"
DEFAULT: String = NOT_FOUND

scala> names.map { currentName =>
| currentName match {
| case Some(name) => name
| case None => DEFAULT
| }
| }
res17: List[String] = List(John, Sam, NOT_FOUND, NOT_FOUND)

Above the names are already being mapped, so we can remove the match there,

scala> val names = List(Some("John"), Some("Sam"), None, None)
names: List[Option[String]] = List(Some(John), Some(Sam), None, None)

scala> val DEFAULT = "NOT_FOUND"
DEFAULT: String = NOT_FOUND

scala> names.map {
| case Some(name) => name
| case None => DEFAULT
| }
res18: List[String] = List(John, Sam, NOT_FOUND, NOT_FOUND)

Java Converters

While programming in Scala, there are certain conditions where we face the code written in java specially while using any external api’s, whose documentation is written in java. So, java converters provide a better way of transforming these java properties into Scala.

Suppose we have an ArrayList of java utility package as below,

scala> import java.util._
import java.util._

scala> val arrayList = new ArrayList[Int]()
arrayList: java.util.ArrayList[Int] = []

scala> arrayList.add(100)
res6: Boolean = true

scala> print(arrayList)
[100]

Now to transform we use the java converter as below,

scala> import scala.collection.JavaConverters._
import scala.collection.JavaConverters._

scala> val scalaBuffer = arrayList.asScala
scalaBuffer: scala.collection.mutable.Buffer[Int] = Buffer(100)

Now in the above code, we transformed the java ArrayList into mutable buffer of scala, Now we can easily change it to a list of scala,

scala> scalaBuffer.toList
res7: List[Int] = List(100)

Collections over Conditions

Sometimes we have a number of choices so that a value must match with any of them, at that time the easy approach is to match that element with those choices as below,

scala> val name = "whisky"
name: String = whisky

scala> if (((name == "vodka" || name == "teacher") || (name == "whisky")) || (name == "slice" || name == "fruity")) true else false
res0: Boolean = true

Above code wants to verify, which type of drink does the name belong to. Code is simple but not easily understandable and complex to be programmed. The code can be written as below using collection,

scala> val name = "whisky"
name: String = whisky

scala> val alchoholicDrinks = List("vodka", "teacher", "whisky")
alchoholicDrinks: List[String] = List(vodka, teacher, whisky)

scala> val softDrinks = List("slice", "fruity")
softDrinks: List[String] = List(slice, fruity)

scala> if(alchoholicDrinks.contains(name) || softDrinks.contains(name)) true else false
res1: Boolean = true

Now we defined two groups having their respective drinks. And it is easily understandable.

So there are some practices in scala, so that code can be rewritten in more effective way.

Happy Blogging !!

5 thoughts on “Effective Programming In Scala – Part 1 : Standardizing code in better way6 min read”

Marco says:

July 4, 2016 at 2:28 AM

Nice article, just a quick contribution, I think the main reason to use map vs foreach is wheter you want to explicitly have side effects, map is used to transform values of a collection while foreach just execute a piece of code that returns nothing, so probably the piece of code in the foreach function will have a side effect.
1. Harsh Sharma Khandal says:
  
  July 4, 2016 at 5:58 AM
  
  Yes, nice explanation Macro and foreach is the best whenever the requirement is to execute or perform an action without returning its result to others.
omdivo says:

July 5, 2016 at 5:36 PM

if(alchoholicDrinks.contains(name) || softDrinks.contains(name)) true else false should be replaced by simply alchoholicDrinks.contains(name) || softDrinks.contains(name)
1. Harsh Sharma Khandal says:
  
  July 5, 2016 at 8:52 PM
  
  Yeah i know, but due to above comparison as in if-else case, i used the if-else case
Shailesh says:

November 23, 2017 at 9:25 PM

map should only be used if you need another collection transformed by your function.
by the way, last rule is more a language independent.
we should be avoiding dealing with indices as much as possible, collections support zip* method for that purpose.