HXT/Practical/Simple1
The Data
Save this data to "simple1.xml"
<guestbook> <guest> <fname>John</fname> <lname>Steinbeck</lname> </guest> <guest> <fname>Henry</fname> <lname>Ford</lname> </guest> <guest> <fname>Andrew</fname> <lname>Carnegie</lname> </guest> <guest> <fname>Anton</fname> <lname>Chekhov</lname> </guest> <guest> <fname>George</fname> <lname>Washington</lname> </guest> <guest> <fname>William</fname> <lname>Shakespeare</lname> </guest> <guest> <fname>Nathaniel</fname> <lname>Hawthorne</lname> </guest> </guestbook>
An unlikely list, but it will suffice for our purposes.
The Code
First, a quick overview of the necessary imports and compiler declarations:
The LANGUAGE
pragma allows us to specifically enable
certain language extensions. The Arrows
option provides the special Arrow syntax, and the NoMonomorphismRestriction
option eliminates the need for explicit type signatures on our filters.
{-# LANGUAGE Arrows, NoMonomorphismRestriction #-}
import Text.XML.HXT.Core
The XML will be parsed directly into this data-structure:
data Guest = Guest { firstName, lastName :: String }
deriving (Show, Eq)
I find it helpful to get a feel for the combinators at the GHCi prompt. At this point, you may want to start GHCi and load the code so far. Then you can use commands like:
Main> runX (readDocument [ withValidate no] "simple1.xml"
>>> deep (isElem >>> hasName "guest"))
to see the XML structures inside the guest tags. The deep
filter traverses the XML structures recursively and applies the filter
in its parameter to all the underlying structures. withValidate no
turns off validation -- since the XML technically isn't well formed.
With the "guest" structures in hand, the filter can be refined to
pick out the first and last name text and construct a Guest value.
The proc
syntax is introduced here to show how it can
be done conveniently.
getGuest = deep (isElem >>> hasName "guest") >>>
proc x -> do
fname <- getText <<< getChildren <<< deep (hasName "fname") -< x
lname <- getText <<< getChildren <<< deep (hasName "lname") -< x
returnA -< Guest { firstName = fname, lastName = lname }
If you are familiar with monadic do-syntax, you've probably noticed some similarities already.
There is a do
, and there is a <-
. But there are some new operators
too: -<
, returnA
, and this introduced variable x
.
If you squint a bit you'll notice that there seems to be a bit of an "arrow" feel to the syntax:
... <- ... <<< ... <<< ... -< ...
That's done purposefully, you can think of the XML structures flowing through the combinators
in the direction the arrow is pointing. Binding is still done with <-
. returnA
returns the value to the Arrow much like return
does to a monad.
Test it out in GHCi:
Main> runX (readDocument [withValidate no] "simple1.xml" >>> getGuest)
There is some repetition in the above code. Let's factor it out into useful combinators.
atTag tag = deep (isElem >>> hasName tag)
text = getChildren >>> getText
And rewrite the example, much cleaner.
getGuest2 = atTag "guest" >>>
proc x -> do
fname <- text <<< atTag "fname" -< x
lname <- text <<< atTag "lname" -< x
returnA -< Guest { firstName = fname, lastName = lname }
Hopefully, at this point it should be easy to follow the code, with the more appropriately named functions.
main = do
guests <- runX (readDocument [withValidate no] "simple1.xml"
>>> getGuest2)
print guests