Parsec.Expr दोहराया उपसर्ग/पोस्टफिक्स ऑपरेटर

Question

समर्थित नहीं

Parsec.Expr.buildExpressionParser के लिए दस्तावेज़ का कहना है:

उपसर्ग और पोस्टफ़िक्स ही पूर्वता के ऑपरेटरों केवल एक बार हो सकता है (यानी -2 यदि अनुमति नहीं है - उपसर्ग है नकारना)।

और वास्तव में, यह, मुझे काट भाषा मैं पार्स करने के लिए कोशिश कर रहा हूँ का उपसर्ग और पोस्टफ़िक्स ऑपरेटरों की मनमानी पुनरावृत्ति (**a[1][2] की तरह एक सी अभिव्यक्ति के बारे में सोच) की अनुमति देता है के बाद से किया गया है।

तो, Parsec क्यों इस प्रतिबंध को बनाते हैं, और मैं इसके आसपास कैसे काम कर सकता हूं?

मुझे लगता है कि मैं अपने उपसर्ग/पोस्टफिक्स पार्सर्स को term पार्सर में नीचे ले जा सकता हूं क्योंकि उनके पास सबसे ज्यादा प्राथमिकता है।

यानी

**a + 1 

(*(*(a)))+(1) 

लेकिन क्या के रूप में पार्स किया गया है मैं अगर मैं के रूप में

*(*((a)+(1))) 

है कि मैं क्या चाहता हूँ buildExpressionParser था कि यह पार्स करने के लिए चाहता था कर सकता था, मैं मेज में ऑपरेटरों के आदेश को फिर से व्यवस्थित कर सकता था।

नोट एक बेहतर समाधान के लिए here देखें

Answer 1

मैं इसे अपने आप chainl1 का उपयोग करके हल:

prefix p = Prefix . chainl1 p $ return  (.) 
postfix p = Postfix . chainl1 p $ return (flip (.)) 

ये combinators एक op पार्सर कि हमेशा सफल होता है, और बस के साथ chainl1 का उपयोग कार्यों लौटे तैयार करता term पार्सर बाएं से दाएं या दाएं से बाएं क्रम में। इनका उपयोग buildExprParser तालिका में किया जा सकता है; जहाँ आप इस किया होता:

exprTable = [ [ Postfix subscr 
       , Postfix dot 
       ] 
      , [ Prefix pos 
       , Prefix neg 
       ] 
      ] 

अब आप ऐसा करते हैं: इस तरह से

, buildExprParser अभी भी ऑपरेटर पूर्वता सेट करने के लिए इस्तेमाल किया जा सकता है, लेकिन अब केवल एक ही Prefix या Postfix ऑपरेटर देखता है प्रत्येक प्राथमिकता पर। हालांकि, उस ऑपरेटर के पास जितनी प्रतियां हो सकती हैं उतनी प्रतिलिपि बनाने की क्षमता है, और एक फ़ंक्शन लौटाता है जो ऐसा लगता है कि केवल एक ही ऑपरेटर था।