OCaml का परिचय: डेटा प्रकार और मानचित्रण [3]

[लगभग। प्रति: अनुवाद जारी रखा। पहला भाग , दूसरा भाग ]

लिंक की गई सूची

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

 [1;  2;  3]

नोट: अर्धविराम, अल्पविराम नहीं।



[]



अर्थ है एक खाली सूची।



सूची में एक सिर (पहला तत्व) और एक पूंछ (सिर को छोड़कर अन्य तत्व) हैं। सिर एक तत्व है। पूंछ एक सूची है। उपरोक्त उदाहरण में, सिर पूर्णांक 1 है, और पूंछ सूची [2; 3]



[2; 3]



।



लेखन का एक वैकल्पिक रूप है निर्माण ऑपरेटर (विपक्ष) का उपयोग फॉर्म head :: tail



। नीचे की पंक्तियाँ एक दूसरे के समतुल्य हैं।

 [1;  2;  3]
 1 :: [2;  3]
 1 :: 2 :: [3]
 1 :: 2 :: 3 :: []

हमने निर्माण ऑपरेटर का उल्लेख क्यों किया? यह उपयोगी है जब हम सूचियों के लिए पैटर्न मिलान शुरू करते हैं, तो हम इस पर थोड़ा बाद में चर्चा करेंगे।

लिंक्ड सूची डेटा प्रकार

पूर्णांक की लिंक की गई सूची के लिए डेटा प्रकार int list



; प्रकार foo



की वस्तुओं की लिंक की गई सूची के लिए सामान्य प्रकार foo list



होगी।



इसका मतलब है कि सभी सूची आइटम एक ही प्रकार के होने चाहिए। लेकिन हम बहुरूपियों की सूची (उदाहरण के लिए, 'a list



) का उपयोग कर सकते हैं, जो सामान्य कार्यों को लिखते समय बहुत उपयोगी होते हैं जो "किसी चीज़ की सूची" के साथ काम करते हैं। (ध्यान दें, 'a list



मतलब यह नहीं है कि 'a list



के तत्व अलग-अलग प्रकार के हो सकते हैं, आप अभी भी नहीं कर सकते हैं। उदाहरण के लिए, पूर्णांकों और तारों के मिश्रण से एक सूची बनाएं। इस प्रकार के लेखन का अर्थ है "किसी भी प्रकार के तत्वों की एक सूची, लेकिन एक। उसी प्रकार ")।



एक अच्छा उदाहरण List



मॉड्यूल में परिभाषित length



फ़ंक्शन है। इससे कोई फर्क नहीं पड़ता कि सूची में पूर्णांक, या तार, या ऑब्जेक्ट या छोटे प्यारे जानवर शामिल हैं, List.length



फ़ंक्शन का उपयोग किसी भी प्रकार की सूची के लिए किया जा सकता है। इस प्रकार टाइप करें। List.lenght



:

 List.length: 'एक सूची -> इंट

संरचना

C और C ++ में struct



की अवधारणा है (संरचना के लिए संक्षिप्त)। जावा में कक्षाएं हैं जो समान तरीके से उपयोग की जा सकती हैं, हालांकि उनका उपयोग करने के लिए अधिक श्रमसाध्य काम की आवश्यकता होती है।



सी में एक सरल संरचना पर एक नज़र डालें:

 संरचना जोड़ी_ऑफ_ चिह्न {
   int a, b;
 };

OCaml में सबसे सरल समकक्ष एक ट्यूपल (टूपल) है, जैसे (3,4)



, जिसमें टाइप int * int



। सूचियों के विपरीत, टुपल्स में विभिन्न प्रकार के तत्व हो सकते हैं, इसलिए, उदाहरण के लिए, (3, "हेलो", 'x') टाइप int * string * char



।



सी की संरचना का थोड़ा अधिक जटिल कार्यान्वयन एक रिकॉर्ड का उपयोग करना होगा। सी संरचनाओं की तरह रिकॉर्ड, आपको नामित तत्वों का उपयोग करने की अनुमति देता है। टुपल्स में तत्वों का नाम नहीं है, लेकिन बदले में उस क्रम को संग्रहीत करते हैं जिसमें तत्व टपल में दिखाई देते हैं। यहां अभिलेखों का उपयोग करते हुए C संरचना के बराबर है:

 प्रकार pair_of_ints = {a: int;  b: int} ;;

उपरोक्त पंक्ति प्रकार को परिभाषित करती है, और नीचे हम वास्तव में इस प्रकार की एक वस्तु बनाते हैं :

 {a = 3;  b = 5}

ध्यान दें कि हमने टाइप परिभाषा में ":" का उपयोग किया है और दिए गए प्रकार का ऑब्जेक्ट बनाते समय "="।



यहाँ कुछ शीर्ष-स्तरीय उदाहरण दिए गए हैं (toplevel):

 # टाइप करें pair_of_ints = {a: int;  b: int} ;;
 प्रकार pair_of_ints = {a: int;  बी: इंट;  }
 {{a = 3;  b = 5} ;;
 - - pair_of_ints = {a = 3;  b = 5}
 {{a = 3} ;;
 कुछ रिकॉर्ड फ़ील्ड लेबल अपरिभाषित हैं: बी

OCaml प्रविष्टियों को अपरिभाषित छोड़ने पर रोक लगाता है।

विकल्प (योग्य संघों और स्थानान्तरण)

"योग्य यूनियन" ऑब्जेक्ट प्रकार सी में मौजूद नहीं है, हालांकि gcc को इसके लिए कुछ समर्थन है। यहाँ इस बात का उदाहरण दिया गया है कि योग्य C कितनी बार लागू किया गया है:

 संरचना फू {
   int प्रकार;
 #define TYPE_INT १
 #define TYPE_PAIR_OF_INTS 2
 #define TYPE_STRING 3
   संघ {
     int i;  // यदि टाइप करें == TYPE_INT।
     int जोड़ी [2];  // अगर टाइप करें == TYPE_PAIR_OF_INTS।
     चार * str;  // अगर टाइप करें == TYPE_STRING
   };
 };

जैसा कि आप देख सकते हैं, यह बहुत सुखद दृश्य नहीं है। और सामान्य तौर पर, यह बहुत सुरक्षित नहीं है: एक प्रोग्रामर उस समय ui



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



फ़ील्ड का मान सेट करना भूल सकता है, जिससे बग के साथ सभी प्रकार के मज़े और गेम होंगे। हाँ, और यह सब बोझिल है।



यहाँ OCaml पर एक सुरुचिपूर्ण और कॉम्पैक्ट संस्करण है:

 type foo = कुछ नहीं |  इंट का इंट |  जोड़ी की int * int |  स्ट्रिंग का स्ट्रिंग ;;

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



द्वारा पीछा किया जाता of part



, जहां type



हमेशा लोअरकेस अक्षर से शुरू होता है। ऊपर दिए गए उदाहरण में, Nothing



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



एक वास्तविक निर्माण के लिए , निम्नलिखित लिखा है:

 कुछ नहीं
 इंट ३
 जोड़ी (4, 5)
 स्ट्रिंग "हैलो"
      और सी।

उपरोक्त उदाहरण में प्रत्येक अभिव्यक्ति प्रकार foo



।



नोट: of



उपयोग एक प्रकार को परिभाषित करने में किया जाता है, लेकिन किसी प्रकार के तत्वों को बनाने में नहीं।



जारी है। एक साधारण सी लिस्टिंग के रूप में परिभाषित किया गया है

 enum साइन {सकारात्मक, शून्य, नकारात्मक};

इसे OCaml पर निम्न प्रकार से भी लिखा जा सकता है:

 टाइप साइन = सकारात्मक |  शून्य |  नकारात्मक ;;

पुनरावर्ती विकल्प (पेड़ों के लिए)

विकल्प पुनरावर्ती हो सकते हैं। बहुधा इसका उपयोग वृक्ष संरचनाओं को परिभाषित करने के लिए किया जाता है। यह वह जगह है जहाँ कार्यात्मक भाषाओं की स्पष्टता दिखाई देती है:

 type Binary_tree = int का पत्ता |  बाइनरी_ट्री * बाइनरी_ट्री का पेड़ ;;

यहाँ कुछ बाइनरी ट्री हैं। अभ्यास के लिए, उन्हें कागज पर खींचने का प्रयास करें:

 पत्ती ३
 वृक्ष (पत्ती 3, पत्ती 4)
 ट्री (पेड़ (पत्ती 3, पत्ती 4), पत्ती 5)
 ट्री (ट्री (लीफ 3, लीफ 4), ट्री (ट्री (लीफ 3, लीफ 4), लीफ 5)

पैरामीटर विकल्प

ऊपर दिए गए उदाहरणों में बाइनरी ट्री प्रत्येक शीट में एक पूर्णांक संग्रहीत करता है। लेकिन क्या होगा अगर हम एक द्विआधारी पेड़ के आकार का वर्णन करना चाहते हैं, और हम बाद में पत्तियों के लिए क्या संचय करना चाहते हैं? हम इसे पैरामीटराइज्ड (पॉलिमॉर्फिक) विकल्पों का उपयोग करके कर सकते हैं, कुछ इस तरह से:

 टाइप करें 'a Binary_tree = लीफ ऑफ' a |  बाइनरी_ट्री * का पेड़ एक बाइनरी_ट्री ;;

यह एक सामान्य प्रकार है। प्रत्येक शीट में पूर्णांक को स्टोर करने वाले सटीक प्रकार को int binary_tree



कहा जाता है। इसी प्रकार, प्रत्येक शीट में स्ट्रिंग्स को स्टोर करने वाले सटीक प्रकार को string binary_tree



कहा जाता है। निम्नलिखित उदाहरण में, हम शीर्ष स्तर पर कुछ उदाहरणों के प्रकारों को निर्धारित करेंगे और टाइपिंग सिस्टम को हमारे लिए उनके प्रकार दिखाते हैं:

 # पत्ती "हैलो" ;;
 - - स्ट्रिंग बाइनरी_ट्री = लीफ "हेल्लो"
 # पत्ती 3.0 ;;
 - - फ्लोट बाइनरी_ट्री = लीफ 3।

ध्यान दें कि प्रकार नाम रिवर्स ऑर्डर में लिखा गया है। सूची के प्रकार नाम के लिए इसकी तुलना करें, उदाहरण के लिए, int list



।



वास्तव में, यह कोई संयोग नहीं है कि a' list



भी उसी में लिखी गई है" रिवर्स ऑर्डर में। सूचियाँ इस (थोड़े अजीब) परिभाषा के साथ सिर्फ पैरामीटरयुक्त विकल्प हैं:

  टाइप 'ए लिस्ट = [] |  :: 'a *' एक सूची (* यह वास्तविक OCaml * कोड नहीं है)

हालांकि यह पूर्ण परिभाषा नहीं है। यहाँ एक और अधिक सटीक परिभाषा है:

 # टाइप 'ए लिस्ट = निल |  :: 'ए *' की एक सूची ;;
 type 'a list = Nil |  :: 'a *' की सूची
 # नील ;;
 -: 'एक सूची = शून्य
 # 1 :: शून्य ;;
 - - int सूची = :: (1, शून्य)
 # 1 :: 2 :: शून्य ;;
 - - int सूची = :: (1, :: (2, निल))

स्मरण करो कि हमने पहले कहा था - सूचियों को दो तरीकों से लिखा जा सकता है: या तो थोड़ी मात्रा में वाक्यगत शर्करा [1; 2; 3]



[1; 2; 3]



[1; 2; 3]



, या अधिक औपचारिक रूप से, 1 :: 2 :: 3 :: []



। यदि हम ऊपर a' list



की परिभाषा देखते हैं, तो हम औपचारिक प्रविष्टि का स्पष्टीकरण देखेंगे।

सूची, संरचना, विकल्प - परिणाम

OCaml में नाम	उदाहरण प्रकार परिभाषा	उदाहरण का उपयोग करना
सूची	int सूची	[1; 2; 3]
टपल	int * स्ट्रिंग	(3, "हैलो")
अभिलेख	प्रकार जोड़ी = {a: int; b: string}	{a = 3; b = "हैलो"}
प्रकार	type foo = इंट ऑफ़ इंट | इंट * स्ट्रिंग की जोड़ी	इंट ३
प्रकार	टाइप साइन = सकारात्मक | शून्य | नकारात्मक	सकारात्मक शून्य
पैरामिट्रीकृत प्रकार	टाइप करें 'a__list = खाली | A a * ’का my_list	विपक्ष (1, विपक्ष (2, खाली))

पैटर्न मिलान (डेटा प्रकारों के लिए)

कार्यात्मक प्रोग्रामिंग भाषाओं की वास्तव में बढ़िया विशेषताओं में से एक संरचनाओं को पार्स करने और डेटा के लिए पैटर्न मिलान करने की क्षमता है। यह काफी "कार्यात्मक" विशेषता नहीं है - हम सी में भिन्नता के कुछ समानता की कल्पना कर सकते हैं, जो हमें ऐसा करने की अनुमति देगा, लेकिन किसी भी मामले में, यह एक अच्छा फीचर है।



आइए एक वास्तविक प्रोग्रामिंग कार्य के साथ शुरू करें: मैं गणितीय अभिव्यक्ति जैसे n * (x + y) के लिए एक लेखन उपकरण रखना चाहता हूं और ऊपर की अभिव्यक्ति से n * x + n * y प्राप्त करने के लिए प्रतीकात्मक गुणन करता हूं।



आइए इन अभिव्यक्तियों के प्रकार को परिभाषित करें:

 expr = expr का प्लस * expr (* का अर्थ है a + b *)
           |  Expr का विस्तार * expr (* का अर्थ है - b *)
           |  Expr का समय * expr (* का अर्थ है * b *)
	   |  Expr * expr का विभाजन (* का अर्थ है a / b *)
           |  स्ट्रिंग का मूल्य (* "x", "y", "n", आदि *)
	   ;;

प्रपत्र n * (x + y) की अभिव्यक्ति इस प्रकार लिखी जा सकती है:

 टाइम्स (मान "n", प्लस (मान "x", मान "y"))

अब एक फ़ंक्शन लिखते हैं जो आउटपुट (Value "n", Plus (Value "x", Value "y"))



n * (x+y)



समान कुछ और के समान होगा। ऐसा करने के लिए, हम दो फ़ंक्शन लिखेंगे, जिनमें से एक अभिव्यक्ति को एक सुंदर स्ट्रिंग में परिवर्तित करता है और एक जो इसे प्रदर्शित करता है (अलगाव का कारण यह है कि शायद मुझे फ़ाइल को एक ही पंक्ति लिखने की आवश्यकता होगी और मैं इसके लिए पूरे फ़ंक्शन को दोहराना नहीं चाहता हूं)।

 आइए rec_string ई = पर
   मैच ई के साथ
     प्लस (बाएं, दाएं) -> "(" ^ (to_string बाएं) ^ "+" ^ (in_string दाएं) ^ ")"
   |  माइनस (बाएँ, दाएँ) -> "(" ^ (to_string बाएँ) ^ "-" ^ (to_string दाएँ) ^ ")" "
   |  टाइम्स (बाएं, दाएं) -> "(" ^ (to_string बाएं) ^ "*" ^ (in_string दाएं) ^ ")"
   |  विभाजित करें (बाएं, दाएं) -> "(" ^ (to_string बाएं) ^ "/" ^ (to_string दाएं) ^ ")"
   |  मान v -> v
   ;;

 आज्ञा देना Print_expr e =
   Print_endline (to_string e) ;;

(नोट: ^



ऑपरेटर का उपयोग तारों को समतल करने के लिए किया जाता है)



लेकिन काम में स्क्रीन आउटपुट फ़ंक्शन:

 # Print_expr (टाइम्स (मान "n", प्लस (मूल्य "x", मूल्य "y"))) ;;
 (n * (x + y))

पैटर्न मिलान के लिए सामान्य रूप:

 के साथ मैच वस्तु
   पैटर्न -> परिणाम
 |  पैटर्न -> परिणाम
     ...

पैटर्न मिलान के बाईं ओर संलग्नक के साथ सरल (जैसा कि ऊपर उदाहरण में to_string



के मामले में), या जटिल हो सकता है। निम्नलिखित उदाहरण फार्म n * (x + y)



या प्रपत्र (x + y) * n



में अभिव्यक्ति को गुणा करने के लिए हमारा कार्य है। इसके लिए हम नेस्टेड नमूनों का उपयोग करेंगे:

 recly_out को e = में पुन: दर्ज करें
   मैच ई के साथ
     टाइम्स (ई 1, प्लस (ई 2, ई 3)) ->
       प्लस (टाइम्स (multiply_out e1, multiply_out e2),
             टाइम्स (multiply_out e1, multiply_out e3))
   |  टाइम्स (प्लस (ई 1, ई 2), ई 3) ->
       प्लस (टाइम्स (multiply_out e1, multiply_out e3),)
             टाइम्स (multiply_out e2, multiply_out e3))
   |  प्लस (बाएं, दाएं) -> प्लस (बाएं से गुणा करें, गुणा करें)
   |  माइनस (बाएं, दाएं) -> माइनस (बाएं से गुणा), दाएं से गुणा करें (दाएं से)
   |  टाइम्स (बाएं, दाएं) -> टाइम्स (बाएं से गुणा), दाएं से गुणा करें (दाएं से)
   |  विभाजित करें (बाएं, दाएं) -> विभाजित करें (बाएं से गुणा करें, दाएं से गुणा करें)
   |  मान v -> मान v
   ;;

यहाँ यह काम में है:

 # Print_expr (multiply_out (टाइम्स (मान "n"), प्लस (मान "x", मूल्य "y"))) ;;;
 ((n * x) + (n * y)

multiply_out



कैसे काम करता है? मुख्य बिंदु पहले दो नमूने हैं। पहला नमूना Time (e1, Plus (e2, e3))



, जो कि फॉर्म e1 * (e2 + e3)



भावों की तुलना करता है। अब नमूने के साथ पहली तुलना के दाईं ओर एक नज़र डालें और सुनिश्चित करें कि यह समकक्ष (e1 * e2) + (e1 * e3)



।



दूसरा पैटर्न वही करता है, जो फॉर्म के भाव (e1 + e2) * e3



के उपयोग को छोड़कर है।



शेष नमूने अभिव्यक्ति को नहीं बदलते हैं, लेकिन, संक्षेप में, वे पुन: अवमानक रूप से subexpressions पर multiply_out



कहते हैं। यह सुनिश्चित करता है कि सभी सबएक्सप्रेस कई गुना हैं (यदि आप किसी अभिव्यक्ति के केवल शीर्ष स्तर को गुणा करना चाहते हैं, तो आपको सभी शेष पैटर्न को सरल नियम e -> e



) से बदलना चाहिए।



क्या हम इसके विपरीत कर सकते हैं? (सबएक्सप्रेस के सामान्य भाग का फैक्टराइजेशन?) बेशक! (हालांकि यह थोड़ा अधिक जटिल है)। नीचे दिया गया संस्करण केवल शीर्ष स्तर के भावों के लिए काम करता है। बेशक, आप अभिव्यक्ति के सभी स्तरों के लिए इसका विस्तार कर सकते हैं (और अधिक जटिल मामलों के लिए):

 आज्ञा देना =
   मैच ई के साथ
     प्लस (टाइम्स (e1, e2), टाइम्स (e3, e4)) जब e1 = e3 -> टाइम्स (e1, प्लस (e2, e4))
   |  प्लस (टाइम्स (ई 1, ई 2), टाइम्स (ई 3, ई 4)) जब ई 2 = ई 4 -> टाइम्स (प्लस (ई 1, ई 3), ई 4)
   |  ई -> ई
   ;;

 # फैक्टराइज़ (प्लस (टाइम्स (मान "एन"), वैल्यू "एक्स"), टाइम्स (वैल्यू "एन", वैल्यू "वाई"))) ;;
 - - expr = Times (मान "n", प्लस (मान "x", मान "y"))

फैक्टराइजेशन फ़ंक्शन हमें भाषा की कुछ और विशेषताएं दिखाता है। आप प्रत्येक पैटर्न मैच में संरक्षक जोड़ सकते हैं। एक रक्षक एक शर्त है जो एक मैच के बाद है। पैटर्न मिलान केवल तभी काम करता है जब कोई पैटर्न मैच हो और संतुष्ट when



स्थिति।

 के साथ मैच वस्तु
   पैटर्न [जब हालत] -> परिणाम
   पैटर्न [जब हालत] -> परिणाम
     ...

भाषा की दूसरी विशेषता =



ऑपरेटर है, जो अभिव्यक्ति के बीच "संरचनात्मक पत्राचार" की जांच करता है। इसका मतलब है कि यह प्रत्येक अभिव्यक्ति में पुनरावर्ती रूप से जाता है और सभी स्तरों के अनुसार उन्हें जांचता है।



OCaml संकलन समय पर सत्यापित कर सकता है कि आपने अपने टेम्पलेट में सभी संभावित मामलों को कवर किया है। मैंने Product



प्रकार को उसमें जोड़कर expr



प्रकार की परिभाषा को बदल दिया है:

 expr = expr का प्लस * expr (* का अर्थ है a + b *)
           |  Expr का विस्तार * expr (* का अर्थ है - b *)
           |  Expr का समय * expr (* का अर्थ है * b *)
	   |  Expr * expr का विभाजन (* का अर्थ है a / b *)
	   |  एक्सप्रे लिस्ट के उत्पाद (* का अर्थ है * बी * सी * ... *)
           |  स्ट्रिंग का मूल्य (* "x", "y", "n", आदि *)
	   ;;

फिर मैंने इसे जोड़ने के बिना to_string फ़ंक्शन को कॉपी करने का प्रयास किया। OCaml ने निम्नलिखित चेतावनी जारी की:

 चेतावनी: यह पैटर्न-मिलान संपूर्ण नहीं है।
 यहां एक ऐसे मूल्य का उदाहरण दिया गया है जो मेल नहीं खाता है:
 उत्पाद _