हास्केल: "1 + 2"

Question

जैसे स्ट्रिंग का मूल्यांकन कैसे करें असल में मेरे पास "x + y" जैसे कुछ सूत्र हैं, जो String है। मैं x/y वैरिएबल को "1.2" जैसे विशिष्ट मानों के साथ बदलने में कामयाब रहा, जो अभी भी String प्रकार है। अब मेरे पास "1 + 2" जैसी अभिव्यक्ति है।

तो समस्या यह है कि एक स्ट्रिंग प्रकार की अभिव्यक्ति का मूल्यांकन कैसे करें और परिणाम प्राप्त करें।

ps: मैं read की तरह sth चाहता हूं, जो सीधे ऑपरेटर (+/-, आदि) केस को संभालने के बजाय पूरी स्ट्रिंग अभिव्यक्ति को परिवर्तित कर सकता है। क्या यह संभव है?

Answer 1

आपका प्रश्न व्याख्या के लिए बहुत सारे कमरे छोड़ देता है। मैं अनुमान लगा रहा हूं कि आप लेक्सिंग, पार्सिंग, शायद टाइपिंग, और मूल्यांकन की पूरी पाइपलाइन बनाने के आदी नहीं हैं। लंबे उत्तर में आपको यह परिभाषित करना होगा कि आप किस भाषा का मूल्यांकन करना चाहते हैं (बस '+' के साथ पूर्णांक, शायद '+', '-' '*', '/', या यहां तक ​​कि एक बड़ी भाषा के साथ सभी राशन?) और प्रत्येक को निष्पादित करें उस भाषा के लिए उपरोक्त चरणों में से।

संक्षिप्त उत्तर है: हास्केल भाव का मूल्यांकन करने, जो बुनियादी गणित ऑपरेटरों आप शायद के बारे में बात कर रहे हैं शामिल हैं, बस "संकेत" पैकेज का उपयोग करें:

$ cabal install hint 
... 
$ ghci 
> import Language.Haskell.Interpreter 
> runInterpreter $ setImports ["Prelude"] >> eval "3 + 5" 
Right "8" 

आहा!

Answer 2

Real World Haskell के Parsec अनुभाग पढ़ने के लायक हो सकता है। आप इसे एक अभिव्यक्ति वृक्ष में पार्स कर सकते हैं और फिर मानों को प्रतिस्थापित कर सकते हैं। जैसा कि आप पारसेक का उपयोग करते हैं, आप प्रकारों का उपयोग करके अभिव्यक्ति वृक्ष का निर्माण करेंगे (बहुत मोटे तौर पर, मुझे यकीन है कि मैंने कुछ गलतियां की हैं जिन्हें मैं ठीक करता हूं जैसे ही लोग उन्हें इंगित करते हैं!) नीचे की तरह।

data Op = Plus | Minus 
data Term = Variable String 
      | Value Int 
data Expression = Expr Expression Op Expression 
       | Term 

फिर 1 + 2 (Expr (Variable "x") Plus (Variable "y")) हो सकता है और आप उपयुक्त प्रतिस्थापन लागू हो सकते हैं।

परिणाम प्राप्त करने के लिए, मुझे लगता है कि आप सही काम कर सकते हैं evaluate :: Map String Int -> Expression -> Either ErrorMessage Int जो मानचित्र में बाइंडिंग लागू करेगा और फिर यदि संभव हो तो परिणाम की गणना करेगा।

Answer 3

वैसे मैं hint के खिलाफ अपने सिर को टक्कर लगी हूं लेकिन अब मैं हार मानता हूं। मुझे पता है संकेत यह कर सकता है लेकिन मुझे यकीन नहीं है कि कैसे। [संपादित करें] संकेत के लिए आयात सेट करने के लिए टॉमएमडी का जवाब देखें। [/ संपादित करें]

import Language.Haskell.Interpreter (eval, runInterpreter, Interpreter, InterpreterError) 

main = do let resIO = eval "3" :: Interpreter String 
      res <- runInterpreter resIO 
      print res 

यह uninterestingly परिणाम के रूप में Right "3" पैदा करता है। मैं निम्नलिखित वेरिएंट की कोशिश की, चौंकाने त्रुटियों में केवल चलाने के लिए:

... eval "3 + 3" .... 
-- yields -- 
Left (WontCompile [GhcError (errMsg = "Not in scope: `+'"]) 

+ ऑपरेटर दायरे में नहीं है ??? wtf ...

import Language.Haskell.Interpreter (interpret, as, runInterpreter, Interpreter) 

main = do let resIO = interpret "3" (as :: Int) :: Interpreter Int 
      res <- runInterpreter resIO 
      print res 
-- yields -- 
Left (WontCompile [GhcError (errMsg = "Not in scope: type constructor or class 'Int'")]) 

Int कक्षा दायरे में नहीं है ??? उह ...

मैं उन संकेतों के बारे में अधिक जानकारी देता हूं जो संकेत के बेहतर विवरण पर विस्तार से हैं।