व्याख्यान में लिखा गया है "पहली प्रोग्रामिंग भाषा के रूप में हास्केल।" भाग 1

हाय हमर! आज मैंने सर्गेई मिखाइलोविच अब्रामोव द्वारा अपने पुराने सिनॉप्स को "पहली प्रोग्रामिंग भाषा के रूप में हास्केल" पर निकाला और इस अद्भुत भाषा को उन लोगों को समझाने की कोशिश करेंगे जो इससे समझदारी और यथासंभव परिचित नहीं हैं। कहानी एक अप्रस्तुत पाठक के उद्देश्य से है। तो भले ही आपने पहली बार हास्केल शब्द सुना हो ...

दूसरा भाग

हास्केल बेस प्रकार

हास्केल भाषा के मूल प्रकार हैं:
संख्या
तार्किक मात्राएँ
प्रतीकों
सूचियों
आदेशित सेट (टुपल्स)
कार्यों

संख्या
पूरे:
पूर्णांक (-∞, ∞)
इंट (-2 ^ 31, 2 ^ 31-1)
प्रोल्यूड (मानक पुस्तकालय) में निश्चित रूप से पूर्णांकों के लिए कई उपयोगी कार्य हैं, जिनमें फ़्लोटिंग-पॉइंट नंबर (fromInt और fromInteger) में रूपांतरण शामिल है)

फ़्लोटिंग पॉइंट नंबर:
फ्लोट (7 दशमलव स्थान)
डबल (16 दशमलव स्थान)

तार्किक मात्राएँ
बूल (सच | गलत)
संयोजन, अस्वीकृति, और नकारात्मक संचालन (&&, ||, नहीं)

प्रतीकों
चार ('ए')
और चार कार्यों में Int और Int में चार (ord, chr)

सूचियों
सूची भिन्न हो सकती है:
[इंट] - पूर्णांक की एक सूची [1,2,3,4]
[चार] - पात्रों की सूची (स्ट्रिंग)
[[इंट]] - एक सरणी
[फ्लोट -> फ्लोट] सुविधाओं की एक सूची है
और टी। डी।

उदाहरणों में कुछ मानक संचालन:
मुख्य> सिर [1,2,3]
1
मुख्य> पूंछ [1,2,3]
[2,3]
मुख्य> लंबाई [सही, गलत]
2
मुख्य> रिवर्स [1,2,3]
[3,2,1]
मुख्य> 0: [1,2,3]
[0,1,2,3]
मुख्य> - ghci संकलक कंसोल में प्रॉम्प्ट लाइन
":" - एक आइटम को सूची में संलग्न करने का संचालन।

सेट का आदेश दिया
उदाहरण:
(२.४, "बिल्ली") (फ्लोट, [चार])
('ए', ट्रू, 1) (चार, बूल, इंट)
([१,२], वर्गर्ट) ([इंट], फ्लोट-> फ्लोट)
(1, (2, 3)) (इंट, (इंट, इंट))

लेकिन, हास्केल और सभी कार्यात्मक प्रोग्रामिंग का दिल, ज़ाहिर है, स्वयं कार्य करता है!

कार्यों

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

square :: Integer -> Integer square x = x*x 

जैसा कि आपने शायद अनुमान लगाया था, यह एक संख्या को चुकता करने का एक कार्य है। हम इसका विस्तार से विश्लेषण करेंगे:

पहली पंक्ति एक फ़ंक्शन घोषणा है:
फंक्शन_नाम :: परिभाषा_ क्षेत्र -> मूल्य_क्षेत्र
वर्ग :: पूर्णांक -> पूर्णांक
यह कहा जाना चाहिए कि हास्केल में हमेशा एक फ़ंक्शन घोषित करना आवश्यक नहीं है। कुछ मामलों में, दुभाषिया पहले से ही समझ जाएगा कि इस फ़ंक्शन की परिभाषा और मूल्य क्या हैं। हालाँकि, विज्ञापनों को छोड़ना एक बुरा विचार है।

दूसरी पंक्ति फ़ंक्शन की परिभाषा है:
फंक्शन_नाम पैरामीटर्स = कैल्कुलेशन_रूले
वर्ग x = x * x

मापदंडों के बिना एक फ़ंक्शन एक स्थिर से अधिक कुछ नहीं है:

 e :: Float e = exp 1.0 

कई मापदंडों के साथ कार्य:
स्पष्टीकरण के लिए जनेटम को धन्यवाद ( टिप्पणियों को पढ़ें )।

 abcFormula :: Float -> Float -> Float -> [Float] abcFormula abc = [ (-b+sqrt(b*b-4.0*a*c))/(2.0*a), (-b-sqrt(b*b-4.0*a*c))/(2.0*a) ] --    ax^2+bx+c=0 

विकल्प के साथ कार्य की परिभाषा

किसी भी भाषा के साथ के रूप में, हास्केल की शाखाएँ हैं।
आइए एक उदाहरण के रूप में एब्स फ़ंक्शन (मॉड्यूल) का उपयोग करके उनका विश्लेषण करें।
यदि ... तो ... और ...

 abs1 x = if x>=0 then x else -x 

मामला ... का ...

 abs2 x = case x>=0 of True -> x False -> -x 

लेकिन मानक अगर और मामले के अलावा, हास्केल के पास एक बहुत ही सुंदर और सबसे अधिक उपयोग की जाने वाली शाखा है। तथाकथित सुरक्षा भाव । एक उदाहरण:

 abs3 x | x>0 = x | x<0 = -x | otherwise = 0 

एक सीधी रेखा को इस रूप में पढ़ा जाना चाहिए: "पर।"
हम पढ़ते हैं: "एबीएस 3 फ़ंक्शन, इनपुट पैरामीटर x के साथ, x> 0 के लिए मान x लेता है, x <0 के लिए यह मान -x लेता है, और किसी अन्य मामले में मान 0 लेता है"।
बेशक, हम दो गार्ड अभिव्यक्तियों की मदद से सब कुछ रिकॉर्ड कर सकते थे, लेकिन मैंने तीन नीचे लिखे ताकि यह स्पष्ट हो सके कि उनमें से कोई भी संख्या हो सकती है।
अन्यथा फोरप्ले में बहुत सरलता से परिभाषित किया गया है:

 otherwise :: Bool otherwise = True 

यही है, "अन्यथा" के बजाय "ट्रू" लिखना संभव है, लेकिन यह फिर से, खराब रूप है।

पैटर्न मिलान

हास्केल में सबसे आम और प्रभावी तकनीकों में से एक पैटर्न मिलान है। एक पैरामीटर के बजाय, हम फंक्शन में स्लिप कर सकते हैं कि पैरामीटर कैसा दिखना चाहिए। यदि नमूना पास आया, तो फ़ंक्शन निष्पादित किया जाता है, यदि नहीं, तो यह अगले नमूने पर जाता है। उदाहरण के लिए, पैटर्न का उपयोग करके पुनरावृत्ति के माध्यम से तथ्य का निर्धारण करना:

 fact :: Integer -> Integer fact 0 = 1 fact n = n * fact (n-1) 

एक ही बात है, लेकिन गार्ड अभिव्यक्ति की मदद से:

 fact :: Integer -> Integer fact n | n==0 = 1 | n>0 = n*fact (n-1) 

एक सूची के लिए एक बहुत ही सामान्य पैटर्न है: (x: xs)। एक्स - पहले तत्व को इंगित करता है, एक्सएस - बाकी सूची (पहले तत्व को छोड़कर)। ":" - एक आइटम को सूची में संलग्न करने का संचालन। प्रस्तावना के उदाहरण:

 head :: [a] -> a head (x:_) = x head [] = error "Prelude.head: empty list" tail :: [a] -> [a] tail (_:xs) = xs tail [] = error "Prelude.tail: empty list" 

हेड फ़ंक्शन इनपुट [कुछ] की सूची के रूप में लेता है और इस सूची का पहला तत्व देता है। टेल फ़ंक्शन इनपुट [कुछ] की सूची के रूप में लेता है और इस सूची से पहला तत्व निकालता है।
"_" - इसका मतलब है कि यह तत्व हमें ब्याज नहीं देता है।

खैर, आज के लिए बस इतना ही। यदि रुचि है, तो मैं निकट भविष्य में एक अगली कड़ी लिखूंगा।