Scala Buzz - Type Class pattern example

So I'm going to compromise here. The example below discuss a common task in many systems, but which I'm going to present in a very simplistic manner. Specifically, how to format stuff for output.

There is much discussion about the proper place to handle output formatting. On one hand, for instance, we have the toString method available on every Java object. It is not uncommon to have serializer, toXML, or similar stuff either. On the other hand, such approach is not scalable and mixes business rules with presentation concerns, and architectures such as Model-View-Controller try to avoid it.

So let's try to solve this problem using the type class pattern. First, let's create or type class for a formatter which produces XML output (NodeSeq class), just as described in the last article. This time, there is one method we want this type class to have, though. Here it is:

import scala.xml.NodeSeq

abstract class FormatterXML[T] {
  def format(input: T): NodeSeq
}

def output[T](what: T)(implicit formatter: FormatterXML[T]) = println(formatter.format(what))

And, to finish the initial example, we'll create a simple class, good old Person, to test it. We'll put the implicit type class object inside the companion object of Person, so that it can be found automatically. Already, the class Person has become free of concerns about formatting, though companion object might be too close for some. This, however, is not necessary, as we'll see later.

In the code below, as in other examples later on, I'm declaring the case class and the companion object in the same line, so that it can be easily pasted on REPL (which won't recognize the companion object as a companion object otherwise). I added a test line too at the end.

case class Person(name: String, age: Int); object Person {
  implicit object Formatter extends FormatterXML[Person] {
    def format(input: Person): NodeSeq = <Person><Name>{input.name}</Name><Age>{input.age}</Age></Person>
  }
}

output(Person("John", 32))

So far, this can be trivially done in other ways, so we are gaining nothing. We'll gradually increase the complexity so that benefits of this approach start to show up. First, we'll create a Song class which has a Person member, so that we show off composition of the formatter.

case class Song(title: String, author: Person); object Song {
  implicit object Formatter extends FormatterXML[Song] {
    def format(input: Song): NodeSeq = <Song>
      <Title>{input.title}</Title>
      <Author>{implicitly[FormatterXML[Person]].format(input.author)}</Author>
    </Song>
  }
}

output(Song("War Pigs", Person("Ozzy Osbourne", 61)))

Now, I'm sure all of you must be up in arms right now, because, as everyone knows, Ozzy Osbourne wasn't the sole author of War Pigs. We need to change the Song class to accomodate more authors, but that will make the formatter more complex. To help us here, let's create a formatter for generic lists, that we can use to simplify the Song formatter:

def ListFormatterXML[T](implicit formatter: FormatterXML[T]) = new FormatterXML[Traversable[T]] {
  def format(input: Traversable[T]): NodeSeq = <List>{input map formatter.format}</List>
}

Here we start to see an advantage to this approach. This method will work for any list (any traversable, in fact!), as long as there is a formatter for its members. Anyway, let's see the Song again:

case class Song(title: String, authors: Person*); object Song {
  implicit object Formatter extends FormatterXML[Song] {
    def format(input: Song): NodeSeq = <Song>
      <Title>{input.title}</Title>
      <Authors>{ListFormatterXML[Person].format(input.authors)}</Authors>
    </Song>
  }
}

output(Song("War Pigs", 
            Person("Tony Iommi", 62), 
            Person("Ozzy Osbourne", 61), 
            Person("Geezer Butler", 60),
            Person("Bill Ward", 62)))

def ListFormatterXML[T](kind: String)(implicit formatter: FormatterXML[T]) = new FormatterXML[Traversable[T]] {
  def format(input: Traversable[T]): NodeSeq = <List>{input map formatter.format}</List>.copy(label = kind)
}

case class Song(title: String, authors: Person*); object Song {
  implicit object Formatter extends FormatterXML[Song] {
    def format(input: Song): NodeSeq = <Song>
      <Title>{input.title}</Title>
      {ListFormatterXML[Person]("Authors").format(input.authors)}
    </Song>
  }
}

output(Song("War Pigs", 
            Person("Tony Iommi", 62), 
            Person("Ozzy Osbourne", 61), 
            Person("Geezer Butler", 60),
            Person("Bill Ward", 62)))

Personally, I like this better, but your milleage may vary. Anyway, let's increase complexity a bit. If we want scalability, we'd better make the formatter more flexible, able to handle many different formats. Let's redefine our type class, in a way that avoids changes to the code we have written so far:

abstract class Formatter[T, Format] {
  def format(input: T): Format
} 

abstract class FormatterXML[T] extends Formatter[T, NodeSeq] {
  def format(input: T): NodeSeq
}

We also need a new output, but here we have a problem. How do we specify the format type explicitly while, at the same time, inferring the input type? I'll confess not having given much thought to this problem, but the following code will work:

def as[F] = new {
  def output[T](what: T)(implicit formatter: Formatter[T, F]) = println(formatter.format(what))
}

as[NodeSeq].output(Song("War Pigs", 
            Person("Tony Iommi", 62), 
            Person("Ozzy Osbourne", 61), 
            Person("Geezer Butler", 60),
            Person("Bill Ward", 62)))

implicit object PersonFormatterString extends Formatter[Person, String] {
  def format(input: Person): String = "%s, age %d" format (input.name, input.age)
}

def ListFormatterString[T](kind: String)(implicit formatter: Formatter[T, String]) = new Formatter[Traversable[T], String] {
  def format(input: Traversable[T]): String = input map formatter.format mkString (kind+" ", ", ", "; ")
}

implicit object SongFormatterString extends Formatter[Song, String] {
  def format(input: Song): String = input.title+" "+ListFormatterString[Person]("by").format(input.authors)
}

as[String].output(Song("War Pigs", 
            Person("Tony Iommi", 62), 
            Person("Ozzy Osbourne", 61), 
            Person("Geezer Butler", 60),
            Person("Bill Ward", 62)))


	Web Artima.com