haskell - कैसे HXT प्रोग्राम पर कमांड लाइन विकल्पों को सही तरीके से एकत्रित करें?



command-line xml-parsing (1)

मैं थीसिस के खंड 3 तक पहुंच गया हूं। एच। ऑलेंडोर्फ के आरडीएफ दस्तावेजों को प्रसंस्करण के लिए उदाहरण के साथ हास्केल एक्सएमएल उपकरण बॉक्स के लिए एक कुकबुक

यहाँ कार्यक्रम मैंने लिखा है,

import Text.XML.HXT.Core
import System.Exit
import System.Environment
import Data.Maybe

main = do
  args       <- getArgs
  (al, src)  <- cmdLineOpts args
  [rc]       <- runX (processDocument al src)
  exitWith ( if rc >= c_err
             then ExitFailure (-1)
             else ExitSuccess
           )

cmdLineOpts :: [String] -> IO (Attributes, String)
cmdLineOpts []  = return ([("","")], "")
cmdLineOpts xss = return (zip [""] xss :: Attributes, last xss)

processDocument :: Attributes -> String -> IOSArrow b Int
processDocument al src =
    readDocument al src -- lecture du document en appliquant les attributes                                                                                            
    >>>
    removeAllWhiteSpace >>> propagateNamespaces
    >>>
    writeDocument al (fromMaybe "" (lookup a_output_file al))
    >>>
    getErrStatus

लेकिन मैं अभी भी निम्नलिखित त्रुटि के माध्यम से जाना

hxtuto.hs:28:17:
    Couldn't match expected type `XIOSysState -> XIOSysState'
           against inferred type `(String, String)'
      Expected type: SysConfigList
      Inferred type: Attributes
    In the first argument of `readDocument', namely `al'
    In the first argument of `(>>>)', namely `readDocument al src'
Failed, modules loaded: none.

ऐसा लगता है कि यह मेरे cmdLineOpts कार्यान्वयन है जो अच्छी तरह से फिट नहीं है।

यहां क्या समस्या है ? और मैं इसे कैसे ठीक कर सकता हूं?

किसी भी मदद के लिए धन्यवाद !


चूंकि दोनों दस्तावेज और लिखने दस्तावेज़ के पहले पैरामीटर है [SysConfig], आप कमांड लाइन से पाठ पढ़ने के गृह व्यवस्था को संभालने के लिए GetOpt जैसे पैकेज का उपयोग करना चाहते हैं और उसे आवश्यक वस्तुओं में रूपांतरित कर सकते हैं। मैंने थीसिस के पृष्ठ 50 से "उपलब्ध विकल्पों" की सूची ली और मौजूदा, संबंधित SysConfigs (Text.XML.HXT.Arrow.XmlState.SystemConfig से) के साथ एक विकल्प प्रकार बनाया। उन हिस्सों को छोड़कर, जो विशेष अनुप्रयोग के लिए अनुकूलित किया गया है, शेष (जैसे सीएमडीलाइन आक्षेप) को गेट-ओप्ट दस्तावेज़ीकरण से सीधे लिया गया था।

import System.Console.GetOpt
import System.Environment
import System.Exit 
import Text.XML.HXT.Core

data Options = Options {
    withvalidate :: SysConfig
  , withchecknamespaces :: SysConfig
  , withcanonicalize :: SysConfig
  , withremovews :: SysConfig
  , withtrace :: SysConfig
  , output_file :: String } 

defaultOptions = Options { withvalidate = (withValidate no)
                         , withchecknamespaces = (withCheckNamespaces no)
                         , withcanonicalize = (withCanonicalize no)
                         , withremovews = (withRemoveWS no)
                         , withtrace = (withTrace 0)
                         , output_file = "" } 

options :: [OptDescr (Options -> Options)]
options =
 [ Option ['V'] ["withValidate"] 
   (ReqArg (\v opts -> opts { withvalidate = withValidate (v == "yes") } ) "") 
   "perform DTD validation"
 , Option ['n'] ["withCheckNamespaces"] 
   (ReqArg (\n opts -> opts { withchecknamespaces = withCheckNamespaces (n == "yes") } ) "")
   "check namespaces"
 , Option ['c'] ["withCanonicalize"] 
   (ReqArg (\c opts -> opts { withcanonicalize = withCanonicalize (c == "yes") } ) "")
   "canonicalize document"
 , Option ['w'] ["withRemoveWS"] 
   (ReqArg (\w opts -> opts { withremovews = withRemoveWS (w == "yes") } ) "")
   "remove whitespace used for document indentation"
 , Option ['t'] ["withTrace"] 
   (ReqArg (\t opts -> opts { withtrace = withTrace (read t) } ) "")
   "set trace level" 
 , Option ['o'] ["outputFile"] 
   (ReqArg (\o opts -> opts { output_file = o } ) "") 
   "output file" ]

cmdLineOpts :: [String] -> IO (Options, [String])
cmdLineOpts argv =
    case getOpt Permute options argv of
      (o, n, []) -> return (foldl (flip id) defaultOptions o, n)
      (_, _, errs) -> ioError (userError (concat errs ++ usageInfo header options))
    where header = "Using: [OPTION ...]"

main :: IO ()
main = do (opts, (src:_)) <- cmdLineOpts =<< getArgs 
          [rc] <- runX $ processDocument opts src
          exitWith $ if rc >= c_err then ExitFailure (-1) else ExitSuccess

processDocument :: Options -> String -> IOSArrow b Int
processDocument (Options val ns can ws tr out) src =
    readDocument [val, ns, can, ws, tr] src >>> 
    removeAllWhiteSpace >>> propagateNamespaces >>>
    writeDocument [val, ns, can, ws, tr] out >>>
    getErrStatus




hxt