Idiomatic way in scala to emulate/replace unary addition for repeated operations

Question

In languages with support for unary addition, and in situations where a long list of operations is performed against sequential items in an array-like structure I might create a simple counter "int counter= 0;" and do the following:

someOperation(array[counter++]);
nextOperation(array[counter++]);
subsequentOperation(array[counter++]);
..  etc

What is an idiomatic way in scala to achieve similar behavior - i.e. avoid requiring hard-coded input array indices? Here is a specific example: a simple record parser method that converts a tab-separated call detail to a Call object. Not knowing any better way I did an ugly thing of putting in an AtomicInteger. But what is an acceptable way to do this?

Note: we can not simply do a collective operation here because some of the columns require ".toInt" processing and others do not.

  def parseStringToCall(text: String) = {
    val toks = text.split('\t')
    val ix = new AtomicInteger(0)
    new CallUpdate(
      toks(ix.getAndIncrement),  // callDate
      toks(ix.getAndIncrement),  // calledNumber
      toks(ix.getAndIncrement),  // callingNumbe
      toks(ix.getAndIncrement),  // cellTowersVi
      toks(ix.getAndIncrement),  // direction
      toks(ix.getAndIncrement),  // iMSI
      toks(ix.getAndIncrement),  // manufacturer
      toks(ix.getAndIncrement),  // phoneType
      toks(ix.getAndIncrement),  // reasonforDro
      toks(ix.getAndIncrement).toInt,  // weeknum
      toks(ix.getAndIncrement),  // firstCellTow
      toks(ix.getAndIncrement),  // lastCellTowe
      toks(ix.getAndIncrement).toInt,  // calls
      toks(ix.getAndIncrement),  // distinctCell
      toks(ix.getAndIncrement),  // droppedCall
      toks(ix.getAndIncrement).toInt,  // handovers
      toks(ix.getAndIncrement).toInt,  // setupTime
      toks(ix.getAndIncrement).toInt  // talkTime
    )

Answer 1

Maybe you could not use index to access an array, but use pattern matching.

Given you have your call update defined as a case class (I've omitted some of the fields)

case class CallUpdate(
  callDate: String, 
  calledNumber: String, 
  callingNumber: String, 
  cellTowersVi: String,
  direction: String, 
  iMSI: String, 
  manufacturer: String, 
  phoneType: String,
  reasonforDro: String, 
  weekNum: Int, 
  firstCellTow: String, 
  calls: Int
)

You could write your parseStringToCall like this

def parseStringToCall(text: String) = text.split('\t') match {
  case Array (
    callDate, calledNumber, callingNumber, cellTowersVi, direction, iMSI, manufacturer, 
    phoneType, reasonforDro, weekNumString, firstCellTow, callsString
  ) => CallUpdate(callDate, calledNumber, callingNumber, cellTowersVi, direction, iMSI, manufacturer,     
                  phoneType, reasonforDro, weekNumString.toInt, firstCellTow, callsString.toInt)
}

Additionally using this approach, you could handle lines, which do not match, by adding wildcard case, and return None for example.

PS. Maybe you could think of splitting your CallUpdate into smaller, specialized objects.

Answer 2

You're approaching the problem imperatively. Idiomatic Scala is more about functional programming. You have to get used to treating functions as values and exploit that power.

Your problem can be solved functionally like this:

toks
  // Get a lazy wrapper around `toks`, so that all the subsequent
  // operations will be done in just a single traversal:
  .view 
  // Pair each item of `toks` up with an according operation:
  .zip(List(someOperation(_), nextOperation(_), subsequentOperation(_)))
  // Traverse thru those pairs, applying the operations:
  .foreach{ case (t, f) => f(t) }

It must be noted that the operations are expected to be of type String => Unit.

Answer 3

For the sake of future generations searching for the question on the title, this is a potential implementation of postIncrement in Scala:

class Counter(start:Int = 0) {
  var current = start
  def ++ : Int = {val x=current; current +=1 ; x}
}

repl> val i = new Counter
repl> i: Counter = Counter@2a01a9f2
repl> i++
repl> res26: Int = 0
repl> i++
repl> res27: Int = 1

Now, to address the specific usecase on the body of the question: i.e. iterating over an array without having to deal with the index, probably the most straightforward way to do that is using an iterator:

val args = Array("arguments","with","ints","23","46")
val iter = args.iterator
val res = CallUpdate(iter.next, iter.next, iter.next, iter.next.toInt, iter.next.toInt)

This solves the index access in a clean way.

Can we do better? Probably. We could address the type conversion in a more elegant way. For that we define a simple marker type and implicit conversions to avoid having to take care of those toInt calls. This can of course be extended to other types like Date, Long, ...

case class Param(value:String)
object Param {
    implicit def paramToString(p:Param):String = p.value
    implicit def paramToInt(p:Param):Int = p.value.toInt
}

and we can do something like:

val args = Array("arguments","with","ints","23","46")
val params = args.map(elem => Param(elem))
val iter = params.iterator
val res = CallUpdate(iter.next, iter.next, iter.next, iter.next, iter.next)

And if you want a mind-blowing solution, I recommend you this reading: applying-an-argument-list-to-curried-function