(अनुवादक से प्रस्तावना: मैं ओकामल सीखने के लिए बैठ गया, पाया कि रूसी में शुरुआती गाइड का कोई अनुवाद नहीं है। मैं इस अंतर को भरता हूं)।

मूल बातें

टिप्पणियाँ

OCaml में टिप्पणियाँ पात्रों (* और *) द्वारा इंगित की जाती हैं, कुछ इस तरह हैं:
(* *)

 (* यह एक टिप्पणी है
    द्वारा कई
    लाइनों।
 *)

दूसरे शब्दों में, OCaml में टिप्पणियां C ( /* ... */ ) में टिप्पणियों के समान हैं।

वर्तमान में कोई भी एक-पंक्ति टिप्पणी नहीं है (जैसे #... पर्ल में या // ... C99 / C ++ / Java में)। ## ... का उपयोग करने की संभावना पर एक बार चर्चा की गई थी, और मैं अत्यधिक अनुशंसा करता हूं कि ओकामलोव के कामरेड भविष्य में इस अवसर को जोड़ते हैं (हालांकि, अच्छे संपादकों ने अब भी एकल-पंक्ति टिप्पणियों का उपयोग करना संभव बना दिया है)।

OCaml में टिप्पणियाँ नेस्टेड हैं, यह टिप्पणी के साथ कोड के टुकड़ों पर टिप्पणी करना बहुत आसान बनाता है:
(* This code is broken ...

(* Primality test. *)
let is_prime n =
(* note to self: ask about this on the mailing lists *) XXX;;

*)


फंक्शन कॉल

मान लीजिए कि आपने कोई फ़ंक्शन लिखा है, तो इसे बार-बार कॉल करें, जो मूल स्ट्रिंग s, संख्या n को लेता है, और एक नया स्ट्रिंग देता है जिसमें बार-बार स्ट्रिंग s होता है।

अधिकांश सी-लाइक भाषाओं में, एक फ़ंक्शन कॉल इस तरह दिखाई देगी:
repeated ("hello", 3) /* this is C code */

इसका मतलब है "दो तर्कों के साथ दोहराया फ़ंक्शन को कॉल करें, पहला तर्क स्ट्रिंग हैलो है, दूसरा तर्क नंबर 3 है"।

ओमेक्एल में अन्य कार्यात्मक प्रोग्रामिंग भाषाओं की तरह, फ़ंक्शन कॉल की रिकॉर्डिंग और कोष्ठक का उपयोग काफी अलग है, जो कई त्रुटियों की ओर जाता है। यहाँ OCaml पर रिकॉर्ड किए गए उसी कॉल का एक उदाहरण है: repeated "hello" 3 (* this is OCaml code *) ।

कृपया ध्यान दें कि तर्क के बीच कोई कोष्ठक, कोई अल्पविराम नहीं हैं।

OCaml के दृष्टिकोण से अभिव्यक्ति repeated ("hello", 3) जाता है। इसका मतलब है "एक तर्क के साथ दोहराया फ़ंक्शन को कॉल करें, जो एक दो-तत्व जोड़ी संरचना है।" बेशक, यह एक त्रुटि का कारण होगा, क्योंकि दोहराया समारोह एक नहीं, बल्कि दो तर्क की उम्मीद करता है, और पहला तर्क एक स्ट्रिंग होना चाहिए, न कि एक जोड़ी। लेकिन, हम विशेष रूप से जोड़े (टुपल्स) के बारे में विवरण में नहीं जाएंगे। इसके बजाय, बस याद रखें: एक समारोह में तर्क पारित करते समय कोष्ठक और अल्पविराम का उपयोग करना एक गलती है।

एक अन्य फ़ंक्शन, प्रॉम्प्ट_स्ट्रिंग पर विचार करें, जो आमंत्रण पाठ के साथ एक स्ट्रिंग लेता है और उपयोगकर्ता इनपुट देता है। हम इस फ़ंक्शन के परिणाम को दोहराए गए फ़ंक्शन को पास करना चाहते हैं। यहाँ C और OCaml संस्करण हैं:

 / * C कोड: * /
 दोहराया (प्रॉम्प्ट_स्ट्रिंग ("नाम कृपया:"), 3)
 (* OCaml कोड: *)
 बार-बार (प्रॉम्प्ट_स्ट्रिंग "नाम कृपया:") 3

कोष्ठक और गायब अल्पविराम पर एक करीब से देखो। OCaml संस्करण में, दोहराए गए फ़ंक्शन का पहला तर्क, जो किसी अन्य फ़ंक्शन को कॉल करने का परिणाम है, को ब्रैकेट किया गया है। सामान्य नियम: "फ़ंक्शन तर्कों के आसपास कोष्ठक, फ़ंक्शन तर्कों के आसपास नहीं"। यहाँ कुछ और उदाहरण दिए गए हैं:

 f 5 (g "हैलो") 3 (* f में तीन तर्क हैं, g में एक * है)
 f (g 3 4) (* f में एक तर्क है, g में दो * हैं)

 # दोहराया गया ("हैलो", 3) ;;  (* OCaml एक त्रुटि फेंक देगा *)
 इस अभिव्यक्ति में टाइप स्ट्रिंग * int है लेकिन यहाँ टाइप स्ट्रिंग के साथ प्रयोग किया जाता है

कार्य की परिभाषा

मान लीजिए कि आप सभी जानते हैं कि परिचित भाषाओं में फ़ंक्शन (या जावा के लिए स्थिर तरीके) को कैसे परिभाषित किया जाए। लेकिन हम इसे OCaml में कैसे करते हैं?

OCaml के लिए वाक्यविन्यास सुरुचिपूर्ण और संक्षिप्त है। यहाँ एक फ़ंक्शन है जो दो फ़्लोटिंग पॉइंट तर्क देता है और औसत की गणना करता है:

 औसत औसत दें =
   (a + b।) / है।  2.0 ;;

इसे OCaml के टॉपलेवल पर सेट करें। (इसके लिए, यूनिक्स पर, ओसमल टाइप करें)। [नोट। प्रति। ubuntu / debian sudo एप्टीट्यूड के लिए ocaml स्थापित करें, suse / centos / fedora के लिए - sudo yum install ocaml]। आप देखेंगे:

 # औसत औसत =
   (a + b।) / है।  2.0 ;;
 वैल एवरेज: फ्लोट -> फ्लोट -> फ्लोट = <फन>

यदि आप किसी फ़ंक्शन की परिभाषा को देखते हैं और OCaml ने क्या लिखा है, तो आपके पास कुछ प्रश्न होंगे:

• अतिरिक्त अर्धविराम कोड में क्या करते हैं?
• इसका क्या अर्थ है कि float -> float -> float ?

हम इस प्रश्न का उत्तर निम्न वर्गों में देंगे, क्योंकि अब मैं C में समान फ़ंक्शन को परिभाषित करना चाहूंगा (यह जावा में समान दिखाई देगा), और मुझे कुछ और सवाल उठाने की उम्मीद है। यहाँ एक ही औसत फ़ंक्शन का C संस्करण है:

 दोहरा
 औसत (डबल डबल बी)
 {
   वापसी (ए + बी) / 2;
 }

OCaml पर अधिक कॉम्पैक्ट संस्करण के साथ तुलना करें। मुझे आशा है कि आपके पास प्रश्न हैं:

• हमने OCaml वर्जन में वेरिएबल टाइप a और b क्यों सेट नहीं किया है? OCaml ने कैसे परिभाषित किया? (और, सामान्य रूप से, OCaml प्रकार जानता है , या यह एक पूरी तरह से गतिशील भाषा है?)
• C में, संख्या 2 को दोगुना करने के लिए निहित है, क्या OCaml भी ऐसा कर सकता है?
• OCaml में लिखे गए रिटर्न स्टेटमेंट का एक एनालॉग कैसे है?

ठीक है, यहाँ कुछ जवाब दिए गए हैं:

• OCaml एक ऐसी भाषा है जिसमें मजबूत स्टेटिक टाइपिंग होती है (दूसरे शब्दों में, पर्ल में int, float और string के बीच कोई डायनेमिक कास्ट जैसी कोई जाति नहीं होती)
• OCaml प्रकारों को निर्धारित करने के लिए प्रकार के अनुमान का उपयोग करता है, इसलिए आपको इसे हाथ से करने की आवश्यकता नहीं है। यदि आप ऊपर दिए गए उदाहरण के अनुसार OCaml के शीर्ष स्तर पर कोड दर्ज करते हैं, तो OCaml आपके फ़ंक्शन में प्रकार का अनुमान लगाता है
• OCaml किसी भी निहित जाति को लागू नहीं करता है। यदि आप एक फ्लोट चाहते हैं, तो आपको स्पष्ट रूप से 2.0 लिखना होगा, क्योंकि 2 एक पूर्णांक है [लगभग। अनुवाद: अंग्रेजी में, अंश भाग को पूर्णांक बिंदु से अलग किया जाता है, और प्रकार को कहा जाता है, शाब्दिक रूप से, "अस्थायी बिंदु संख्या", इसलिए OCaml में, पूर्णांक और आंशिक भाग को अलग करने के लिए बिंदु का उपयोग किया जाता है]। OCaml स्वचालित रूप से int, float, string, या किसी अन्य प्रकार के बीच परिवर्तित नहीं होता है ।
• OCaml में टाइप इंफ़ेक्शन के साइड इफेक्ट के रूप में, फ़ंक्शंस (ऑपरेटरों सहित) को ओवरलोड नहीं किया जा सकता है। OCaml पूर्णांक जोड़ने के संचालन के रूप में + परिभाषित करता है। फ़्लोटिंग पॉइंट नंबर जोड़ने के लिए, +. उपयोग करें +. (प्लस साइन के बाद बिंदु पर ध्यान देना)। इसी तरह, -. का उपयोग किया जाता है -. , *. , /. अन्य अस्थायी बिंदु संचालन के लिए।
• OCaml में रिटर्न स्टेटमेंट नहीं है - किसी फ़ंक्शन में अंतिम अभिव्यक्ति स्वचालित रूप से फ़ंक्शन के मूल्य के रूप में उपयोग की जाती है।

हम निम्नलिखित अनुभागों और अध्यायों में इस सब पर अधिक विस्तार से चर्चा करेंगे।

मुख्य प्रकार

टाइप	मूल्य सीमा
पूर्णांक	32-बिट सिस्टम पर 31-बिट हस्ताक्षरित पूर्णांक और 64-बिट प्रोसेसर के साथ सिस्टम पर 63-बिट हस्ताक्षरित पूर्णांक
नाव	डबल सटीक फ्लोटिंग पॉइंट नंबर (IEEE), C में डबल के बराबर
bool	बूलियन, सच / गलत
चार	8 बिट चरित्र
तार	पंक्ति

OCaml स्वचालित मेमोरी प्रबंधन (कचरा संग्रह) के लिए डेटा स्टोर करने के लिए इंट बिट्स में से एक का उपयोग करता है। यही कारण है कि अंतर आयाम 31 बिट्स है, न कि 32 बिट्स (64-बिट सिस्टम के लिए 63 बिट्स)। सामान्य उपयोग में, यह कुछ विशिष्ट मामलों को छोड़कर, कोई समस्या नहीं है। उदाहरण के लिए, यदि आप लूप में कुछ गिनते हैं, तो OCaml 2. के बजाय पुनरावृत्तियों की संख्या को 1 बिलियन तक सीमित कर देता है। यह कोई समस्या नहीं है, क्योंकि यदि आप किसी भी भाषा में int सीमा के करीब कुछ गिनाते हैं, तो आपको बड़ी संख्या के साथ काम करने के लिए विशेष मॉड्यूल का उपयोग करना चाहिए (OCaml में नेट और बिग_इंट मॉड्यूल)। हालाँकि, 32-बिट मान (उदाहरण के लिए, क्रिप्टो कोड या नेटवर्क स्टैक कोड) को nativeint करने के लिए, OCaml प्लेटफ़ॉर्म पर पूर्णांक nativeint अनुरूप एक nativeint प्रकार प्रदान करता है।

OCaml में एक अहस्ताक्षरित पूर्णांक के आधार पर आधार प्रकार नहीं होता है, हालाँकि, आप इसे nativeint का उपयोग करके प्राप्त कर सकते हैं। जहाँ तक मुझे पता है, OCaml के पास एक भी सटीक फ़्लोटिंग पॉइंट सपोर्ट नहीं है।

OCaml में, char type का उपयोग टेक्स्ट में अक्षरों को दर्शाने के लिए किया जाता है। दुर्भाग्य से, char प्रकार न तो यूनिकोड का समर्थन करता है, न ही मल्टीबाइट एन्कोडिंग के रूप में, न ही यूटीएफ -8 के रूप में। यह ओकेमेल में एक गंभीर दोष है जिसे ठीक करने की आवश्यकता है, लेकिन अभी के लिए यूनिकोड समर्थन के लिए व्यापक पुस्तकालय हैं जो मदद करनी चाहिए।

स्ट्रिंग्स सिर्फ बाइट्स का एक क्रम नहीं हैं। वे अपने स्वयं के, अधिक कुशल भंडारण विधि का उपयोग करते हैं।

unit प्रकार C में void प्रकार के लिए कुछ समानता है, लेकिन हम इसके बारे में बाद में बात करेंगे।

स्पष्ट टाइपिंग बनाम निहित

सी-जैसी भाषाओं में, कुछ निश्चित परिस्थितियों में पूरा एक फ्लोटिंग-पॉइंट नंबर में बदल जाता है। उदाहरण के लिए, यदि आप 1 + 2.5 लिखते हैं, तो पहला तर्क (पूर्णांक) एक फ्लोटिंग पॉइंट पर डाला जाएगा, और परिणाम भी एक फ़्लोटिंग पॉइंट होगा। यह स्पष्ट रूप से ((double)1)+2.5 लिखकर प्राप्त किया जा सकता है।

OCaml कभी भी अंतर्निहित प्रकार रूपांतरण नहीं करता है OCaml 1 + 2.5 एक प्रकार की त्रुटि है। इसके अलावा ऑपरेटर को दो पूर्णांक तर्कों की आवश्यकता होती है और यदि कोई एक तर्क एक फ्लोटिंग पॉइंट संख्या है तो त्रुटि की रिपोर्ट करता है:

 # 1 + 2.5 ;;
       ^^^
 इस अभिव्यक्ति में टाइप फ्लोट है, लेकिन यहां टाइप इंट के साथ प्रयोग किया जाता है

(एक विशिष्ट भाषा में, "फ्रांसीसी से अनुवाद", त्रुटि संदेश का अर्थ है "आप यहां एक अस्थायी बिंदु रखते हैं, और मुझे पूरी उम्मीद है") [लगभग। अनुवाद: ओमेक्एल को फ्रेंच द्वारा विकसित किया गया था और लेखक ने फ्रेंच से अंग्रेजी में त्रुटि संदेशों के असफल अनुवाद पर मजाक उड़ाया था]।

दो फ़्लोटिंग पॉइंट संख्याओं को जोड़ने के लिए, एक अन्य ऑपरेटर, +. (बिंदु पर ध्यान दें)।

OCaml पूर्णांक को फ्लोटिंग पॉइंट पर नहीं डालता है, इसलिए यह भी एक त्रुटि है:

 # 1 +।  2.5 ;;
   ^
 इस अभिव्यक्ति का प्रकार int है लेकिन यहाँ प्रकार फ़्लोट के साथ प्रयोग किया जाता है

OCaml अब पहले तर्क के बारे में शिकायत करता है।

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

 (float_of_int i) +  एफ ;;

float_of_int एक फ़ंक्शन है जो पूर्णांक लेता है और एक अस्थायी बिंदु संख्या देता है। ऐसे कार्यों का एक पूरा समूह है जो समान कार्यों को करता है, जिसे कुछ इस तरह कहा जाता है: int_of_float , char_of_int , int_of_char, string_of_int । अधिकांश भाग के लिए, वे वही करते हैं जो उनसे अपेक्षित होता है।

चूंकि फ्लोट में इंट को परिवर्तित करना बहुत आम है, float_of_int में एक छोटा उपनाम है। ऊपर के उदाहरण के रूप में लिखा जा सकता है

 फ्लोट i +।  एफ ;;

(नोट, C के विपरीत, OCaml में, फ़ंक्शन और प्रकार दोनों का एक ही नाम हो सकता है)।

कौन सा बेहतर है - स्पष्ट या निहित कास्ट?

आप सोच सकते हैं कि स्पष्ट कास्टिंग बदसूरत है, कि यह एक कठिन काम है। कुछ मायनों में आप सही हैं, लेकिन स्पष्ट कलाकारों के पक्ष में कम से कम दो तर्क हैं। सबसे पहले, OCaml स्पष्ट प्रकार के रूपांतरण का उपयोग करता है ताकि प्रकार के अनुमान (नीचे देखें) को सक्षम किया जा सके, और प्रकार का अनुमान एक ऐसा अद्भुत और समय बचाने वाला कार्य है कि यह स्पष्ट रूप से टाइप करने पर अतिरिक्त बटन दबाता है। दूसरे, यदि आपने कम से कम एक बार सी प्रोग्राम डिबग किया है, तो आप जानते हैं कि (ए) निहित टाइपिंग त्रुटियों को खोजने में मुश्किल होती है, और (बी) जब आप बैठते हैं और यह पता लगाने की कोशिश करते हैं कि अंतर्निहित टाइपिंग ने कहां काम किया है। स्पष्ट टाइपिंग की आवश्यकता डीबगिंग में मदद करती है। तीसरा, कुछ प्रकार के कास्ट (विशेष रूप से पूर्णांक <-> फ्लोटिंग पॉइंट) वास्तव में बहुत महंगे ऑपरेशन हैं। आप उन्हें अंतर्निहित टाइपिंग में छिपाकर एक असहमति करते हैं।

सामान्य और पुनरावर्ती कार्य

सी-लाइक भाषाओं के विपरीत, फ़ंक्शन तब तक पुनरावृत्ति की अनुमति नहीं देते हैं जब तक कि सामान्य let rec बजाय let rec एक्सप्रेशन का उपयोग करके स्पष्ट रूप से निर्दिष्ट नहीं किया जाता है let यहां एक पुनरावर्ती फ़ंक्शन का एक उदाहरण है:

 लेट रे रेंज एब =
   अगर a> b तो []
   और एक :: रेंज (ए + 1) बी
   ;;

ध्यान दें कि सीमा स्वयं कॉल करती है।

let rec and let rec बीच का अंतर केवल फ़ंक्शन नाम का कार्यक्षेत्र है। यदि ऊपर दिए गए उदाहरण से फ़ंक्शन केवल let का उपयोग करके परिभाषित किया गया था, तो range फ़ंक्शन को कॉल करना एक मौजूदा (पहले से परिभाषित) फ़ंक्शन के लिए खोज करेगा, जिसे राइट-अब-परिभाषित फ़ंक्शन के बजाय range कहा जाता है। let (बिना rec ) का उपयोग करना आपको पिछली परिभाषा के टर्मिनल में मूल्य को फिर से परिभाषित करने की अनुमति देगा। उदाहरण के लिए:

 let पॉजिटिव_सम एब = 
     आज्ञा देना = एक अधिकतम ०
     और बी = अधिकतम बी 0 में
     ए + बी

ओवरराइडिंग फ़ंक्शन परिभाषा से पिछले "बाइंडिंग" a और b छुपाता है। कुछ स्थितियों में, प्रोग्रामर नए वेरिएबल्स का उपयोग करने के लिए इस दृष्टिकोण को प्राथमिकता let a_pos = max a 0 ( let a_pos = max a 0 ) क्योंकि यह पुराने बाइंडिंग को अनुपलब्ध बनाता है, जिससे केवल a और b के नवीनतम मान b ।

let rec माध्यम से फ़ंक्शंस को परिभाषित करना, प्रदर्शन की तुलना में किसी भी तरह के प्रदर्शन में बदलाव नहीं करता है, इसलिए यदि आप चाहें, तो आप हमेशा सी-लाइक भाषाओं के समान व्यवहार प्राप्त करने के लिए let rec फॉर्म का उपयोग कर सकते हैं।

टाइपिंग फ़ंक्शन मान

टाइप इंट्रेंस के लिए धन्यवाद, आपको फ़ंक्शन द्वारा लौटाए गए मान के प्रकार को स्पष्ट रूप से निर्दिष्ट करना होगा। हालांकि, OCaml अक्सर आपके कार्यों के वापसी प्रकार के बारे में क्या सोचता है, इस तरह का उल्लंघन करता है, इसलिए आपको ऐसी प्रविष्टियों के लिए सिंटैक्स पता होना चाहिए। एक फ़ंक्शन f जो arg 1 , arg 2 , ... arg n लेता है, और एक rettype संकलक काम करेगा:

 f: arg1 -> arg2 -> ... -> argn -> rettype

तीर का उपयोग करने वाला वाक्यविन्यास असामान्य लगता है, लेकिन फिर हम तथाकथित व्युत्पन्न कार्यों (करी) में आते हैं, आप समझेंगे कि ऐसा क्यों है। आइए हम कुछ उदाहरण देते हैं।

हमारा repeated कार्य एक स्ट्रिंग लेता है और एक पूर्णांक एक स्ट्रिंग लौटाता है। इसका प्रकार इस प्रकार है:

 दोहराया: स्ट्रिंग -> इंट -> स्ट्रिंग

हमारा average फ़ंक्शन, जो दो फ़्लोटिंग पॉइंट नंबर लेता है और एक फ़्लोटिंग पॉइंट नंबर देता है, इस तरह वर्णित है:

 औसत: फ्लोट -> फ्लोट -> फ्लोट

मानक OCaml फ़ंक्शन int_of_char :

 int_of_char: char -> इंट

यदि फ़ंक्शन कुछ भी नहीं देता है (सी और जावा के लिए void ), तो हम लिखते हैं कि यह टाइप unit लौटाता है। उदाहरण के लिए, यह ऐसा है कि OCaml पर fputs फ़ंक्शन का एनालॉग कैसे दिखता है:

 output_char: out_channel -> char -> यूनिट

बहुरूपी कार्य

अब थोड़ा और अजीब है। एक फ़ंक्शन के बारे में क्या तर्क के रूप में कुछ भी लेता है? यहाँ एक असामान्य फ़ंक्शन का एक उदाहरण है जो एक तर्क लेता है, लेकिन इसे अनदेखा करता है और हमेशा 3 नंबर देता है:

  let_me_a_three x = 3 ;; 

यह किस प्रकार का कार्य है? OCaml एक विशेष विकल्प का उपयोग करता है, जिसका अर्थ है "जो भी आपकी आत्मा की इच्छा है।" यह एक पत्र के बाद एक एकल उद्धरण है। ऊपर दिए गए फ़ंक्शन का प्रकार निम्नानुसार है:

 give_me_a_three: 'a -> int

जहाँ 'a का वास्तविक अर्थ है "कोई भी प्रकार।" उदाहरण के लिए, आप इस फ़ंक्शन को give_me_a_three "foo" या give_me_a_three 2.0 । दोनों विकल्प OCaml के दृष्टिकोण से समान रूप से सही होंगे।

यह बहुत स्पष्ट नहीं है कि पॉलीमॉर्फिक फ़ंक्शन उपयोगी क्यों हैं, लेकिन वास्तव में वे बहुत उपयोगी और बहुत आम हैं; हम बाद में उनकी चर्चा करेंगे। (संकेत: पॉलीफ़िज़्म C ++ में पैटर्न या जावा में जेनेरिक जैसा कुछ है)।

प्रकार का अनुमान

इस ट्यूटोरियल का विषय यह विचार है कि कार्यात्मक भाषाओं में कई कूल विशेषताएँ होती हैं और OCaml एक ऐसी भाषा है जिसमें सभी कूल सुविधाएँ एक ही स्थान पर इकट्ठी होती हैं, जो वास्तविक प्रोग्रामर के लिए बहुत उपयोगी होती हैं। लेकिन यहाँ अजीब बात है - इनमें से अधिकांश उपयोगी सुविधाओं का "कार्यात्मक प्रोग्रामिंग" से कोई लेना-देना नहीं है। वास्तव में, मैं पहले कूल फ़िच में गया और मैंने अभी भी एक शब्द भी नहीं कहा है कि कार्यात्मक प्रोग्रामिंग को "कार्यात्मक" क्यों कहा जाता है। किसी भी मामले में, यहां पहला कूल फ़ीचर है: टाइप इंफ़ेक्शन।

सीधे शब्दों में कहें, तो आपको अपने कार्यों और चर के लिए प्रकारों को घोषित करने की आवश्यकता नहीं है, क्योंकि OCaml यह आपके लिए करेगा।

इसके अलावा, OCaml आपके लिए कई फाइलों के बीच भी सभी प्रकार की जाँच करेगा।

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

आइए average फ़ंक्शन पर वापस जाएं, जिसे OCaml के शीर्ष स्तर पर पेश किया गया था।

 # औसत औसत =
   (a + b।) / है।  2.0 ;;
 वैल एवरेज: फ्लोट -> फ्लोट -> फ्लोट = <फन>

मीराबाइल तानाशाह! OCaml ने खुद सब कुछ किया, यह निर्धारित किया कि फ़ंक्शन दो फ़्लोट्स लेता है और एक फ़्लोट लौटाता है।

कैसे? पहले हम देखते हैं कि a और b उपयोग अभिव्यक्ति (a + . b) । चूंकि .+ फ़ंक्शन को दो फ़्लोटिंग पॉइंट तर्क की आवश्यकता के लिए जाना जाता है, एक साधारण कटौती यह घटा सकती है कि a b float .

, /. float, , , average , average float. :
average : float -> float -> float
, , , . , , , NullPointerException ClassCastException (, , , , Perl). a b float .

, /. float, , , average , average float. :
average : float -> float -> float
, , , . , , , NullPointerException ClassCastException (, , , , Perl).

 a  b     float . 
 
 ,  /.   float,   ,   ,     average ,   average   float.         : 
 average : float -> float -> float 
  , ,    ,         .    ,       ,  , NullPointerException  ClassCastException    (,  ,   ,     ,  Perl). 

a b float .

, /. float, , , average , average float. :
average : float -> float -> float
, , , . , , , NullPointerException ClassCastException (, , , , Perl).