हास्केल प्रोग्राम का मूल संरचना

Question

कई हास्केल ट्यूटोरियल मैंने प्रोग्राम को कैसे व्यवस्थित किया जाए, इस बारे में बहुत कम कवरेज के साथ लगभग पूरी तरह से वाक्यविन्यास पर ध्यान केंद्रित किया है।

उदाहरण के लिए ...

यहाँ एक सी के एक नंगे हड्डियों रूपरेखा है ++ आवेदन:

#include <iostream> 
using namespace std; 

int addition (int a, int b) 
{ 
    int r; 
    r=a+b; 
    return (r); 
} 

int main() 
{ 
    int z; 
    z = addition (5,3); 
    cout << "The result is " << z; 
    return 0; 
} 

जब मैं पहली बार सी ++ सीखने शुरू कर दिया, इस तरह के उदाहरण मुझे बेहद कैसे अलग-अलग इकट्ठा करने के लिए सीखने में मदद की कामकाजी कार्यक्रमों में टुकड़े। हो सकता है कि मैं गलत जगहों पर देख रहा हूं, लेकिन मैं ऐसे किसी भी उदाहरण नहीं ढूंढ पा रहा हूं जो हास्केल के लिए सीधे और सरल हैं।

मुझे पहले से ही हास्केल वाक्यविन्यास का बहुत कुछ पता है। मैं पुनरावर्ती सूची समझ लिख सकता हूं, और तारों, पूर्णांक, और वज़ू को सूचियों में हेरफेर कर सकता हूं।

संक्षेप में: मैं सिर्फ यह जानना चाहता हूं कि हास्केल में दो सबराउटिन और वेरिएबल पास कैसा दिखता है। यदि मैं हास्केल प्रोग्राम को कैसे व्यवस्थित करना है, इस बारे में कुछ बुनियादी समझ प्राप्त कर सकता हूं, तो अंत में मैं कुछ सिंटैक्स डाल सकता हूं जिसे मैंने कुछ उपयोग के लिए सीखा है।

Answer 1

एक हास्केल प्रोग्राम की संरचना आश्चर्यजनक रूप से सरल है। आपके पास main फ़ंक्शन है जो आईओ करता है, और यह इसके बारे में है। तो मूल बातें:

module Main where 

addition a b = a + b 

main :: IO() 
main = do let z = addition 5 3 
      putStrLn $ "The result is: " ++ show z 

अब आप यह एक सरल कार्यक्रम में की तरह कुछ का उपयोग कर संकलन कर सकते हैं:

ghc --make Main.hs -o program 

और यह एक निष्पादन योग्य प्रोग्राम कहा जाता है का उत्पादन करना चाहिए।

सामान्य रूप से, कार्यक्रमों को आईओ से निपटने वाले कोड के अलग-अलग हिस्सों के साथ वास्तविक गणना के साथ अधिकतर शुद्ध कार्यों के रूप में संरचित किया जाता है। (इसमें निश्चित रूप से अपवाद हैं, लेकिन जितना संभव हो उतना शुद्ध कोड लिखने का सामान्य विचार काफी सार्वभौमिक है।)

चूंकि लगभग हर चीज शुद्ध कार्यों के समूह के रूप में व्यक्त की जाती है, इसलिए आप उनके बीच चर नहीं पारित करते हैं- - तर्क तर्क पारित करके संवाद करते हैं।

IO पर आपके कोड का हिस्सा main में अंकित है। ज्यादातर मामलों में, सभी आपका आईओ मुख्य माध्यम से जा रहा है; भले ही आप आईओ कार्यों को अलग से लिखते हैं और उन्हें नाम देते हैं, फिर भी उन्हें main से शुरू किया जाएगा।

हास्केल में एक "फ़ंक्शन समूह" को "मॉड्यूल" कहा जाता है। आप कई मॉड्यूल कर सकते हैं, प्रत्येक अपनी फाइल में:

module Blarg (exportedFunction) where 

helper a b = ... -- this will *not* be exported 
exportedFunction a b = helper a b -- this *will* be exported 

केवल कोष्ठक में पहचानकर्ता निर्यात किए जाएंगे; बाकी छिपे हुए हैं। यदि आप कोष्ठक शामिल नहीं करते हैं, तो सबकुछ डिफ़ॉल्ट रूप से निर्यात किया जाएगा।

इस फ़ाइल को Blarg.hs के रूप में सहेजें।अब आप Main में आयात कर सकते हैं:

import Blarg 

समूह के कार्यों के लिए एक और उपयोगी तरीका where है:

complicatedFunction a b c = helper 0 
    where helper count = ... 

इस तरह helper केवल complicatedFunction के लिए दायरे में है और यह भी a, b और c की पहुंच है complicatedFunction से।