¿Cómo acceder a algunos datos XML con Haskell (usando HaXml)?

Question

quiero obtener acceso a los datos de un archivo XML como

<?xml version="1.0"?> 
<MY> 
    <Foo id="1" name="test"> 
    <Argument name="a" /> 
    </Foo> 
    <Foo id="2" name="test2"> 
    <Argument name="a" /> 
    <Argument name="b" /> 
    </Foo> 
    <Other id="2" name="someOther"/> 
</MY> 

quiero por ejemplo, para leer cada Foo con sus argumentos, ¿cómo puedo hacer esto con Haskell? (Me gustaría utilizar el módulo HaXml)

No sé por dónde empezar.

Answer 1

No puedo encontrar documentación actualizada y ejemplos para haXml.

Sin embargo, hay documentación disponible para HXT. Sé que es probablemente una exageración para su ejemplo, pero de todos modos.

Si desea utilizar tagsoup, tal vez las siguientes respuestas podrían ayudar:
xml-tree parser (Haskell) for graph-library
In Haskell how do you extract strings from an XML document?

Aquí está la documentación un ejemplo para HXT:
http://www.haskell.org/haskellwiki/HXT/Conversion_of_Haskell_data_from/to_XML
http://www.haskell.org/haskellwiki/HXT
http://www.haskell.org/haskellwiki/HXT/Practical
http://en.wikibooks.org/wiki/Haskell/XML

Ahora el código usando HXT. (advirtiendo que no estoy seguro de si este es el camino correcto)

he seguido el tutorial: http://www.haskell.org/haskellwiki/HXT/Conversion_of_Haskell_data_from/to_XML

necesita que su fichero XML como "data.xml"

import Data.Map (Map, fromList, toList) 
import Text.XML.HXT.Core 


type Foos = Map String [Foo] 

data Foo = Foo 
    { 
     fooId :: String 
    , fooName :: String 
    , arguments :: [Argument] 
    } 
      deriving (Show, Eq) 



data Argument = Argument 
     { argName :: String 
     } 
      deriving (Show, Eq) 

instance XmlPickler Foo where 
    xpickle = xpFoo 


instance XmlPickler Argument where 
    xpickle = xpArgument 

-- WHY do we need this?? no clue    
instance XmlPickler Char where 
    xpickle = xpPrim 

-- this could be wrong 
xpFoos :: PU Foos 
xpFoos 
    = xpWrap (fromList 
      , toList 
     ) $ 
    xpList $ 
     xpElem "MY" $ 
     xpickle 

xpFoo :: PU Foo 
xpFoo 
    = xpElem "Foo" $ 
    xpWrap (uncurry3 Foo 
      , \ f -> (fooId f 
         , fooName f 
         , arguments f 
        ) 
      ) $   
    xpTriple (xpAttr "id" xpText) 
       (xpAttr "name" xpText) 
       (xpList xpickle) 


xpArgument :: PU Argument 
xpArgument 
    = xpElem "Argument" $ 
     xpWrap (\ ((a)) -> Argument a 
       , \ t -> (argName t) 
      ) $ 
     (xpAttr "name" xpText) 


main :: IO() 
main 
    = do 
     runX (xunpickleDocument xpFoos 
           [ withValidate no 
           , withTrace 1 
           , withRemoveWS yes 
           , withPreserveComment no 
           ] "data.xml" 
     >>> 
      arrIO (\ x -> do {print x ; return x}) 
      ) 
     return() 

resultado (que necesita ejemplo xml como "data.xml"):

-- (1) getXmlContents 
-- (1) readDocument: "data.xml" (mime type: "text/xml") will be processed 
-- (1) readDocument: "data.xml" processed 
fromList [("",[Foo {fooId = "1", fooName = "test", arguments = [Argument {argName = "a"}]}, 
Foo {fooId = "2", fooName = "test2", arguments = [Argument {argName = "a"}, 
Argument  {argName = "b"}]}])] 

Answer 2

Para tareas simples, es posible que desee considerar el paquete de etiquetas.

Answer 3

Sí, la documentación es una gran desventaja sobre haskell. Me pregunto por qué la gente de Haskell odia documentar tanto su código. No hay necesidad de papeles gordos, pocos ejemplos de uso suelen ser más que suficientes.

también pequeño ejemplo de uso HaXML disponible aquí: http://book.realworldhaskell.org/read/extended-example-web-client-programming.html

Answer 4

con XML-conducto que puede hacer que sea muy simple y directo:

{-# LANGUAGE OverloadedStrings #-} 

import Data.Conduit 
import qualified Text.XML.Stream.Parse as XP 
import Data.String(fromString) 

parseFile fileName = runResourceT $ XP.parseFile XP.def (fromString fn) 
            $$ parseXML 

parseXML = XP.force $ XP.tagNoAttr "MY" 
     $ XP.many 
     $ XP.tagName "foo" (mapM XP.requiredAttr ["id", "name"]) 
          $ \(~[i,n]) -> return (i,n) 

Answer 5

Hay un tutorial introduction to haxml, mi respuesta llega un poco tarde , pero creo que el tutorial describe cómo analizar un XML muy similar al que proporcionó en su pregunta.

Una aplicación muy simplista de cómo leer el código XML sería:

c <- fReadXml "your.xml" :: IO ANYContent 
print c