提高FParsec解析器

Question

的可讀性，我在C＃這是越來越難以管理做了手寫CSS解析器，並試圖做到這一點我FParsec使其更mantainable。下面是解析與正則表達式做了CSS選擇器元素的片段：

var tagRegex = @"(?<Tag>(?:[a-zA-Z][_\-0-9a-zA-Z]*|\*))"; 
var idRegex = @"(?:#(?<Id>[a-zA-Z][_\-0-9a-zA-Z]*))"; 
var classesRegex = @"(?<Classes>(?:\.[a-zA-Z][_\-0-9a-zA-Z]*)+)"; 
var pseudoClassRegex = @"(?::(?<PseudoClass>link|visited|hover|active|before|after|first-line|first-letter))"; 
var selectorRegex = new Regex("(?:(?:" + tagRegex + "?" + idRegex + ")|" + 
           "(?:" + tagRegex + "?" + classesRegex + ")|" + 
            tagRegex + ")" + 
           pseudoClassRegex + "?"); 

var m = selectorRegex.Match(str); 

if (m.Length != str.Length) { 
    cssParserTraceSwitch.WriteLine("Unrecognized selector: " + str); 
    return null; 
} 

string tagName = m.Groups["Tag"].Value; 

string pseudoClassString = m.Groups["PseudoClass"].Value; 
CssPseudoClass pseudoClass; 
if (pseudoClassString.IsEmpty()) { 
    pseudoClass = CssPseudoClass.None; 
} else { 
    switch (pseudoClassString.ToLower()) { 
     case "link": 
      pseudoClass = CssPseudoClass.Link; 
      break; 
     case "visited": 
      pseudoClass = CssPseudoClass.Visited; 
      break; 
     case "hover": 
      pseudoClass = CssPseudoClass.Hover; 
      break; 
     case "active": 
      pseudoClass = CssPseudoClass.Active; 
      break; 
     case "before": 
      pseudoClass = CssPseudoClass.Before; 
      break; 
     case "after": 
      pseudoClass = CssPseudoClass.After; 
      break; 
     case "first-line": 
      pseudoClass = CssPseudoClass.FirstLine; 
      break; 
     case "first-letter": 
      pseudoClass = CssPseudoClass.FirstLetter; 
      break; 
     default: 
      cssParserTraceSwitch.WriteLine("Unrecognized selector: " + str); 
      return null; 
    } 
} 

string cssClassesString = m.Groups["Classes"].Value; 
string[] cssClasses = cssClassesString.IsEmpty() ? EmptyArray<string>.Instance : cssClassesString.Substring(1).Split('.'); 
allCssClasses.AddRange(cssClasses); 

return new CssSelectorElement(
    tagName.ToLower(), 
    cssClasses, 
    m.Groups["Id"].Value, 
    pseudoClass); 

我第一次嘗試取得這樣的：

type CssPseudoClass = 
    | None = 0 
    | Link = 1 
    | Visited = 2 
    | Hover = 3 
    | Active = 4 
    | Before = 5 
    | After = 6 
    | FirstLine = 7 
    | FirstLetter = 8 

type CssSelectorElement = 
    { Tag : string 
     Id : string 
     Classes : string list  
     PseudoClass : CssPseudoClass } 
with 
    static member Default = 
     { Tag = ""; 
      Id = ""; 
      Classes = []; 
      PseudoClass = CssPseudoClass.None; } 

open FParsec 

let ws = spaces 
let str = skipString 
let strWithResult str result = skipString str >>. preturn result 

let identifier = 
    let isIdentifierFirstChar c = isLetter c || c = '-' 
    let isIdentifierChar c = isLetter c || isDigit c || c = '_' || c = '-'  
    optional (str "-") >>. many1Satisfy2L isIdentifierFirstChar isIdentifierChar "identifier" 

let stringFromOptional strOption = 
    match strOption with 
    | Some(str) -> str 
    | None -> "" 

let pseudoClassFromOptional pseudoClassOption = 
    match pseudoClassOption with 
    | Some(pseudoClassOption) -> pseudoClassOption 
    | None -> CssPseudoClass.None 

let parseCssSelectorElement = 
    let tag = identifier <?> "tagName" 
    let id = str "#" >>. identifier <?> "#id" 
    let classes = many1 (str "." >>. identifier) <?> ".className" 
    let parseCssPseudoClass = 
     choiceL [ strWithResult "link" CssPseudoClass.Link; 
        strWithResult "visited" CssPseudoClass.Visited; 
        strWithResult "hover" CssPseudoClass.Hover; 
        strWithResult "active" CssPseudoClass.Active; 
        strWithResult "before" CssPseudoClass.Before; 
        strWithResult "after" CssPseudoClass.After; 
        strWithResult "first-line" CssPseudoClass.FirstLine; 
        strWithResult "first-letter" CssPseudoClass.FirstLetter] 
       "pseudo-class"  
    // (tag?id|tag?classes|tag)pseudoClass? 
    pipe2 ((pipe2 (opt tag) 
        id 
        (fun tag id -> 
         { CssSelectorElement.Default with 
          Tag = stringFromOptional tag; 
          Id = id })) |> attempt 
      <|> 
      (pipe2 (opt tag) 
        classes 
        (fun tag classes -> 
         { CssSelectorElement.Default with 
          Tag = stringFromOptional tag; 
          Classes = classes })) |> attempt 
      <|> 
      (tag |>> (fun tag -> { CssSelectorElement.Default with Tag = tag }))) 
      (opt (str ":" >>. parseCssPseudoClass) |> attempt) 
      (fun selectorElem pseudoClass -> { selectorElem with PseudoClass = pseudoClassFromOptional pseudoClass }) 

但我真的不喜歡它是如何塑造。我曾想過提供一些更容易理解的東西，但部分解析（tag？id | tag？classes | tag）pseudoClass？用一些pipe2的和嘗試是非常糟糕的。

來了一個人，在FParsec更多的經驗，教育我的更好的方式來做到這一點？ 我想在試圖FSLex/Yacc的或Boost.Spirit代替FParsec是看能不能拿出來與他們更好的代碼

Answer 1

正如毛說，如果你發現自己在一個FParsec解析器重複的代碼，你可以隨時因素出於共同點部件放入變量或自定義組合器中。這是combinator庫的一大優點。

然而，在這種情況下，你也可以簡化和重組語法有點優化解析器。你可以，例如，與

let defSel = CssSelectorElement.Default 

let pIdSelector = id |>> (fun str -> {defSel with Id = str}) 
let pClassesSelector = classes |>> (fun strs -> {defSel with Classes = strs}) 

let pSelectorMain = 
    choice [pIdSelector 
      pClassesSelector 
      pipe2 tag (pIdSelector <|> pClassesSelector <|>% defSel) 
        (fun tagStr sel -> {sel with Tag = tagStr})] 

pipe2 pSelectorMain (opt (str ":" >>. parseCssPseudoClass)) 
     (fun sel optPseudo -> 
      match optPseudo with 
      | None -> sel 
      | Some pseudo -> {sel with PseudoClass = pseudo}) 

更換parseCssSelectorElement解析器的下半部順便說一句，如果你想分析大量的字符串常量，它是更有效地使用基於字典的解析器，像

let pCssPseudoClass : Parser<CssPseudoClass,unit> = 
    let pseudoDict = dict ["link", CssPseudoClass.Link 
          "visited", CssPseudoClass.Visited 
          "hover", CssPseudoClass.Hover 
          "active", CssPseudoClass.Active 
          "before", CssPseudoClass.Before 
          "after", CssPseudoClass.After 
          "first-line", CssPseudoClass.FirstLine 
          "first-letter", CssPseudoClass.FirstLetter]   
    fun stream -> 
     let reply = identifier stream    
     if reply.Status <> Ok then Reply(reply.Status, reply.Error) 
     else 
      let mutable pseudo = CssPseudoClass.None 
      if pseudoDict.TryGetValue(reply.Result, &pseudo) then Reply(pseudo) 
      else // skip to beginning of invalid pseudo class     
       stream.Skip(-reply.Result.Length) 
       Reply(Error, messageError "unknown pseudo class") 

Answer 2

你可以提取複雜的解析器變量的某些部分，如：

let tagid = 
    pipe2 (opt tag) 
     id 
     (fun tag id -> 
      { CssSelectorElement.Default with 
       Tag = stringFromOptional tag 
       Id = id }) 

你也嘗試使用applicative interface，我個人覺得它更容易使用，並認爲比pipe2：

let tagid = 
    (fun tag id -> 
      { CssSelectorElement.Default with 
       Tag = stringFromOptional tag 
       Id = id }) 
    <!> opt tag 
    <*> id