हास्केल पारसेक: `एक` optional` Combinator

Question

मैं इस व्याकरण हास्केल के पारसेक लाइब्रेरी का उपयोग कर नियम लागू करना चाहते हैं अंदर many` Combinator:

((a | b | c)* (a | b))? 

जो एक पार्सर नियम यह है कि एक वैकल्पिक स्वीकार करता है (यानी संभावित रिक्त है) स्ट्रिंग। स्ट्रिंग यह acccepts खाली नहीं है, तो यह ab या c पारसर्स के शून्य या अधिक घटनाओं के माध्यम से गुजर द्वारा सेवन किया जा सकता है, लेकिन सबसे बाहरी ? वैकल्पिक पार्सर द्वारा स्वीकार कर लिया स्ट्रिंग या तो पार्सर a द्वारा या सेवन किया जाना चाहिए b, लेकिन c नहीं। यहाँ एक उदाहरण है:

module Main where 

import Text.Parsec 
import Text.Parsec.Text 

a,b,c :: GenParser() Char 
a = char 'a' 
b = char 'b' 
c = char 'c' 

-- ((a | b | c)* (a | b))? 
myParser = undefined 

shouldParse1,shouldParse2,shouldParse3, 
     shouldParse4,shouldFail :: Either ParseError String 
-- these should succeed 
shouldParse1 = runParser myParser() "" "" -- because ? optional 
shouldParse2 = runParser myParser() "" "b" 
shouldParse3 = runParser myParser() "" "ccccccb" 
shouldParse4 = runParser myParser() "" "aabccab" 

-- this should fail because it ends with a 'c' 
shouldFail = runParser myParser() "" "aabccac" 

main = do 
    print shouldParse1 
    print shouldParse2 
    print shouldParse3 
    print shouldParse4 
    print shouldFail 

एक पहला प्रयास इस प्रकार दिखाई देंगे:

myParser = option "" $ do 
    str <- many (a <|> b <|> c) 
    ch <- a <|> b 
    return (str ++ [ch]) 

लेकिन many बस सभी 'एक' 'ख' और 'प्रत्येक परीक्षा मामले में सी' अक्षर की खपत, a <|> b छोड़ने उपभोग करने के लिए कोई पात्र नहीं है।

सवाल:

पारसेक combinators का उपयोग करना, ((a | b | c)* (a | b))? का सही कार्यान्वयन myParser परिभाषित करने के लिए क्या है?

Answer 1

हम यह भी कह सकते हैं यह थोड़ा अलग हैं: अपने पार्सर में c केवल सफल हो सकते है, तो यह किसी भी टोकन, जिसका उपयोग एकमात्र lookAhead साथ किया जा सकता द्वारा पीछा किया है:

myParser = many (a <|> b <|> (c <* (lookAhead anyToken <?> "non C token"))) <* eof