Pollak D. Beginning Scala

Подождите немного. Документ загружается.

CHAPTER 3 ■ COLLECTIONS AND THE JOY OF IMMUTABILITY

and call it with an XML literal:

scala> len(Hello)

res1: Int = 1

Or we can call it with the XML variable x we defined previously:

scala> len(x)

res2: Int = 1

Or we can call it with a List[Int]:

scala> len(List(1,2,3))

res11: Int = 3

The ability to dynamically create XML in Scala is far more powerful than the ability to

dynamically create

Strings. Scala code can be embedded in any attribute or element body

to dynamically render XML. For example, let’s define a method that returns the current

milliseconds as a

String:

scala> def now = System.currentTimeMillis.toString

now: java.lang.String

We can call the now method from the attribute definition to add a time attribute:

scala> Hello World

res3: scala.xml.Elem = Hello World

19897ch03.fm Page 77 Thursday, April 16, 2009 4:54 PM

CHAPTER 3

■ COLLECTIONS AND THE JOY OF IMMUTABILITY

Attributes can be defined with Scala expressions of type String, NodeSeq, and Option[NodeSeq].

We did an example of

String previously. Option[NodeSeq] in an attribute definition is very

powerful. If the

Option is None, the attribute will not be included in the resulting XML, but

if the

Option is Some, then the attribute will be included.

An example will help illustrate. Let’s define a method that tests

Long for being odd:

scala> def isOdd(in: Long) = in % 2L == 1L

isOdd: (Long)Boolean

Next we import Scala’s XML package. XML literals are language-level, but the library

that allows you to manipulate the literals must be imported.

scala> import scala.xml._

import scala.xml._

We define the oddTime method, which will return Some[NodeSeq] if the time is odd and

return

None if it’s even:

scala> def oddTime: Option[NodeSeq] = System.currentTimeMillis match {

case t if isOdd(t) => Some(Text(t.toString))

case _ => None

}

oddTime: Option[scala.xml.NodeSeq]

And we can see that the time attribute is only included when the time is odd:

scala> Sometimes

res6: scala.xml.Elem = Sometimes

scala> Sometimes

3. The Class class in Java is language-level, but we must explicitly import java.lang.reflect.* because

Method is in that package rather than in java.lang.*.

19897ch03.fm Page 78 Thursday, April 16, 2009 4:54 PM

CHAPTER 3 ■ COLLECTIONS AND THE JOY OF IMMUTABILITY

res7: scala.xml.Elem = Sometimes

scala> Sometimes

res8: scala.xml.Elem = Sometimes

You can also generate tags, text, cdata, and so on from Scala code:

scala> The time is {new java.util.Date}

res4: scala.xml.Elem = The time is Tue Dec 30 15:09:09 PST 2008

If your embedded Scala code returns a NodeSeq, the NodeSeq will be embedded directly. If

your Scala expression returns anything else, that thing will be converted to a

scala.xml.Text

node by calling

toString on the thing.

Using

map, we can convert from a given type to XML that’s embedded:

scala> <stuff>

{(1 to 3).map(i => <v id={i.toString}>#{i}</v>)}

</stuff>

res0: scala.xml.Elem =

<stuff>

</stuff>

One thing to be careful about is making sure your if expressions have an else. The type

of an

if expression without an else is Unit, which converts to an empty String:

scala> {if (true) "dogs"}

res14: scala.xml.Elem =

That’s not what we expected, but this is:

scala> {if (true) "dogs" else ""}

19897ch03.fm Page 79 Thursday, April 16, 2009 4:54 PM

CHAPTER 3

■ COLLECTIONS AND THE JOY OF IMMUTABILITY

res15: scala.xml.Elem = dogs

scala> {if (false) "dogs" else ""}

res16: scala.xml.Elem =

Scala correctly escapes characters from your Scala expressions:

scala> {"Hello & Goodbye"}

res3: scala.xml.Elem = Hello & Goodbye

scala>

res6: scala.xml.Elem =

So you don’t have to worry about escaping XML characters. This is generally the right

thing, but if you’re trying to embed a script in your XML, it might not be the right thing:

scala> val info = """

var x = "";

if (true && false) alert('Woof');

"""

scala> <script>{info}</script>

res4: scala.xml.Elem =

var x = "";

if (true && false) alert('Woof');

</script>

19897ch03.fm Page 80 Thursday, April 16, 2009 4:54 PM

CHAPTER 3 ■ COLLECTIONS AND THE JOY OF IMMUTABILITY

You can use PCData to embed unescaped characters in your XML:

scala> <script>{PCData(info)}</script>

res5: scala.xml.Elem =

<script><![CDATA[

var x = "";

if (true && false) alert('Woof');

]]></script>

Scala’s built-in XML support makes creating XML a breeze. Because the XML data

structures are immutable, they can be shared and cached without concern that another

thread or method may change the XML. As a side note, when I do browser-side HTML

manipulation, I always have to be concerned about inserting some nodes into other

nodes because the insertion causes parent node references to be changed. This means

that if I had inserted the nodes elsewhere, they’ll be unceremoniously removed from the

old place to be inserted into the new place. This means I have to copy the entire node

structure each time I do an insert, which is an O(n) operation. With Scala’s immutable

XML data structures, I only have to change from the insertion point to the root node, an

O(log n) operation.

Now that we’ve seen how to create XML in Scala, let’s see how to parse and manipulate

XML.

Parsing XML

Creating XML in Scala is done at the language level. The compiler needed to be changed

to support XML literals. Parsing XML in Scala is all done at the library level. Let’s explore

XML parsing in combination with Scala’s collection support. First, let’s make sure the

scala.xml package is imported:

scala> import scala.xml._

import scala.xml._

Next, let’s grab some well-formed XML from the Web:

scala> val xml = XML.load("http://demo.liftweb.net/")

19897ch03.fm Page 81 Thursday, April 16, 2009 4:54 PM

CHAPTER 3

■ COLLECTIONS AND THE JOY OF IMMUTABILITY

xml: scala.xml.Elem =

<html xmlns="http://www.w3.org/1999/xhtml"...

Next, let’s find all the <a> tags in the document:

scala> xml \\ "a"

res6: scala.xml.NodeSeq = <a shape="rect" ...

The \\ (double backslash) operator finds all the tags with the given label in the document.

The

\ (single backslash) operator finds all the tags with the given label that are direct chil-

dren of the current tag.

How many

<a> tags on the page?

scala> (xml \\ "a").length

res7: Int = 25

OK, that’s pretty cool. And note that the results of the using \ and \\ are Seq, so all the

standard collection operations apply, including the

for comprehension. Also, if the first

character of the query

String is an @, the query is performed against the attributes in the

tag. Let’s find all the

<a> tags that refer to external resources:

scala> (xml \\ "a").map(_ \ "@href").map(_.text).filter(_ startsWith "http:")

res11: Seq[String] = ArrayBuffer(http://liftweb.net, http://scala-lang.org, ...

How many is that?

scala> (xml \\ "a").filter(n => (n \ "@href").text.startsWith("http:")).length

res9: Int = 8

19897ch03.fm Page 82 Thursday, April 16, 2009 4:54 PM

CHAPTER 3 ■ COLLECTIONS AND THE JOY OF IMMUTABILITY

Perhaps the code is easier to read in a for comprehension:

scala> val refs = for {a <- xml \\ "a"

ext <- a \ "@href" if ext.text startsWith "http:"}

yield ext.text

refs: Seq[String] = ArrayBufferRO(http://liftweb.net, ...)

How many?

scala> refs.length

res10: Int = 8

In combination with Scala’s collection methods, we can do more fun stuff with XML.

We can traverse the XML and sum the contents of particular tags. First, let’s create some

XML:

scala> val x2 = <x>{(1 to 3).map(i => {i})}</x>

x2: scala.xml.Elem = <x>123</x>

Let’s find all the tags:

scala> x2 \ "i"

res26: scala.xml.NodeSeq = 123

Now, get the text from each tag:

scala> (x2 \ "i").map(_.text)

res27: Seq[String] = ArrayBufferRO(1, 2, 3)

19897ch03.fm Page 83 Thursday, April 16, 2009 4:54 PM

CHAPTER 3

■ COLLECTIONS AND THE JOY OF IMMUTABILITY

and convert to an Int:

scala> (x2 \ "i").map(_.text.toInt)

res28: Seq[Int] = ArrayBufferRO(1, 2, 3)

Finally, we sum up the collection:

scala> (x2 \ "i").map(_.text.toInt).foldLeft(0)(_ + _)

res29: Int = 6

Scala’s XML parsing library provides a simple yet powerful way to traverse XML. Combined

with XML’s collection methods, it’s very easy and concise to convert XML data to object

representations. Next, let’s see how to transform XML.

Modifying XML

Transforming flat data structures such as List or Map is pretty easy: you just take each

element from the collection and return a transformed value. Transforming XML is more

complex. XML contains many different types of elements. XML data is nested. A transfor-

mation may return many nodes for each transformed node.

In order to deal with these complexities, Scala provides a set of classes to help with XML

transformation. These helpers can be found in the

scala.xml.transform package. These

helpers provide O(log n) cost for transformations. That means only the nodes that are

changed and the direct path from the changed nodes to the root node are changed. This

is far more efficient than the O(n) cost of copying an entire XML data structure if modifying

the structure will cause unexpected results.

In order to transform XML, we need to create a rewrite rule. In this case, if the XML

element contains the attribute

instruction with the value remove, the node will be removed

from the transformed XML. First, let’s import the packages:

import scala.xml._

import scala.xml.transform._

19897ch03.fm Page 84 Thursday, April 16, 2009 4:54 PM

CHAPTER 3 ■ COLLECTIONS AND THE JOY OF IMMUTABILITY

Next, let’s define a rule that removes the elements that have the remove instruction:

val removeIt = new RewriteRule {

override def transform(n: Node): NodeSeq = n match {

case e: Elem if (e \ "@instruction").text == "remove" => NodeSeq.Empty

case n => n

}

The RewriteRule overrides the transform method and pattern matches against an element

that contains the remove instruction. If the pattern is matched, an empty node is returned.

Otherwise the method returns the unmodified node. Let’s create some test data:

val xmlBooks =

</books>

Next, let’s transform xmlBooks using a RuleTransformer:

scala> new RuleTransformer(removeIt).transform(xmlBooks)

res0: Seq[scala.xml.Node] =

</books>

The rule transformer applied our removeIt rule to the input and transformed this to the

output. Let’s create a

RewriteRule to process the add instruction:

val addIt = new RewriteRule {

override def transform(n: Node): NodeSeq = n match {

case e: Elem if (e \ "@instruction").text == "add" =>

new Elem(e.prefix, e.label,

e.attributes.remove("instruction"),

e.scope,

transform(e.child) ++ <added>I added this</added> :_*)

case n => n

}

19897ch03.fm Page 85 Thursday, April 16, 2009 4:54 PM

CHAPTER 3

■ COLLECTIONS AND THE JOY OF IMMUTABILITY

This RewriteRule matches nodes with the add instruction attribute. The method creates

a new element with the same attributes, but removes the

instruction attribute. It also

transforms the child nodes and appends a child node.

Let’s run this transformation:

scala> new RuleTransformer(addIt).transform(xmlBooks)

res2: Seq[scala.xml.Node] =

<book status="" name="book2"><added>I added this</added></book>

</books>

Note that the book2 book has child nodes. We can run the transformation with both of

the

RewriteRules:

scala> new RuleTransformer(addIt, removeIt).transform(xmlBooks)

res3: Seq[scala.xml.Node] =

<book status="" name="book2"><added>I added this</added></book>

</books>

In this section, we’ve explored creating, parsing, and rewriting XML. Scala’s awesome

XML support makes it super-simple to write complex web-based applications. You can

create Atom or RSS feeds in just a few lines that transform database records into the

appropriate XML. You can parse incoming XML using the same constructs you use for

other data sequences, which makes transformation from XML into data structures and

objects easy and fast. Finally, Scala provides simple ways to transform XML.

In this chapter, we’ve explored Scala’s immutable data types and the power and simplicity

that they afford you. Next, let’s see how we can use the immutable data structures in a

highly concurrent situation. We’re going to do concurrency without synchronization and

see how immutability helps us out, big time.

19897ch03.fm Page 86 Thursday, April 16, 2009 4:54 PM