Using Scala Functions to Simplify Code

I’ve recently been diving into Scala to create Scarab, a simulation framework I’m developing.  Coming from a Java / Groovy background, I was still in the habit of using classes and inheritance to create functionality.  However, as I was documenting code, I decided it would be cleaner to use functions and pass them as parameters.

One of the things I find useful is to have the ability to write output to different output streams in different formats.  I separated the code to do the formatting from the code to do the writing so that I could easily mix and match writers and formatters.  Originally both the writers and the formatters inherited from a base class.  Writers would then add additional functionality to write and formatters would add additional formatting capabilities.

The base writer contained the following methods (plus more that aren’t relevant to this post):

abstract class AbstractWriter {

  private var formatter : TraceFormatter = SimpleFormat

  // formats, then writes the message
  def trace (trace: String, message: String) = { write (formatter.format(trace, message))  }

  // sets the formatter to use.
  def withFormat (format : TraceFormatter) = {
    formatter = format
    this // for method chaining
  }

  // abstract method writers should implement.
  protected def write (message: String)

}

The base formatting class was defined as such:

abstract class AbstractFormatter {
  // method to be overridden by the formatter to do the formatting.
  def format(trace : String, message: String) : String
}

// Class to format with trace type and date for searching.
class LogFormatter extends AbstractFormat {
  def format(trace: String, message: String) = { "[" + trace + "] [" + new Date() + "] " + message }
}

So, I happily began creating classes to do formatting, but realized that my users might want to create their own formats as well.  Initially I simply said to extend the base formatter and use that with the writer.  However, this has the potential to clutter up the class space and each formatter is at least three lines.  While users could use anonymous classes, it just didn’t feel right.  All I wanted was a function to format a string.

So, after reviewing my Programming In Scala book, I figured out how to make the changes.  First, I changed the AbstractWriter to the following:

abstract class AbstractWriter {

  // Assigns an initial function for the formatter.  The type is implicitly determined.
  private var formatter = TraceFormatters.SimpleFormat

  // formats, then writes the message
  def trace (trace: String, message: String) = {    write (formatter(trace, message))  }

  // sets the formatter to use.  The parameter is now a function.
  def withFormat (format : (String, String) => String) = {
    formatter = format
    this
  }

  // abstract method writers should implement.
  protected def write (message: String)

}

Now, the defined formatters are just functions I placed inside an Object:

object TraceFormatters {

  val SimpleFormat = (trace: String, message: String) => message
  val LogFormat = (trace: String, message: String) => "[" + trace + "] [" + new java.util.Date() + "] " + message

}

I can easily add additional formats as needed with a single line of code.

The major benefit, however, is that now users can create formats on the fly.  Lets say that a user wants to create a formatter that formats messages as comma separated values, then all that is needed is the following:

// ignoring the case of messages or trace names with commas.
val writer = new FileWriter("log.csv") withFormat { _ + ", " + _}

Switching from classes to functions makes the code more readable, reduces the number of classes that need to be created, and provides increased flexibility for users of my class.