अजगर कैसे हास्केल पढ़ते हैं

क्या आपको इस तथ्य के बारे में पता है कि कभी-कभी आपको यह समझने की आवश्यकता होती है कि एक अपरिचित भाषा में कोड का एक टुकड़ा क्या होता है? यदि भाषा आपके द्वारा उपयोग की जाने वाली चीज़ों के समान है, तो आप आमतौर पर अधिकांश कोड के उद्देश्य का अनुमान लगा सकते हैं - भले ही आप भाषा की सभी विशेषताओं से परिचित न हों।
हास्केल के साथ, सब कुछ अलग है, क्योंकि इसका सिंटैक्स पारंपरिक भाषाओं के सिंटैक्स से पूरी तरह से अलग दिखता है। लेकिन, वास्तव में, अंतर इतना महान नहीं है - आपको केवल सही कोण पर देखने की आवश्यकता है। यहाँ एक त्वरित है, अधिकांश भाग के लिए गलत है, और, उम्मीद है, pythonists द्वारा व्याख्या करने के लिए उपयोगी मार्गदर्शिका ( लेखक "पायथोनिस्टा" शब्द का उपयोग करता है - लगभग। अनुवादक ) हास्केल कोड। अंत तक, आप निम्न टुकड़े को समझ पाएंगे (कोड का भाग एलिप्स के बाद छोड़ा गया है):

runCommand env cmd state = ... retrieveState = ... saveState state = ... main :: IO () main = do args <- getArgs let (actions, nonOptions, errors) = getOpt Permute options args opts <- foldl (>>=) (return startOptions) actions when (null nonOptions) $ printHelp >> throw NotEnoughArguments command <- fromError $ parseCommand nonOptions currentTerm <- getCurrentTerm let env = Environment { envCurrentTerm = currentTerm , envOpts = opts } saveState =<< runCommand env command =<< retrieveState 

प्रकार

उसके बाद आने वाली हर चीज को नजरअंदाज type :: (और type , class , instance और newtype भी नजरअंदाज type )। कुछ कसम जो उन्हें कोड को समझने में मदद करती हैं। यदि आप एक पूर्ण शुरुआत हैं, तो Int और String जैसी LayoutClass मदद कर सकती हैं, लेकिन LayoutClass और MonadError जैसी LayoutClass नहीं हैं। उनकी चिंता मत करो।

बहस

fabc f(a, b, c) । हास्केल कोष्ठक और अल्पविराम को छोड़ देता है। इसका एक परिणाम यह है कि कभी-कभी हमें तर्कों के लिए कोष्ठक की आवश्यकता होती है: fa (b1 + b2) c अनुवाद f(a, b1 + b2, c) ।

डॉलर का प्रतीक

चूँकि रूप के जटिल अभिव्यक्तियाँ a + b काफी सामान्य हैं, और Haskelers (Haskellers लेखक - अनुवादक का नोट ) कोष्ठक पसंद नहीं करते हैं, उनसे बचने के लिए डॉलर चिन्ह का उपयोग किया जाता है: f $ a + b f (a + b) बराबर होता है और इसका अनुवाद किया जाता है। f(a + b) । आप $ विशालकाय बाईं कोष्ठक पर विचार कर सकते हैं जो स्वचालित रूप से पंक्ति के अंत में बंद हो जाता है (और अब लिखने की आवश्यकता नहीं है)))), हुर्रे!) विशेष रूप से, आप उन्हें घोंसला बना सकते हैं, और प्रत्येक एक घोंसले के स्तर का निर्माण करेगा: f $ gx $ hy $ a + b , f (gx (hy (a + b))) समतुल्य है और f(g(x,h(y,a + b)) (हालाँकि कुछ इसे बुरा व्यवहार मानते हैं)।
कभी-कभी आप इस विकल्प को देख सकते हैं: <$> (कोण कोष्ठक के साथ)। आप इसे $ के समान मान सकते हैं। यह भी होता है <*> - बहाना है कि यह एक अल्पविराम है, और f <$> a <*> b अनुवाद f(a, b) ।

अप्रोस्ट्रोफिस उल्टा

x `f` y अनुवाद f(x,y) । एपोस्ट्रोफिस के बीच का टुकड़ा एक फ़ंक्शन है, आमतौर पर द्विआधारी, और दाएं और बाएं तर्क।

प्रतीक के बराबर

दो मूल्य संभव हैं। कोड के एक ब्लॉक की शुरुआत में, इसका मतलब है कि आप केवल एक फ़ंक्शन को परिभाषित करते हैं:

 doThisThing abc = ... 

==>

 def doThisThing(a, b, c): ... 

कीवर्ड के आगे, असाइनमेंट ऑपरेटर के रूप में कार्य करता है:

 let a = b + c in ... 

==>

 a = b + c ... 

बाण बाण

असाइनमेंट ऑपरेटर के रूप में भी काम करता है:

 a <- createEntry x 

==>

 a = createEntry(x) 

हम समान चिह्न का उपयोग क्यों नहीं करते? मोजो। (अधिक विशेष रूप से, createEntry x के दुष्प्रभाव हैं। अधिक सटीक रूप से, इसका मतलब है कि अभिव्यक्ति विवादास्पद है। लेकिन यह एक जादू है। फिलहाल, इसे अनदेखा करें।)

सही तीर

सब कुछ जटिल है। हम बाद में उनके पास लौट आएंगे।

कीवर्ड करें

शोर। नजरअंदाज किया जा सकता है। यह कुछ जानकारी देता है - कि नीचे दुष्प्रभाव होंगे, लेकिन आप पायथन में अंतर कभी नहीं देखेंगे।

वापसी

शोर। इसे भी नजरअंदाज करें। (आप निष्पादन को नियंत्रित करने के लिए उपयोग किए गए return कभी नहीं देखेंगे।)

बिंदु

f . g $ a + b f . g $ a + b अनुवाद f(g(a + b)) । वास्तव में, पायथन कार्यक्रम में, आपको संभवतः निम्नलिखित जैसा कुछ दिखाई देगा:

 x = g(a + b) y = f(x) 

लेकिन हास्केल प्रोग्रामर को अतिरिक्त चर से एलर्जी है।

बाइंडिंग ऑपरेटर और मछली

आप =<< , >>= , <=< और >=> जैसी चीजों के साथ आ सकते हैं। बस, मध्यवर्ती चर से छुटकारा पाने के कुछ और तरीके हैं:

 doSomething >>= doSomethingElse >>= finishItUp 

==>

 x = doSomething() y = doSomethingElse(x) finishItUp(y) 

कभी-कभी एक हास्केल प्रोग्रामर यह तय करता है कि इसे अलग दिशा में करना विशेषकर, खासकर अगर चर को कहीं और मान दिया जाए:

 z <- finishItUp =<< doSomethingElse =<< doSomething 

==>

 x = doSomething() y = doSomethingElse(x) z = finishItUp(y) 

सबसे महत्वपूर्ण बात यह है कि doSomething , doSomethingElse और finishItUp की परिभाषाओं को doSomething जो हो रहा है, उसका उल्टा इंजीनियरिंग करना है: यह एक संकेत देगा कि "मछली" को "प्रवाह" अतीत। यदि आप ऐसा करते हैं, तो आप <=< और >=> उसी तरह पढ़ सकते हैं (वास्तव में, वे जैसे कार्यों की रचना करते हैं)। पढ़ें >> अर्धविराम के रूप में (यानी, कोई काम नहीं):

 doSomething >> doSomethingElse 

==>

 doSomething() doSomethingElse() 

आंशिक आवेदन

कभी-कभी हास्केल प्रोग्रामर एक फ़ंक्शन कहते हैं, लेकिन पर्याप्त तर्क पास नहीं करते हैं। डरो मत, सबसे अधिक संभावना है, उन्होंने बाकी तर्कों का स्थानांतरण कहीं और आयोजित किया। उन कार्यों की उपेक्षा करें, या उन कार्यों की तलाश करें जो अनाम कार्यों को तर्क के रूप में स्वीकार करते हैं। सामान्य संदिग्ध: map , fold (और इसके प्रकार), filter , रचना ऑपरेटर . , मछली ऑपरेटर ( =<< , आदि)। यह अक्सर संख्यात्मक ऑपरेटरों के साथ होता है: (+3) lambda x: x + 3 अनुवाद करता है।

नियंत्रण ऑपरेटरों

प्रवृत्ति पर भरोसा: ये ऑपरेटर वही करते हैं जो आपने सोचा था! (भले ही आपको लगता है कि उन्हें उस तरह से काम नहीं करना चाहिए)। तो, यदि आप देखते हैं: when (x == y) $ doSomething x , पढ़ें कि "चूंकि x y बराबर है, तो doSomething with तर्क x " को कॉल करें।
इस तथ्य को अनदेखा करें कि आप वास्तव में इसका अनुवाद when(x == y, doSomething(x)) (यहाँ doSomething को वैसे भी कहा जाएगा) नहीं करेंगे। दरअसल, when(x == y, lambda: doSomething x) अधिक सटीक होगा, लेकिन भाषा निर्माण के when यह विचार करना अधिक सुविधाजनक हो सकता है।
if और case कीवर्ड हैं। वे उम्मीद के मुताबिक काम करते हैं।

सही तीर (असली के लिए!)

दाएं तीर का बाएं तीर से कोई लेना-देना नहीं है। उन्हें कॉलन के रूप में सोचो: वे हमेशा case कीवर्ड और बैकस्लैश के पास कहीं होते हैं (जो लैम्बडा घोषित करता है: \x -> x lambda x: x अनुवाद करता है)।
case का उपयोग करते हुए पैटर्न मिलान एक बहुत अच्छी सुविधा है, लेकिन इस पोस्ट में इसे समझाना मुश्किल है। शायद सबसे सरल if..elif..else के असाइनमेंट वाली श्रृंखला को देखें:

 case moose of Foo xyz -> x + y * z Bar z -> z * 3 

==>

 if isinstance(moose, Foo): x = moose.x # ! y = moose.y z = moose.z return x + y * z elif isinstance(moose, Bar): z = moose.z return z * 3 else: raise Exception("Pattern match failure!") 

रैपिंग

आप एक रैपिंग फ़ंक्शन को इस तथ्य से अलग कर सकते हैं कि यह किसके with शुरू होता with । वे पायथन में संदर्भ प्रबंधन की तरह काम करते हैं:

 withFile "foo.txt" ReadMode $ \h -> do ... 

==>

 with open("foo.txt", "r") as h: ... 

(आप बैकस्लैश का पता लगा सकते हैं। हाँ, यह एक मेमना है। हाँ, withFile एक फ़ंक्शन है। हाँ, आप अपने स्वयं को परिभाषित कर सकते हैं।)

अपवाद

throw , catch , catch , throwIO , finally , handle और अन्य सभी समान कार्य ठीक उसी तरह से काम करते हैं जैसे आप उम्मीद करते हैं। यह, हालांकि, मज़ेदार लग सकता है, क्योंकि ये सभी कार्य हैं, न कि कीवर्ड, सभी परिणामों के साथ। उदाहरण के लिए:

 trySomething x `catch` \(e :: IOException) -> handleError e 

===

 catch (trySomething x) (\(e :: IOException) -> handleError e) 

==>

 try: trySomething(x) except IOError as e: handleError(e) 

शायद

यदि आप Nothing देखते हैं, तो आप इसे None । तो isNothing x जाँच करता है कि x is None । कुछ भी नहीं के विपरीत क्या है? Just । उदाहरण के लिए, isJust x सत्यापित करता है कि x is not None ।
आप सही क्रम में Just और None से संबंधित शोर का एक बहुत कुछ देख सकते हैं। सबसे आम मामलों में से एक:

 maybe someDefault (\x -> ...) mx 

==>

 if mx is None: x = someDefault else: x = mx ... 

इस मामले के लिए एक विशिष्ट विकल्प है जब अशक्त त्रुटि है:

 maybe (error "bad value!") (\x -> ...) x 

==>

 if x is None: raise Exception("bad value!") 

रिकॉर्डिंग

उम्मीद के मुताबिक काम करें, हालांकि हास्केल आपको बिना नाम के क्षेत्र बनाने की अनुमति देता है:

 data NoNames = NoNames Int Int data WithNames = WithNames { firstField :: Int, secondField :: Int } 

इस प्रकार, NoNames को NoNames (1, 2) रूप में पायथन में NoNames जाएगा, और निम्न वर्ग के WithNames :

 class WithNames: def __init__(self, firstField, secondField): self.firstField = firstField self.secondField = secondField 

इस सरल तरीके से, NoNames 2 3 प्रसारण (2, 3) और WithNames 2 3 या WithNames { firstField = 2, secondField = 3 } WithNames(2, 3) ।
फील्ड्स थोड़े अलग हैं। सबसे महत्वपूर्ण बात यह है कि याद रखें कि हास्केलर्स ने अपने क्षेत्रों के नाम चर के सामने रखे हैं, जबकि आपको सबसे अधिक संभावना है कि आप उन्हें डालने के बाद उपयोग करें। तो field x अनुवाद x.field । x.field = 2 कैसे लिखें? वास्तव में, वास्तव में, आप ऐसा नहीं कर सकते। यद्यपि आप कॉपी कर सकते हैं:

 return $ x { field = 2 } 

==>

 y = copy(x) y.field = 2 return y 

या आप स्क्रैच से बना सकते हैं यदि आप x को डेटा संरचना के नाम से बदलते हैं (यह एक बड़े अक्षर से शुरू होता है)। हम केवल प्रतिलिपि संरचनाओं की अनुमति क्यों देते हैं? क्योंकि हास्केल एक शुद्ध भाषा है; लेकिन इस पर ध्यान न दें। बस एक और हास्केल क्वर्की।

सूची के भाव

शुरू में, वे मिरांडा-हास्केल परिवार से आए थे! उनके पास केवल कुछ और पात्र हैं।

 [ x * y | x <- xs, y <- ys, y > 2 ] 

==>

 [ x * y for x in xs for y in ys if y > 2 ] 

यह भी पता चला है कि हास्केलर अक्सर बहु-पंक्ति रूप में सूची अभिव्यक्तियों को लिखना पसंद करते हैं (शायद उन्हें इस तरह से पढ़ना आसान लगता है)। यह कुछ इस तरह दिखता है:

 do x <- xs y <- ys guard (y > 2) return (x * y) 

इसलिए यदि आप एक बायाँ तीर देखते हैं और ऐसा नहीं लगता है कि तृतीय-पक्ष प्रभाव अपेक्षित हैं, तो यह संभवतः एक सूची अभिव्यक्ति है।

अधिक वर्ण

सूचियाँ ठीक वैसे ही काम करती हैं जैसे आप पायथन में करते हैं: [1, 2, 3] - और वास्तव में तीन तत्वों की सूची। बृहदान्त्र, जैसा कि x:xs , का अर्थ है अंत में x साथ एक सूची बनाना और अंत में xs (लिश प्रशंसकों के लिए ()।) ++ - सूची संघटन, !! - सूचकांक द्वारा उपचार। बैकस्लैश का अर्थ है lambda । यदि आपको कोई ऐसा चरित्र दिखाई देता है, जिसे आप नहीं समझते हैं, तो Hoogle में खोज करने का प्रयास करें (हाँ, यह पात्रों के साथ काम करता है!)।

अधिक शोर

निम्नलिखित कार्यों, संभवतः शोर, और संभवतः अनदेखा किया जा सकता है: liftIO , lift , runX (जैसे runState ), unX (जैसे unConstructor ) , fromJust , fmap , const , से evaluate , तर्क से पहले विस्मय बोधक चिह्न ( f !x ) f !x , seq , seq प्रतीक (जैसे I# x )।

यह सब एक साथ रखना

आइए मूल कोड स्निपेट पर वापस जाएं:

 runCommand env cmd state = ... retrieveState = ... saveState state = ... main :: IO () main = do args <- getArgs let (actions, nonOptions, errors) = getOpt Permute options args opts <- foldl (>>=) (return startOptions) actions when (null nonOptions) $ printHelp >> throw NotEnoughArguments command <- fromError $ parseCommand nonOptions currentTerm <- getCurrentTerm let env = Environment { envCurrentTerm = currentTerm , envOpts = opts } saveState =<< runCommand env command =<< retrieveState 

अनुमान लगाने के लिए, हम इस अनुवाद को प्राप्त कर सकते हैं:

 def runCommand(env, cmd, state): ... def retrieveState(): ... def saveState(state): ... def main(): args = getArgs() (actions, nonOptions, errors) = getOpt(Permute(), options, args) opts = **mumble** if nonOptions is None: printHelp() raise NotEnoughArguments command = parseCommand(nonOptions) currentTerm = getCurrentTerm() env = Environment(envCurrentTerm=currentTerm, envOpts=opts) state = retrieveState() result = runCommand(env, command, state) saveState(result) 

हास्केल सिंटैक्स की सतही समझ के लिए यह बुरा नहीं है (एक टुकड़ा है जिसे स्पष्ट तरीके से अनुवादित नहीं किया जा सकता है, जिसे इस बात का ज्ञान होना चाहिए कि सजा क्या है ( वास्तव में, पायथन में एक अंतर्निहित कमी फ़ंक्शन है - अनुवादक टिप्पणी )। नहीं हास्केल कोड दृढ़ संकल्प के साथ काम करता है; मैं दोहराता हूं; इसके बारे में बहुत चिंता है!
ज्यादातर चीजें जिन्हें मैंने "शोर" कहा है, वास्तव में, उनके पीछे बहुत गहरे कारण हैं, और यदि आप उनके पीछे क्या रुचि रखते हैं, तो मैं हास्केल में लिखना सीखने की सलाह देता हूं। लेकिन अगर आप सिर्फ पढ़ रहे हैं, तो मुझे लगता है कि ये नियम, पर्याप्त से अधिक हैं।
पुनश्च यदि आप वास्तव में इस बात में रुचि रखते हैं कि किस foldl (>>=) (return startOptions) action : यह कर्तव्यों के पैटर्न की एक श्रृंखला को लागू foldl (>>=) (return startOptions) action । हाँ नरक।

अनुवादक से पीपीएस: ग्रैनिनस ने कुछ शर्तों के अनुवाद के साथ मेरी मदद की