While many language-agnostic APIs have been developed to process XML documents, working with XML is not a chore many developers enjoy. One reason is perhaps because many XML APIs provide a relatively verbose way to read and modify XML documents.

Several newer languages provide a possibly easier way to navigate XML by supporting XML as a native language construct. EcmaScript 4, for instance, has such native XML support in its E4X extension. Adding XML support to a language, however, carries with it the danger of growing the core elements of the language, adding complexity and making the language harder to master.

Although Scala supports XML as a "built-in" data type, Scala's XML support does not come at the expense of simplicity. Instead, XML processing in Scala takes clever advantage of the language's expression syntax and functional features. A recent article by eBay architect Michael Galpin, Scala and XML, published on IBM's developerWorks Web site, provides a detailed tutorial on XML processing in Scala.

Galpin writes that,

XML has become such an important part of technology that it is only natural to use a programming language that has XML support built in to its syntax. That is exactly what you get with Scala... Like most programming languages, Scala gives you multiple options for parsing XML. These are the same basic ones: InfoSet/DOM based representations, push (SAX) or pull (StAX) events, or data-binding similar to Java Architecture for XML Binding (JAXB.).. And with Scala's native support for XML, you can use a template-style syntax to insert dynamic data into an XML structure...

The article illustrates Scala XML processing with an example that loads an XML document from the network into Scala's native XML type:

object FriendFeed {
  import java.net.{URLConnection, URL}
  import scala.xml._ 
  def friendFeed():Elem = {
    val url = new URL("http://friendfeed.com/api/feed/public?format=xml&num=100")
    val conn = url.openConnection
    XML.load(conn.getInputStream)
  }
}

This XML document can be accessed in the following manner:

val feedXml = friendFeed

Among the more interesting XML-related features of Scala is that syntax that appears to be XPath—and is, indeed, valid XPath expression—is translated into Scala function invocations. Galpin illustrates this point with an example of searching through an XML document. This example also shows how to use Scala's pattern matching in the course of searching:

def filterFeed(feed:Elem, feedId:String):Seq[Node] = {
   var results = new Queue[Node]()
   feed\"entry" foreach{(entry) =>
     if (search(entry\"service"\"id" last, feedId)){
       results += (entry\"user"\"nickname").last
     }
   }
   return results
 }
 
 def search(p:Node, Name:String):Boolean = p match {
   case {Text(Name)} => true
   case _ => false
 }

filterFeed ... takes in an XML element (feed) and an ID of a service. First create a Queue of XML Nodes called results. Queue is parameterized, like a List or Map in Java. Scala uses square brackets to denote generic type, instead of the angle brackets used in Java programming. The line feed\"entry" is an XPath-like expression.

The backslash is actually a method of the class scala.xml.Elem. It returns all of the child-nodes with the given name, that is, all of the entry elements in the feed. This is returned as an instance of the class scala.xml.NodeSeq. This class extends Seq[Node]. Because it is a Seq, it has a foreach method that takes a closure as a parameter.

Other examples in the article demonstrate how to alter an XML document using pattern matching, and also discuss the immutable objects used in the Scala XML API.

What do you think of Scala's XML support? What is you favorite language for working with XML?

node.findAll(\child -> child.Name == "MyElement" && child.Attributes["foo"] == "bar")

def search(p:Node, Name:String):Boolean = p match {
   case <id>{Text(Name)}</id> => true
   case _ => false
 }