[लगभग। अनुवाद: अनुवाद जारी रहा, यहाँ पहला लेख]

OCaml पर कार्यक्रम की संरचना

अब हम OCaml पर कुछ वास्तविक कार्यक्रमों के उच्च-स्तरीय विश्लेषण पर थोड़ा समय व्यतीत करेंगे। मैं आपको स्थानीय और वैश्विक परिभाषाएँ दिखाना चाहता हूँ, उपयोग में अंतर ;;



और ;



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

स्थानीय "चर" (वास्तव में स्थानीय अभिव्यक्ति)

सी में हमारे average



फ़ंक्शन को लें और इसमें स्थानीय चर जोड़ें (पिछले अध्याय में उदाहरण के साथ तुलना करें)।

 डबल औसत (डबल ए, डबल बी)
 {
   डबल सम = ए + बी;
   वापसी राशि / 2;
 }

अब इसे OCaml के लिए देखें:

 औसत औसत दें =
   आज्ञा देना = a +।  बी में
   योग /।  2.0 ;;

मानक अभिव्यक्ति let name = expression in



उपयोग स्थानीय नाम की अभिव्यक्ति को परिभाषित करने के लिए किया जाता है और name



का उपयोग बाद में अभिव्यक्ति के बजाय किया जा सकता है ;;



, जिसका अर्थ है स्थानीय कोड ब्लॉक का अंत। कृपया ध्यान दें कि हमने घोषणा के बाद भी इंडेंट नहीं किया था। बस ले let ... in



जैसे कि यह एक बयान था।



अब, उपरोक्त स्थानीय नामित अभिव्यक्तियों के साथ सी में स्थानीय चर की तुलना करना हाथ की नींद का मामला है। हालांकि वे कुछ अलग हैं। C कोड में चर sum



स्टैक पर मेमोरी का उपयोग करती है। आप अपने इच्छित किसी भी मूल्य को आगे असाइन कर सकते हैं, या यहां तक ​​कि स्मृति पता प्राप्त कर सकते हैं जहां मूल्य संग्रहीत है। OCaml संस्करण के लिए, ऐसा नहीं है। इसमें, अभिव्यक्ति के लिए sum



केवल एक छोटा नाम है a +. b



a +. b



। किसी भी चीज़ sum



आवंटित करने का कोई तरीका नहीं है। (थोड़ी देर बाद हम दिखाएंगे कि कैसे चर बनाने के लिए जिसके लिए आप मूल्य बदल सकते हैं)।



यहाँ अंतिम स्पष्टीकरण के लिए एक और उदाहरण है। इन दो कोड स्निपेट को समान मान ((a + b) + (a + b) ² ) वापस करना चाहिए:

 लेट फेब =
   (a + b।) + है।  (a + b।) ** २।
   ;;

 लेट फेब =
   Let x = a +।  बी में
   x +।  x ** २।
   ;;

दूसरा संस्करण सिद्धांत रूप में तेज होना चाहिए (लेकिन अधिकांश संकलक आपके लिए "सामान्य सबटेक्शंस को नष्ट करने") नामक चरण को पूरा करने में सक्षम होंगे, और यह निश्चित रूप से पढ़ना आसान है। दूसरे उदाहरण में x



a +. b



लिए सिर्फ एक छोटा नाम है a +. b



a +. b



।

वैश्विक "चर" (वास्तव में वैश्विक अभिव्यक्ति)

आप शीर्ष स्तर पर विभिन्न चीजों के लिए वैश्विक नामों को भी परिभाषित कर सकते हैं, और ऊपर दिए गए स्थानीय "चर" की तरह, वे वास्तव में चर नहीं हैं, वे विभिन्न चीजों के लिए संक्षिप्त नाम हैं। यहाँ एक वास्तविक (थोड़ा छंटनी की गई) उदाहरण है:

 चलो html =
   कन्टैंट = read_whole_file फ़ाइल को अंदर जाने दें
   GHtml.html_from_string सामग्री
   ;;

 let menu_bold () =
   मैच bold_button # के साथ सक्रिय
     सच -> html # set_font_style ~ सक्षम: [`बॉल्ड] ()
   |  गलत -> html # set_font_style ~ अक्षम: [`BOLD] ()
   ;;

 आज्ञा देना मुख्य () =
   (* कोड छोड़ा गया *)
   factory # add_item "कट" ~ कुंजी: _X ~ कॉलबैक: html # कट
   ;;

यह वास्तविक कोड का एक टुकड़ा है। html



- एचटीएमएल संपादन विजेट (lablgtk लाइब्रेरी ऑब्जेक्ट) अभिव्यक्ति के कार्यक्रम के शुरुआत में बनाया गया है let html =



। फिर, आगे, इसका उपयोग कई कार्यों में किया जाता है।



कृपया ध्यान दें कि ऊपर दिए गए कोड स्निपेट में html



नाम को वास्तविक वैश्विक चर के रूप में नहीं लिया जाना चाहिए, जैसा कि C या अन्य अनिवार्य भाषाओं में है। " html



पॉइंटर" स्टोर करने के लिए कोई मेमोरी एलोकेशन नहीं है। उदाहरण के लिए, html



कुछ भी निर्दिष्ट करना असंभव है, इसे एक विजेट के रूप में एक संकेतक के रूप में फिर से परिभाषित करना है। अगले भाग में, हम उन संदर्भों पर चर्चा करेंगे जो वास्तविक चर हैं।

चलो बाध्यकारी

let ...



का कोई उपयोग let ...



, कोई फर्क नहीं पड़ता कि, शीर्ष स्तर पर (विश्व स्तर पर) या अंदर के कार्यों (स्थानीय रूप से) को अक्सर ले-बाइंडिंग (बाध्यकारी का उपयोग करते हुए) कहा जाता है।

संदर्भ: असली चर

लेकिन क्या होगा यदि आप एक वास्तविक चर चाहते हैं जिसका मूल्य आप असाइन कर सकते हैं और कार्यक्रम निष्पादन के दौरान बदल सकते हैं? इस मामले में, आपको लिंक का उपयोग करने की आवश्यकता है। लिंक सी / सी ++ में संकेत के समान हैं। जावा में, वस्तुओं को संग्रहीत करने वाले सभी चर वास्तव में वस्तुओं के संदर्भ (पॉइंटर्स) हैं। पर्ल में, लिंक लिंक हैं, जैसे ओकेम्ल में।



यहाँ हम OCaml में एक int



लिंक कैसे बनाते हैं:

 रेफ 0 ;;

वास्तव में, ऐसी अभिव्यक्ति बहुत उपयोगी नहीं है। हमने लिंक बनाया और क्योंकि हमने उसे कोई नाम नहीं दिया, कचरा संग्रहकर्ता ने वहीं आकर इसे एकत्र किया! (वास्तव में, सबसे अधिक संभावना है, इसे संकलन चरण पर फेंक दिया जाएगा)। आइए लिंक को एक नाम दें:

 let my_ref = ref 0 ;;

यह लिंक वर्तमान में एक पूरे शून्य को संग्रहीत करता है। आइए अब इसमें एक और मूल्य लिखते हैं (असाइनमेंट ऑपरेशन):

 my_ref: = 100 ;;

और देखते हैं कि अब लिंक क्या स्टोर करता है:

 #; my_ref ;;
 - - int = 100

तो, ऑपरेटर :=



लिंक :=



उपयोग करने के लिए उपयोग किया जाता है, और ऑपरेटर !



dereferences लिंक, वापसी सामग्री। यहाँ C / C ++ के साथ एक क्रूड लेकिन प्रभावी तुलना है:

OCaml	सी / सी ++
let my_ref = ref 0 ;; my_ref: = 100 ;; my_ref	int a = 0; int * my_ptr = & a; * my_ptr = 100; * my_ptr

लिंक का अपना दायरा है, लेकिन आप उन्हें अक्सर उपयोग नहीं करेंगे। आपके कार्यों में स्थानीय अभिव्यक्तियों के नाम के लिए let name=expression in



का अधिक सामान्य उपयोग है।

नेस्टेड कार्य

सी में नेस्टेड फ़ंक्शन की कोई अवधारणा नहीं है। जीसीसी सी कार्यक्रमों के लिए नेस्टेड कार्यों का समर्थन करता है, लेकिन मुझे एक भी कार्यक्रम की जानकारी नहीं है जो इस एक्सटेंशन का उपयोग करेगा। वैसे भी, यह gcc जानकारी पृष्ठ नेस्टेड फ़ंक्शन के बारे में लिखता है:

एक "नेस्टेड फ़ंक्शन" एक फ़ंक्शन है जिसे किसी अन्य फ़ंक्शन के अंदर परिभाषित किया गया है (नेस्टेड फ़ंक्शन GNU C ++ के लिए समर्थित नहीं हैं)। नेस्टेड फ़ंक्शन के नाम उस ब्लॉक के लिए स्थानीय हैं जिसमें उन्हें परिभाषित किया गया था। उदाहरण के लिए, यहां एक नेस्टेड फ़ंक्शन 'स्क्वायर' की परिभाषा है जिसे दो बार कहा जाता है:

 फू (डबल ए, डबल बी)
 {
   डबल वर्ग (डबल जेड) {रिटर्न जेड * जेड;  }

   वापसी वर्ग (ए) + वर्ग (बी);
 }

एक नेस्टेड फ़ंक्शन में बाहरी फ़ंक्शन के सभी फ़ंक्शन तक पहुंच होती है जो फ़ंक्शन परिभाषित होने के समय दिखाई देते हैं। यह तथाकथित "लेक्सिकल दृश्यता का क्षेत्र" है। यहां एक नेस्टेड फ़ंक्शन का एक उदाहरण है जो ऑफसेट नामक एक चर को विरासत में मिला है:

 बार (इंट * सरणी, इंट ऑफसेट, इंट आकार)
 {
   इंट एक्सेस (int * array, int index)
     {वापसी सरणी [सूचकांक + ऑफसेट];  }
   int i;
   / * ... * /
   के लिए (i = 0? मैं <आकार; मैं ++)
     / * ... * / पहुंच (सरणी, i) / * ... * /
 }

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

 let_whole_channel चान =
   चलो बफ़ = बफ़र.क्रिएट 4096 इन
   आज्ञा देना लूप () =
     let newline = input_line chan in
     बफ़र .add_string buf newline;
     बफ़र .add_char buf '\ n';
     पाश ()
   में
   कोशिश
     पाश ()
   साथ
     End_of_file -> बफ़र.कंटेंट्स buf ;;

यदि आप पूरे कोड को नहीं समझते हैं, तो इसमें बहुत सी अवधारणाएँ हैं, जिनके बारे में हमने अभी तक बात नहीं की है। इसके बजाय, केंद्रीय नेस्टेड loop



फ़ंक्शन पर ध्यान दें, जो टाइप unit



का एक तर्क लेता है। आप read_whole_channel फ़ंक्शन से loop ()



कॉल कर सकते हैं, लेकिन यह फ़ंक्शन के बाहर परिभाषित नहीं है। एक नेस्टेड फ़ंक्शन की मुख्य फ़ंक्शन में परिभाषित चर तक पहुंच होती है (इस तरह loop



को स्थानीय चर buf



और chan



तक पहुंच मिलती है)।



नेस्टेड फ़ंक्शन को परिभाषित करने के लिए फॉर्म एक स्थानीय नामित अभिव्यक्ति के कार्य के समान है: let name arguments = function-defenition in.







आमतौर पर, एक फ़ंक्शन परिभाषा एक नई लाइन पर इंडेंट की जाती है (जैसा कि ऊपर दिए गए उदाहरण में है)। और याद रखें कि यदि फ़ंक्शन पुनरावर्ती है (तो ऊपर दिए गए उदाहरण के रूप में) तो आपको let rec



का उपयोग करने की आवश्यकता है।

मॉड्यूल और open



कमांड

कई दिलचस्प मॉड्यूल (उपयोगी कोड के साथ पुस्तकालय) OCaml के साथ आपूर्ति की जाती है। उदाहरण के लिए, रेखांकन खींचने के लिए मानक पुस्तकालय हैं, विजेट्स के एक सेट का उपयोग करके GUI इंटरफेस बनाना, बड़ी संख्या में प्रोसेसिंग करना, डेटा स्ट्रक्चर्स और POSIX सिस्टम कॉल करना। ये पुस्तकालय / usr / lib / ocaml / VERSION (यूनिक्स पर) स्थित हैं। हमारे उदाहरणों के लिए, हम Graphics



नामक एक काफी सरल मॉड्यूल पर ध्यान केंद्रित करेंगे।



Graphics



मॉड्यूल में 5 फाइलें शामिल हैं (मेरे सिस्टम पर):

 /usr/lib/ocaml/3.08/graphics.a
 /usr/lib/ocaml/3.08/graphics.cma
 /usr/lib/ocaml/3.08/graphics.cmi
 /usr/lib/ocaml/3.08/graphics.cmxa
 /usr/lib/ocaml/3.08/graphics.mli

[लगभग। अनुवाद: लेकिन मेरे सिस्टम पर (डेबियन सिड) मॉड्यूल को सीधे / usr / lib / ocaml में डंप किया जाता है, बिना संस्करण को निर्दिष्ट किए]।



सबसे पहले, चलो graphics.mli



फ़ाइल पर ध्यान केंद्रित करें। यह एक टेक्स्ट फ़ाइल है, जिससे आप आसानी से इसकी सामग्री देख सकते हैं। सबसे पहले, ध्यान दें कि नाम Graphics.mli



, Graphics.mli



नहीं। OCaml हमेशा फ़ाइल नाम के पहले अक्षर को कैपिटल में रखता है जब यह मॉड्यूल पर आता है। यह बहुत भ्रामक हो सकता है, जब तक कि आपको इसके बारे में पहले से पता न हो।



यदि हम Graphics



में फ़ंक्शंस का उपयोग करना चाहते हैं, तो दो तरीके हैं। या हमारे कार्यक्रम की शुरुआत में, हम एक open Graphics;;



घोषणा लिखते हैं open Graphics;;



, या हम उपसर्ग के साथ संबंधित कार्यों के लिए सभी कॉल को पूरक करते हैं: Graphics.open_graph.open



। open



जावा में import



फ़ंक्शन जैसा दिखता है, और पर्ल में use



अभिव्यक्ति से थोड़ा अधिक (जैसा दिखता है)।



[विंडोज उपयोगकर्ताओं के लिए: विंडोज में अंतःक्रियात्मक रूप से काम करने के लिए इस उदाहरण के लिए, आपको एक अलग शीर्ष स्तर (toplevel) बनाने की आवश्यकता है। इस तरह एक कमांड लाइन से एक कमांड चलाएँ: ocamlmktop -o ocaml- ग्राफिक्स ग्राफिक्स।]



निम्नलिखित उदाहरणों के एक जोड़े को सब कुछ स्पष्ट करना चाहिए (ये दो उदाहरण अलग-अलग चीजें आकर्षित करते हैं - दोनों की कोशिश करें)। पहले उदाहरण को कॉल करें open_graph



, दूसरा कॉल Graphics.open_graph



। [लगभग। ट्रांस।: लेख की शुरुआत में कार्यक्रम क्या करते हैं के स्क्रीनशॉट हैं]।

 (* इस उदाहरण को संकलित करने के लिए: ocamlc graphics.cma grtest1.ml -o grtest1 *)

 ग्राफिक्स खोलें ;;

 ओपन_ग्राफ "640x480" ;;
 के लिए मैं = 12 डाउट 1 करते हैं
   आज्ञा देना त्रिज्या = मैं * 20 में
   set_color (यदि (i mod 2) = 0 तो लाल और पीला);
   fill_circle 320 240 त्रिज्या
 किया ;;
 read_line () ;;

---

 (* इस उदाहरण को संकलित करने के लिए: ocamlc graphics.cma grtest2.ml -o grtest2 *)

 रैंडम। स्वंय_नित () ;;
 ग्राफिक्स.ओपन_ग्राफ "640x480" ;;

 आइए पुन: इटर्रेट आर x_init i =
         अगर मैं = 1 तो x_init
         अन्यथा
                 let x = iterate r x_init (i-1) in
                 आर *।  x *।  (1.0 - एक्स) ;;

 x = 0 से 639 के लिए करें
         चलो r = 4.0 *।  (float_of_int x) /।  640.0 में
         i = 0 से 39 के लिए करें
                 आज्ञा देना x_init = random.float 1.0 इन
                 आज्ञा देना x_final = iterate r x_init 500 में
                 let y = int_of_float (x_final *। 480.) में
                 ग्राफिक्स। Xoty
         किया
 किया ;;

 read_line () ;;

दोनों उदाहरण भाषा की कुछ विशेषताओं का उपयोग करते हैं जिनके बारे में हमने अभी तक बात नहीं की है: लूप के for



जरूरी, if-then-else



ब्लॉक, पुनरावृत्ति। हम इस पर बाद में चर्चा करेंगे। इसके बावजूद, आप अभी भी कर सकते हैं: (1) यह समझने की कोशिश करें कि वे कैसे काम करते हैं (2) किस प्रकार का अनुमान आपको त्रुटियों को पकड़ने की अनुमति देता है।

Pervasives



मॉड्यूल

एक मॉड्यूल है जिसे "ओपन" होने की आवश्यकता नहीं है। यह Pervasives



मॉड्यूल (/usr/lib/ocaml/3.08/pervasives.mli [लगभग। अनुवाद में स्थित है। मेरे पास /usr/lib/ocaml/pervasives.mli है)। Pervasives



मॉड्यूल के सभी वर्ण स्वचालित रूप से सभी OCaml कार्यक्रमों में आयात किए जाते हैं।

मॉड्यूल का नाम बदलें

क्या होगा यदि आप Graphics



पात्रों का उपयोग करना चाहते हैं, लेकिन उन सभी को आयात नहीं करना चाहते हैं, और आप हर बार ग्राफिक्स प्रिंट करने के लिए आलसी हैं? बस इस तकनीक का उपयोग करके मॉड्यूल का नाम बदलें:

 मॉड्यूल जीआर = ग्राफिक्स ;;

 Gr.open_graph "640x480" ;;
 Gr.fill_circle 320 240 240 ;;
 read_line () ;;

वास्तव में, यह तकनीक बहुत उपयोगी है यदि आप एक नेस्टेड मॉड्यूल आयात करना चाहते हैं (मॉड्यूल एक दूसरे में नेस्टेड हो सकते हैं), लेकिन आप हर बार नेस्टेड मॉड्यूल के लिए मार्ग प्रिंट नहीं करना चाहते हैं।

कब उपयोग करें, और कब छोड़ें ;;



और ;

अब हम एक बहुत ही महत्वपूर्ण मुद्दे पर विचार करेंगे। कब उपयोग करें ;;



कब उपयोग करना है ;



, और आपको दोनों विकल्पों को कब छोड़ना चाहिए? यह ट्रिकी प्रश्न तब तक बना रहता है जब तक आप इसे अच्छी तरह से समझ नहीं लेते। वह एक लंबे समय और लेखक के लिए चिंतित थे, जबकि उन्होंने OCaml का अध्ययन किया था।



नियम संख्या 1 - आपको उपयोग करना चाहिए ;;



अपने कोड (शीर्ष-स्तर) के शीर्ष स्तर पर बयानों को अलग करने के लिए और फ़ंक्शन परिभाषा या अन्य प्रकार के बयानों के अंदर कभी नहीं ।



जब ग्राफिक्स के साथ दूसरे उदाहरण से टुकड़े पर एक नज़र डालें:

 रैंडम। स्वंय_नित () ;;
 ग्राफिक्स.ओपन_ग्राफ "640x480" ;;

 आइए पुन: इटर्रेट आर x_init i =
         अगर मैं = 1 तो x_init
         अन्यथा
                 let x = iterate r x_init (i-1) in
                 आर *।  x *।  (1.0 - एक्स) ;;

शीर्ष स्तर पर हमारे दो कथन हैं और iterate



फ़ंक्शन की परिभाषा। उनमें से प्रत्येक समाप्त होता है ;;



।



नियम संख्या 2 - कभी - कभी आप छोड़ सकते हैं ;;



। एक नवजात के रूप में, आपको विशेष रूप से इस नियम के बारे में नहीं सोचना चाहिए और हमेशा लिखना चाहिए ;;



नियम संख्या 1 द्वारा निर्धारित अनुसार। लेकिन यदि आप किसी और के कोड को पढ़ते हैं, तो आप कभी-कभी एक कमी का सामना करेंगे ;;



। स्थान छोड़ने के लिए ;;



:

• let
  
  
  
  कीवर्ड से पहले;
• कीवर्ड open
  
  
  
  से पहले;
• कीवर्ड type
  
  
  
  से पहले;
• फ़ाइल के बहुत अंत में
• कई अन्य (बहुत दुर्लभ) मामलों में, जहां OCaml "मान सकता है" कि अगला तत्व एक नए बयान की शुरुआत है, और वर्तमान की निरंतरता नहीं है।

यहाँ एक उदाहरण कोड है ;;



जहाँ भी संभव हो छोड़ा गया:

 खुला रैंडम (* ;; *)
 ग्राफिक्स खोलें ;;

 self_init () ;;
 open_graph "640x480" (* ;; *)

 आइए पुन: इटर्रेट आर x_init i =
         अगर मैं = 1 तो x_init
         अन्यथा
                 let x = iterate r x_init (i-1) in
                 आर *।  x *।  (1.0 - एक्स) ;;

 x = 0 से 639 के लिए करें
         चलो r = 4.0 *।  (float_of_int x) /।  640.0 में
         i = 0 से 39 के लिए करें
                 आज्ञा देना x_init = random.float 1.0 इन
                 आज्ञा देना x_final = iterate r x_init 500 में
                 let y = int_of_float (x_final *। 480.) में
                 ग्राफिक्स। Xoty
         किया
 किया ;;

 read_line () (*; * *)

नियम नंबर 3 और नंबर 4 पर लागू होता है ;



। वे नियमों के लिए पूरी तरह से अलग हैं ;;



। एक एकल अर्धविराम (;) को अनुक्रम बिंदु [लगभग] कहा जाता है । अनुवाद: मुझे अनुक्रम बिंदु के अनुवाद के साथ गलत किया जा सकता है], जो सी, सी ++, जावा या पर्ल में एक एकल अर्धविराम के समान भूमिका निभाता है। इसका मतलब है "इस जगह के बाद सब कुछ करें जब आप इसके पहले सब कुछ करते हैं।" शर्त है कि तुम नहीं जानते थे



नियम नंबर 3: let ... in



बयान में कभी भी let ... in



पर विचार करें ;



उसके बाद।



नियम संख्या 4: कोड ब्लॉक में अन्य सभी बयानों को पूरा करें ;



बहुत अंतिम को छोड़कर ।



ऊपर लूप के लिए आंतरिक एक अच्छा उदाहरण है। कृपया ध्यान दें कि हमने कभी एक का उपयोग नहीं किया है ;



कोड में।

         i = 0 से 39 के लिए करें
                 आज्ञा देना x_init = random.float 1.0 इन
                 आज्ञा देना x_final = iterate r x_init 500 में
                 let y = int_of_float (x_final *। 480.) में
                 ग्राफिक्स। Xoty
         किया

एकमात्र स्थान जहां उपयोग संभव है ;



- यह लाइन Graphics.plot xy



, लेकिन चूंकि यह ब्लॉक नंबर की आखिरी लाइन है, नियम नंबर 4 के अनुसार, आपको इसे लगाने की आवश्यकता नहीं है।

"के बारे में एक नोट?"

ब्रायन हार्ट ने मुझे सही किया:

;



- एक ही ऑपरेटर के रूप में, उदाहरण के लिए, अतिरिक्त ऑपरेटर ( +



)। खैर, काफी + पसंद नहीं है, लेकिन वास्तव में - बिल्कुल उसी तरह। + प्रकार का है int -> int -> int



- यह दो पूर्णांक लेता है और एक पूर्णांक (उनकी राशि) लौटाता है। ;



टाइप unit -> 'b -> 'b



- यह दो अवधारणा लेता है और बस दूसरा लौटाता है। सी। में अल्पविराम के विपरीत। आप a;b;c;d



लिख सकते हैं जितना आसान आप a + b + c + d



लिख सकते हैं।



यह उन मूलभूत अवधारणाओं में से एक है, जिसकी समझ भाषा की समझ देती है, लेकिन जो वास्तव में कभी भी ज़ोर से नहीं बोली जाती है - ओकेमेल में शाब्दिक रूप से सब कुछ एक अभिव्यक्ति है। if/then/else



एक अभिव्यक्ति है। a;b



एक अभिव्यक्ति है। match foo with ...



एक अभिव्यक्ति है। नीचे दिया गया कोड पूरी तरह से सही है (और वे सभी एक ही काम करते हैं):

  आज्ञा देना fxby = अगर b तो x + y और x + 0
 
  आज्ञा देना fxby = x + (यदि बी तो y और 0)
 
  fxby = x + (मैच बी के साथ सच -> y | गलत -> 0)
 
  fxby = x + (gz = function true -> z | false -> 0 को gyb में जाने दें)
 
  आज्ञा देना fxby = x + (let _ = y + 3 in (); यदि b तो y और 0)

उत्तरार्द्ध पर करीब से नज़र डालें - मैं उपयोग करता हूं ;



दो बयानों के संयोजन के लिए एक ऑपरेटर के रूप में। OCaml में सभी कार्यों के रूप में व्यक्त किया जा सकता है:

  नाम [पैरामीटर] = अभिव्यक्ति

OCaml में "अभिव्यक्ति" की परिभाषा सी की तुलना में कुछ व्यापक है। वास्तव में, C में "कथनों" की अवधारणा है, लेकिन C में सभी कथन OCaml (संयुक्त) में सिर्फ अभिव्यक्ति हैं।



के बीच एकमात्र अंतर ;



और +



एक फ़ंक्शन के रूप में +



को संदर्भित करने की क्षमता है। उदाहरण के लिए, मैं पूर्णांक सूची के रूप में sum_list



फ़ंक्शन को इस sum_list



परिभाषित कर सकता हूं:

 आज्ञा देना sum_list = List.fold_left (+) 0

सभी एक साथ: कुछ वास्तविक कोड

इस खंड में, हम labgtk 1.2 पुस्तकालय से वास्तविक कोड के कुछ टुकड़े दिखाएंगे (Labgtk देशी Unix विगेट्स के लिए OCaml में इंटरफ़ेस है)। चेतावनी: यह कोड उन चीजों से भरा है जिनके बारे में हमने अभी तक बात नहीं की है। विवरणों में मत जाओ, कोड की सामान्य संरचना के बजाय, उन जगहों पर देखें जहां लेखक उपयोग करते थे ;;



जहाँ उन्होंने इस्तेमाल किया ;



जहाँ उन्होंने open



प्रयोग किया, उन्होंने कैसे पाठ को हराया, कैसे उन्होंने स्थानीय और वैश्विक भावों का उपयोग किया।



... हालाँकि, मैं आपको कुछ सुझाव दूंगा ताकि सभी खो न जाएं।

• ?foo
  
  
  
  और ~foo
  
  
  
  OCaml में वैकल्पिक और नामित फ़ंक्शन तर्कों को निर्दिष्ट करने के तरीके हैं। सी-लाइक भाषाओं के साथ एक सीधा समानांतर खींचना संभव नहीं होगा, लेकिन पर्ल, पायथन और स्मॉलटाक की यह अवधारणा है। किसी फ़ंक्शन को कॉल करते समय आप तर्कों को नाम दे सकते हैं, उनमें से कुछ को छोड़ सकते हैं और बाकी को उस क्रम में पारित कर सकते हैं जो आपको सूट करता है।
• foo#bar
  
  
  
  - एक विधि कॉल (एक विधि कॉल जिसे foo
  
  
  
  नामक वस्तु के संबंध में bar
  
  
  
  कहा जाता है)। यह foo->bar
  
  
  
  , foo.bar
  
  
  
  , $foo->bar
  
  
  
  (C ++, Java, Perl) के समान है।

पहला टुकड़ा: प्रोग्रामर मानक पुस्तकालयों का एक बंडल खोलता है (छोड़ रहा है ;;



क्योंकि निम्नलिखित कीवर्ड खुले हैं या जाने हैं)। यह file_dialog नामक एक फ़ंक्शन भी बनाता है। इस फ़ंक्शन के अंदर, यह दो-लाइन स्टेटमेंट let sel = .. in



का उपयोग करके sel



नामक एक नामित अभिव्यक्ति को परिभाषित करता let sel = .. in



। वह तो sel के बारे में कई तरीके कहता है।

 (* पहला स्निपेट *)
 खुला डंडा
 GMain खोलें

 file_dialog ~ title ~ callback? filename () = दें
   Let sel =
     GWindow.file_selection ~ शीर्षक ~ modal: true
   sel # Cancel_button # कनेक्ट # क्लिक किया हुआ ~ कॉलबैक: sel # नष्ट;
   sel # ok_button # कनेक्ट # क्लिक किया हुआ ~ कॉलबैक: do_ok;
   sel # शो ()

दूसरा टुकड़ा: शीर्ष स्तर पर वैश्विक नामों की बस एक बड़ी सूची। कृपया ध्यान दें कि लेखक ने सब कुछ छोड़ दिया ;;



नियम संख्या 2 के अनुसार।

 (* दूसरा स्निपेट *)

 चलो खिड़की = GWindow.window ~ चौड़ाई: 500 ~ ऊंचाई: 300 ~ शीर्षक: "संपादक" ()
 चलो vbox = GPack.vbox ~ पैकिंग: विंडो # जोड़ें ()

 मेनूबार = GMenu.menu_bar ~ पैकिंग: vbox # पैक ()
 चलो कारखाने = नई GMenu.fact मेनूबार
 let acceler_group = factory # acceler_group
 चलो file_menu = factory # add_submenu "फ़ाइल"
 edit_menu = factory # add_submenu "संपादित करें"

 hbox = GPack.hbox ~ पैकिंग: vbox # जोड़ें ()
 संपादक को दें = नया संपादक ~ पैकिंग: hbox # जोड़ें ()
 स्क्रोलबार = GRange.scrollbar `VERTICAL ~ पैकिंग: hbox # पैक ()

तीसरा टुकड़ा: लेखक GdkKesyms



मॉड्यूल से सभी प्रतीकों को आयात करता है। इसके बाद असामान्य ले let-binding



आती है। let _ = expression



अर्थ है " let _ = expression



के मूल्य की गणना (सभी दुष्प्रभावों के निष्पादन सहित), लेकिन परिणाम को बाहर फेंकें"। इस मामले में, "अभिव्यक्ति के मूल्य की गणना करें" का अर्थ है Main.main ()



का निष्पादन, जो कि मुख्य GTK चक्र है, जिसका दुष्प्रभाव स्क्रीन पर एक खिड़की की उपस्थिति और संपूर्ण एप्लिकेशन का निष्पादन है। Main.main ()



कॉल करने का "परिणाम" महत्वपूर्ण Main.main ()



है। सबसे अधिक संभावना यह unit



, लेकिन मैंने जांच नहीं की - और यह निश्चित रूप से आवेदन पूरा होने तक वापस नहीं आता है।



ध्यान दें कि इस टुकड़े में लंबी श्रृंखलाएं हैं, वास्तव में, प्रक्रियात्मक आदेश। यह एक वास्तविक क्लासिक अनिवार्य कार्यक्रम है।

 (* तीसरा स्निपेट *)

 GdkKeysyms खोलें

 चलो _ =
   खिड़की # कनेक्ट # नष्ट ~ कॉलबैक: Main.quit;
   चलो कारखाने = नई GMenu.factory फ़ाइल_मेनू ~ acceler_group में
   factory # add_item "ओपन ..." ~ कुंजी: _O ~ कॉलबैक: संपादक # ओपन_फाइल;
   factory # add_item "सहेजें" ~ कुंजी: _S ~ कॉलबैक: संपादक # save_file;
   factory # add_item "इस रूप में सहेजें ..." कॉलबैक: संपादक # save_dialog;
   कारखाना # add_separator ();
   factory # add_item "छोड़ो" ~ कुंजी: _Q ~ कॉलबैक: विंडो # नष्ट;
   चलो कारखाना = नया GMenu.factory edit_menu ~ acceler_group में
   factory # add_item "कॉपी" ~ कुंजी: _C ~ कॉलबैक: संपादक # पाठ # copy_clipboard;
   factory # add_item "कट" ~ कुंजी: _X ~ कॉलबैक: संपादक # पाठ # कट_क्लिपबोर्ड;
   factory # add_item "पेस्ट" ~ कुंजी: _V ~ कॉलबैक: संपादक # पाठ # पेस्ट_क्लिपबोर्ड;
   कारखाना # add_separator ();
   factory # add_check_item "वर्ड रैप" ~ सक्रिय: गलत
     ~ कॉलबैक: संपादक # पाठ # set_word_wrap;
   factory # add_check_item "केवल पढ़ें" ~ सक्रिय: गलत
     ~ कॉलबैक: (फन बी -> एडिटर # टेक्स्ट # सेट_एडिटेबल (बी नहीं));
   window # add_accel_group acceler_group;
   संपादक # पाठ # घटना # कनेक्ट # बटन_प्रेस
     ~ कॉलबैक: (मजेदार ईव ->
       let बटन = GdkEvent.Button.button ev में
       यदि बटन = 3 तो शुरू करें
         file_menu # popup ~ बटन ~ समय: (GdkEvent.Button.time ev);  सच
       अंत में गलत);
   संपादक # पाठ # set_vadjustment स्क्रॉलबार # समायोजन;
   खिड़की # शो ();
   Main.main ()

[लगभग। ट्रांस।: यदि कोई त्रुटियां देखता है या फिर से लिखता है, सही लिखता है]